From 761174c08b1cceb0e9ccc37005bfca9f7958b25a Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 18 Mar 2020 16:10:11 +0800
Subject: [PATCH 001/213] add opengl notes

---
 ...71\345\271\225\345\256\236\347\216\260.md" |    2 +
 ...00\201MediaCodec\343\200\201MediaMuxer.md" |    0
 .../1.OpenGL\347\256\200\344\273\213.md"      |  254 +++
 .../10.OpenGL ES\346\273\244\351\225\234.md"  |   60 +
 ....GLSurfaceView\347\256\200\344\273\213.md" |  216 ++
 ...20\347\240\201\350\247\243\346\236\220.md" |  690 ++++++
 ....GLTextureView\345\256\236\347\216\260.md" | 1974 +++++++++++++++++
 ...66\344\270\211\350\247\222\345\275\242.md" |  863 +++++++
 ...42\345\217\212\345\234\206\345\275\242.md" |  511 +++++
 ...45\231\250\350\257\255\350\250\200GLSL.md" |  232 ++
 ...\261\273\345\217\212Matrix\347\261\273.md" |  143 ++
 .../8.OpenGL ES\347\272\271\347\220\206.md"   |  547 +++++
 ...55\346\224\276\350\247\206\351\242\221.md" |  108 +
 .../OpenGL\347\256\200\344\273\213.md"        |   52 -
 .../SurfaceView\344\270\216TextureView.md"    |    2 +-
 .../\345\205\263\351\224\256\345\270\247.md"  |   41 +-
 ...72\347\241\200\347\237\245\350\257\206.md" |   78 +-
 17 files changed, 5717 insertions(+), 56 deletions(-)
 rename "VideoDevelopment/Android\345\274\271\345\271\225\345\256\236\347\216\260.md" => "VideoDevelopment/Danmaku/Android\345\274\271\345\271\225\345\256\236\347\216\260.md" (99%)
 rename "VideoDevelopment/GLSurfaceView\347\256\200\344\273\213.md" => "VideoDevelopment/MediaExtractor\343\200\201MediaCodec\343\200\201MediaMuxer.md" (100%)
 create mode 100644 "VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
 create mode 100644 "VideoDevelopment/OpenGL/10.OpenGL ES\346\273\244\351\225\234.md"
 create mode 100644 "VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
 create mode 100644 "VideoDevelopment/OpenGL/3.GLSurfaceView\346\272\220\347\240\201\350\247\243\346\236\220.md"
 create mode 100644 "VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md"
 create mode 100644 "VideoDevelopment/OpenGL/4.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"
 create mode 100644 "VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"
 create mode 100644 "VideoDevelopment/OpenGL/6.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
 create mode 100644 "VideoDevelopment/OpenGL/7.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
 create mode 100644 "VideoDevelopment/OpenGL/8.OpenGL ES\347\272\271\347\220\206.md"
 create mode 100644 "VideoDevelopment/OpenGL/9.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
 delete mode 100644 "VideoDevelopment/OpenGL\347\256\200\344\273\213.md"

diff --git "a/VideoDevelopment/Android\345\274\271\345\271\225\345\256\236\347\216\260.md" "b/VideoDevelopment/Danmaku/Android\345\274\271\345\271\225\345\256\236\347\216\260.md"
similarity index 99%
rename from "VideoDevelopment/Android\345\274\271\345\271\225\345\256\236\347\216\260.md"
rename to "VideoDevelopment/Danmaku/Android\345\274\271\345\271\225\345\256\236\347\216\260.md"
index 66136f9d..6a0ef80d 100644
--- "a/VideoDevelopment/Android\345\274\271\345\271\225\345\256\236\347\216\260.md"
+++ "b/VideoDevelopment/Danmaku/Android\345\274\271\345\271\225\345\256\236\347\216\260.md"
@@ -84,6 +84,8 @@
 
 #### 自定义TextureView
 
+#### OpenGL实现
+
 
 
 
diff --git "a/VideoDevelopment/GLSurfaceView\347\256\200\344\273\213.md" "b/VideoDevelopment/MediaExtractor\343\200\201MediaCodec\343\200\201MediaMuxer.md"
similarity index 100%
rename from "VideoDevelopment/GLSurfaceView\347\256\200\344\273\213.md"
rename to "VideoDevelopment/MediaExtractor\343\200\201MediaCodec\343\200\201MediaMuxer.md"
diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..0c7f6f70
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -0,0 +1,254 @@
+## 1.OpenGL简介
+
+[OpenGL官网]（https://www.opengl.org/）
+
+OpenGL(Open Graphics Library开发图形库)是用于渲染2D、3D矢量图形的跨语言、跨平台的应用程序编程接口。
+
+OpenGL的前身是硅谷图形功能(SGI)公司为其图形工作站开发的IRIS GL,后来因为IRIS GL的移植性不好，所以在其基础上，开发出了OpenGl。OpenGl一般用于在图形工作站，PC端使用，由于性能各方面原因，在移动端使用OpenGl基本带不动。为此，Khronos公司就为OpenGl提供了一个子集，OpenGl ES(OpenGl for Embedded System)。
+
+
+
+### OpenGL ES
+
+[OpenGL ES 官网]（https://www.khronos.org/opengles/）
+
+OpenGL ES是免费的跨平台的功能完善的2D/3D图形库接口的API,是OpenGL的一个子集,主要针对手机、Pad和游戏主机等嵌入式设备而设计。
+
+移动端使用到的基本上都是OpenGl ES，当然Android开发下还专门为OpenGl提供了android.opengl包，并且提供了GlSurfaceView,GLU,GlUtils等工具类。
+
+
+
+### OpenGL的作用
+
+
+
+手机上做图像处理用很多方法，但是目前为止最高效的方法就是有效的使用图形处理单元(GPU)，图像的处理和渲染就是在将要渲染到窗口上的像素上做很多的浮点匀速，而GPU可以并行的做浮点运算，所以用GPU来分担CPU的部分，可以提高效率。
+
+- 图片处理:比如图片色调转换、美颜等。
+- 摄像头预览效果处理。比如美颜相机、恶搞相机等。
+- 视频处理。视频播放的时候增加一些滤镜效果。
+- 3D游戏。比如神庙逃亡、都市赛车等。
+
+
+
+### Android中的OpenGL ES
+
+Android中OpenGL ES的版本支持如下:  
+
+- OpenGL ES 1.0 和 1.1 - 此 API 规范受 Android 1.0 及更高版本的支持。
+- OpenGL ES 2.0 - 此 API 规范受 Android 2.2（API 级别 8）及更高版本的支持。
+- OpenGL ES 3.0 - 此 API 规范受 Android 4.3（API 级别 18）及更高版本的支持。
+- OpenGL ES 3.1 - 此 API 规范受 Android 5.0（API 级别 21）及更高版本的支持。
+
+
+
+###  渲染管线
+
+OpenGL 1.x系列采用的是固定功能管线。
+
+OpenGL ES 2.0开始采用了可编程图形管线。
+
+OpenGL ES 3.0兼容了2.0，并丰富了更多功能。
+
+OpenGL渲染管线的流程为: 顶点数据 -> 顶点着色器 -> 图元装配 -> 几何着色器 -> 光栅化 -> 片段着色器 -> 逐片段处理 -> 帧缓冲   
+
+如下图，阴影的表示OpenGL ES 3.0管线中可编程阶段。
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/oepngl_es_pip.jpg)
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_progress.jpg)
+
+
+
+- 顶点着色器(Vertex Shader): 用来渲染图形顶点的OpenGL ES代码。生成每个顶点的最终位置
+
+   着色器(shader)是在GPU上运行的小程序。从名称可以看出，可通过处理它们来处理顶点。此程序使用OpenGL ES SL语言来编写。它是一个描述顶点或像素特性的简单程序。OpenGL最本质的概念之一就是着色器，它是图形硬件设备所执行的一类特殊函数。理解着色器最好的办法就是把它看做是专为图形处理单元(即GPU)编译的一种小型程序。任何一种OpenGL程序本质上都可以被分为两部分：CPU端运行的部分，采用C++、Java之类的语言编写；以及GPU端运行的部分，使用GLSL语言编写。
+
+  顶点着色器可以操作的属性有: 位置、颜色、纹理坐标，但是不能创建新的顶点。最终产生纹理坐标、颜色、点位置等信息送往后续阶段。
+
+- 图元装配(Primitive Assembly)
+
+  顶点组合成图元的过程叫做图元装配，这里的图元就是指点、线、三角。OpenGL ES中最基础且唯一的多边形就是三角形，所有更复杂的图形都是由三角形组成的。复杂的图形都可以拆分成多个三角形。比如OpenGL提供给开发者的绘制方法glDrawArrays，这个方法的第一个参数就是指定绘制方式，可选值有:  
+
+  - GL_POINTS:以点的形式绘制
+  - GL_LINES:以线的形式绘制
+  - GL_TRIANGLE_STRIP:以三角形的形式绘制，所有二维图像的渲染都会使用这种方式。
+
+  该过程还有两个重要操作：裁剪和淘汰。
+
+  - 裁剪是指对于不在视椎体(屏幕上可见的3D区域)内的图元进行裁剪。
+
+  - 淘汰是指根据图元面向前方或后方选择排期它们(如事物内部的点)。
+
+- 光栅化阶段(Rasterization Stage)
+
+  这里会把图元映射为最终屏幕上相应的像素，生成供片段着色器(fragment shader)使用的片段。在图元装配后传递过来的图元数据中，这些图元信息只是顶点而已。顶点处都还没有像素点，直线段端点之间是空的、多边形的边和内部也是空的，光栅化的任务就是构造这些。将图片转化为片段(fragment)的过程叫做光栅化。 这个阶段会将图元数据分解成更小的单元并对应于帧缓冲区的各个像素，这些单元成为片元，一个片元可能包含窗口颜色、纹理坐标等属性。
+
+  光栅化其实是一种将几何图元变成二维图像的过程。在这里，虚拟3D世界中的物体投影到平面上，并生成一系列的片段。  
+
+- 片段着色器或片元着色器(Fragment Shader):使用颜色或纹理(texture)渲染图形表面的OpenGLES代码。
+
+  主要目的是计算一个像素的最终颜色。光栅化操作构造了像素点，这个阶段就是处理这些像素点，根据自己的业务，例如高亮、饱和度调节、高斯模糊等来变化这个片元的颜色。为组成点、直线和三角形的每个片元生成最终颜色/纹理，针对每个片元都会执行一次，一个片元是一个小的、单一颜色的长方形区域，类似于计算机屏幕上的一个像素。一旦最终颜色生成，OpenGL就会把它们写到一块成为帧缓冲区的内存块中，然后Android就会把这个帧缓冲区显示到屏幕上。
+
+  通常在这里对片段进行处理(纹理采样、颜色汇总等)，将每个片段的颜色等属性计算出来并送给后续阶段。
+
+- 逐片段操作
+
+  具体的细分步骤又分为:  
+
+  ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_fragment_opera.jpg)
+
+  - 像素归属测试
+
+    判断当前像素是否归OpenGL所有，即OpenGLES帧缓冲区窗口的部分是否被另一个窗口所遮蔽，被遮挡像素不属于OpenGL上下文。
+
+  - 裁剪测试
+
+    判断当前像素是否位于裁剪矩形范围内，如果位于裁剪区域外则被抛弃。
+
+  - 模板测试
+
+    模板测试主要将绘制区域限定在一定范围内，一般用在湖面倒影、镜像等场合。
+
+  - 深度测试
+
+    深度测试是将输入片元的深度与帧缓冲区中对应片元的深度进行比较，确定片段是否应该被拒绝。
+
+  - 混合
+
+    将新生成的片段和保存在缓冲区的片段进行混合。
+
+  - 抖动
+
+    用于最小化，因为使用有限精度在帧缓冲区中保存颜色值而产生的伪像，使用少量颜色模拟更宽的颜色范围。
+
+- 帧缓冲区
+
+  OpenGL管线的最终渲染目的地被称为帧缓存(framebuffer也被记做FBO)
+
+- 着色器语言
+
+  GLSL(OpenGL Shading Language)是OpenGL着色语言。
+
+  在图形卡的GPU上执行，代替了固定的渲染管线的一部分，是渲染管线中不同层次具有可编程性，例如：视图转换、投影转换等。GLSL的着色器代码分为两个部分: 
+
+  - 顶点着色器(Vertex Shader)
+  - 片段着色器(Fragment Shader)
+
+- 坐标系
+
+  OpenGL ES采用虚拟坐标系
+
+  ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_xy.png)
+
+  OpenGL ES采用的是右手坐标，选取屏幕中心为原点，从原点到屏幕边缘默认长度为1，也就是默认情况下，从原点到x左边的1和到y左边的1的位置在屏幕上显示的并不相同。
+
+- 形状面和缠绕
+
+  在OpenGL的世界里，我们只能画点、线、三角形，图元装配中说到所有复杂的图形都是由三角形组成。
+
+  ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_ex_xy_1.jpg)
+
+  三角形的点按顺序定义，使得它们以逆时针方向绘制。绘制这些坐标的顺序定义了形状的缠绕方向。默认情况下，在OpenGL中，逆时针绘制的面是正面。
+
+- 程式(Program)
+
+  一个OpenGL ES对象，包含了你所希望用来绘制图形所要用到的着色器，最后顶点着色器和片元着色器都要放入到程式中，然后才可以使用，简单的说就是将两个着色器变为一个对象。
+
+
+
+如果想要绘制图像，需要至少一个顶点着色器来定义一个图形顶点，以及一个片元着色器为该图形上色。这些着色器必须被编译然后再添加到一个OpenGL ES Program中，并利用这个Program来绘制形状。
+
+
+
+### OpenGL Context
+
+OpenGL是一个仅仅关注图像渲染的图像接口库，在渲染过程中它需要将顶点信息、纹理信息、编译好的着色器等渲染状态信息存储起来，而存储这些信调用任何OpenGL函数前，必须先创建OpenGL Context，它存储了OpenGL的状态变量以及其他渲染有关的信息。OpenGL是个状态机，有很多状态变量，试个标准的过程式操作过程，改变状态会影响后续所有的操作，这和面向对象的解耦原则不符，毕竟渲染本身就是个复杂的过程。OpenGL采用Client-Server模型来解释OpenGL程序，即Server存储OpenGL Context，Client提出渲染请求，Server给予响应。之后的渲染工作就要依赖这些渲染状态信息来完成，当一个上下文被销毁时，它所对应的OpenGL渲染工作也将结束。
+
+
+
+### EGL
+
+在OpenGL的设计中，OpenGL是不负责管理窗口的，窗口的管理交由各个设备自己完成。具体的来说就是iOS平台上使用EAGL提供本地平台对OpenGL的实现，在Android平台上使用EGL提供本地平台对OpenGL的实现。OpenGL其实是通过GPU进行渲染。但是我们的程序是运行在CPU上，要与GPU关联，这就需要通过EGL，它相当于Android上层应用于GPU通讯的中间层。
+
+EGL为双缓冲工作模式，既有一个Back Frame Buffer和一个Front Frame Buffer，正常绘制的目标都是Back Frame Buffer，绘制完成后再调用eglSwapBuffer API，将绘制完毕的FrameBuffer交换到Front Frame Buffer并显示出来。   
+
+要在Android平台实现OpenGL渲染，需要完成一系列的EGL操作，主要为下面几步:   
+
+1. 获取显示设备(EGL Display)
+
+   获取将要用于显示的设备，有些系统具有多个显示器，会存在多个display，在Android上通过调用EGL10的eglGetDisplay(Object native_display)方法获得EGLDisplay对象，通常传入的参数为EGL10.EGL_DEFAULT_DISPLAY。
+
+2. 初始化EGL
+
+   调用EGL10的egInitialize(EGLDisplay display, int[] major_minor)方法完成初始化操作。display参数即为上一步获取的对象，major_minor传入的是一个int数据，通常传入的是一个大小为2的数据。
+
+3. 选择Config配置
+
+   调用EGL10的eglChooseConfig(EGLDisplay display, int[] attire_list, EGLConfig[] configs, int config_size, int[] num_config)方法，参数3用于存放输出的configs，参数4指定最多输出多少个config，参数5由EGL系统写入，表明满足attributes的config一共有多少个。
+
+4. 创建EGL Context
+
+   eglCreateContext(EGLDisplay display, EGLConfig config, EGLContext share_context, int[] attrib_list);参数1即为上面获取的Display,参数2为上一步chooseConfig传入的configs，share_context,是否有context共享，共享的contxt之间亦共享所有数据,通常设置为EGL_NO_CONTEXT代表不共享。attrib_list为int数组 {EGL_CONTEXT_CLIENT_VERSION, 2,EGL10.EGL_NONE };中间的2代表的是OpenGL ES的版本。
+
+5. 创建EGLSurface
+
+   eglCreateWindowSurface(EGLDisplay display, EGLConfig config, Object native_window, int[] attrib_list);参数1、2均为上述步骤得到的结果，参数3为上层创建的用于绘制内容的surface对象，参数4常设置为null。
+
+6. 设置OpenGL的渲染环境
+
+   eglMakeCurrent(EGLDisplay display, EGLSurface draw, EGLSurface read, EGLContext context);该方法的参数意义很明确，该方法在异步线程中被调用，该线程也会被成为GL线程，一旦设定后，所有OpenGL渲染相关的操作都必须放在该线程中执行。
+
+   通过上述操作，就完成了EGL的初始化设置，便可以进行OpenGL的渲染操作。
+
+
+
+#### OpenGL纹理
+
+纹理(Texture)是一个2D图片(也有1D和3D纹理)，他可以用来添加物体的细节，你可以想象纹理是一张绘有砖块的纸，无缝折叠贴合到你的3D房子上，这样你的房子看起来就有砖墙的外表了。
+
+
+
+Android 通过其框架 API 和原生开发套件 (NDK) 来支持 OpenGL。
+
+Android 框架中有如下两个基本类，用于通过 OpenGL ES API 来创建和操控图形：`GLSurfaceView` 和 `GLSurfaceView.Renderer`。
+
+
+
+
+
+参考
+
+---
+
+- [https://blog.csdn.net/gongxiaoou/article/details/89199632](https://blog.csdn.net/gongxiaoou/article/details/89199632)
+- [https://blog.csdn.net/junzia/category_6462864.html](https://blog.csdn.net/junzia/category_6462864.html)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/OpenGL/10.OpenGL ES\346\273\244\351\225\234.md" "b/VideoDevelopment/OpenGL/10.OpenGL ES\346\273\244\351\225\234.md"
new file mode 100644
index 00000000..026edc95
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/10.OpenGL ES\346\273\244\351\225\234.md"	
@@ -0,0 +1,60 @@
+## 10.OpenGL ES滤镜
+
+滤镜其实就是利用纹理。
+
+滤镜的编写主要是靠基类。
+
+- 先抽取BaseFilter类，封装好每个滤镜的着色器及onDraw等方法
+- 不同的滤镜集成该BaseFilter类
+- 在Renderder接口的实现类中去创建不同的Filter类，然后在onDrawFrame方法中去调用该filter.onDraw方法
+
+滤镜的不同大部分只需要修改片元着色器就可以了。
+
+
+
+### 反色滤镜
+
+RGB三个通道的颜色取反，而alpha通道不变。
+
+### 灰色滤镜
+
+让RGB三个通道的颜色取均值
+
+### 位移滤镜
+
+纹理默认传入的读取范围是(0,0)到(1,1)内的颜色值。如果对读取的位置进行调整修改，那么就可以做出各种各样的效果，例如缩放动画就是让读取的范围改成(-1,-1)到(2,2)。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..d3d7b314
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
@@ -0,0 +1,216 @@
+## 2.GLSurfaceView简介
+
+Android 通过其框架 API 和原生开发套件 (NDK) 来支持 OpenGL。
+
+Android 框架中有如下两个基本类，用于通过 OpenGL ES API 来创建和操控图形：`GLSurfaceView` 和 `GLSurfaceView.Renderer`。也就是说我们想在Android中使用OpenGL ES的最简单的方法就是将我们要显示的图像渲染到GLSurfaceView上，但它只是一个展示类，至于怎么渲染到上面我们就要自己去实现GLSurfaceView.Renderer来生成我们自己的渲染器从而完成渲染操作。    
+
+######## GLSurfaceView(使用OpenGL绘制的图形的视图容器)
+
+SurfaceView在View的基础上创建了独立的Surface，拥有SurfaceHolder来管理它的Surface，渲染的工作可以不再主线程中做。可以通过SurfaceHolder得到Canvas，在单独的线程中，利用Canvas绘制需要显示的内容，然后更新到Surface上。
+
+GLSurfaceView继承自SurfaceView，它主要是在SurfaceView的基础上加入了EGL的管理，并自带了一个GLThread的绘制线程，绘制的工作直接通过OpenGL在绘制线程进行，不会堵塞主线程，绘制的结果输出到SurfaceView所提供的Surface上，这使得GLSurfaceView也拥有了OpenGLES所提供的图形处理能力，通过它定义的Render接口，使更改具体的Render的行为非常灵活，只需要将实现了渲染函数的Renderer的实现类设置给GLSurfaceView既可。也就是说它是对SurfaceView的再次封装，为了方便我们在安卓中使用OpenGL。
+
+#### GLSurfaceView常用方法
+
+- setEGLContextClientVersion:设置OpenGL ES的版本，3.0则设置3
+- onPause:暂停渲染，最好在Activity、Fragment的onPause方法内调用，减少不必要的性能开销，避免不必要的崩溃
+- onResume:恢复渲染
+- setRender:设置渲染器
+- setRenderMode:设置渲染模式
+- requestRender:请求渲染，请求异步线程进行渲染，调用后不会立即进行渲染。渲染会回调到Renderer接口的onDrawFrame()方法
+- queueEvent:插入一个Runnable任务到后台渲染线程上执行。相应的，渲染线程中可以通过Activity的runOnUIThread的方法来传递事件给主线程去执行
+
+#### GLSurfaceView.Renderer(可控制该视图中绘制的图形)
+
+此接口定义了在 `GLSurfaceView` 中绘制图形所需的方法。您必须将此接口的一个实现作为单独的类提供，并使用 `GLSurfaceView.setRenderer()` 将其附加到您的 `GLSurfaceView` 实例。         
+
+`GLSurfaceView.Renderer` 接口要求您实现以下方法: 
+
+- `onSurfaceCreated()`：系统会在创建 `GLSurfaceView` 时调用一次此方法。使用此方法可执行仅需发生一次的操作，例如设置 OpenGL 环境参数或初始化 OpenGL 图形对象。          
+- `onDrawFrame()`：完成绘制工作，每一帧图像的渲染都要在这里完成，系统会在每次重新绘制 `GLSurfaceView` 时调用此方法。请将此方法作为绘制（和重新绘制）图形对象的主要执行点。
+- `onSurfaceChanged()`：系统会在 `GLSurfaceView` 几何图形发生变化（包括 `GLSurfaceView` 大小发生变化或设备屏幕方向发生变化）时调用此方法。例如，系统会在设备屏幕方向由纵向变为横向时调用此方法。使用此方法可响应 `GLSurfaceView` 容器中的更改。          
+
+
+
+使用 `GLSurfaceView` 和 `GLSurfaceView.Renderer` 为 OpenGL ES 建立容器视图后，您便可以开始使用以下类调用 OpenGL API：
+
+OpenGL ES 3.0/3.1 API 软件包        
+
+- ```
+  android.opengl: 此软件包提供了 OpenGL ES 3.0/3.1 类的接口。版本 3.0 从 Android 4.3（API 级别 18）开始可用。版本 3.1 从 Android 5.0（API 级别 21）开始可用。          
+  ```
+
+  - `GLES30`
+  - `GLES31` 
+  - `GLES31Ext` ([Android Extension Pack](https://developer.android.google.cn/guide/topics/graphics/opengl#aep))
+
+
+
+[SurfaceView与TextureView](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/SurfaceView%E4%B8%8ETextureView.md)
+
+```java
+package android.opengl;
+/**
+ * An implementation of SurfaceView that uses the dedicated surface for
+ * displaying OpenGL rendering.
+ */
+ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback2 {
+ }
+
+```
+
+GPU加速：GLSurfaceView的效率是SurfaceView的30倍以上，SurfaceView使用画布进行绘制，GLSurfaceView利用GPU加速提高了绘制效率。
+View的绘制onDraw(Canvas canvas)使用Skia渲染引擎渲染，而GLSurfaceView的渲染器Renderer的onDrawFrame(GL10 gl)使用opengl绘制引擎进行渲染。
+
+
+
+GLSurfaceView的特性:    
+
+- 管理一个surface，这个surface就是一块特殊的内存，能直接排版到android的视图view上。
+- 管理一个EGL Display，它能让OpenGL把内容渲染到surface上
+- 用户自定义渲染器render
+- 让渲染器在独立的变成里运作(与UI线程分离)
+- 支持按需渲染(on-demand)和连续渲染(continuous)
+- 可以封装、跟踪并且排查渲染器的问题
+
+
+
+#### OpenGL实现一个绿色的activity
+
+这里是全屏渲染成绿色，所以不会涉及到顶点着色器和片段着色器。
+
+首选现在AndroidManifest.xml文件中声明使用OpenGL ES的版本： 
+
+```
+<uses-feature android:glEsVersion="0x00030000" android:required="true" />
+```
+
+
+
+```
+public class MainActivity extends AppCompatActivity {
+    private GLSurfaceView mGlSurfaceView;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        mGlSurfaceView = new MyGLSurfaceView(this);
+        setContentView(mGlSurfaceView);
+    }
+}
+
+class MyGLSurfaceView extends GLSurfaceView {
+    private final MyGLRenderer renderer;
+    public MyGLSurfaceView(Context context) {
+        super(context);
+        // 设置opengl es的版本，现在应该没有app还要支持4.3一下系统了，直接用3.0就可以
+        setEGLContextClientVersion(3);
+        renderer = new MyGLRenderer();
+        setRenderer(renderer);
+    }
+}
+
+class MyGLRenderer implements GLSurfaceView.Renderer {
+    public void onSurfaceCreated(GL10 unused, EGLConfig config) {
+        // Set the background frame color RGBA
+        GLES30.glClearColor(0.0f, 1.0f, 0.0f, 0.0f);
+    }
+    public void onDrawFrame(GL10 unused) {
+        // Redraw background color
+        // glClearColor设置好清除颜色，glClear利用glClearColor设置好的清除颜色来设置颜色缓冲区的颜色
+        GLES30.glClear(GLES31.GL_COLOR_BUFFER_BIT);
+    }
+
+    public void onSurfaceChanged(GL10 unused, int width, int height) {
+        GLES30.glViewport(0, 0, width, height);
+    }
+}
+```
+
+效果图就不贴了，就是一个纯绿色的Activity。
+
+Render接口重写的三个方法中调用了GLES31的API方法:   
+
+- glClearColor()：设置清空屏幕用的颜色，参数为RGBA。
+- glClear()：清空屏幕，清空屏幕后调用glClearColor()中设置的颜色填充屏幕。
+- glViewport()：设置视图的尺寸，告诉OpenGL可以用来渲染surface的大小。
+
+
+
+#### RenderMode
+
+GLSurfaceView默认采用的是RENDERMODE_CONTINUOUSLY连续渲染的方式，刷新的帧率是60FPS，16ms就重绘一次，可以通过mGLView.setRenderMode()更改其渲染方式为RENDERMODE_WHEN_DIRTY，表示被动渲染，在surfaceCreate的时候会绘制一次，之后只有在调用requestRender或者onResume等方法主动请求重绘时才会进行渲染，如果你的界面不需要频繁的刷新最好使用RENDERMODE_WHEN_DIRTY，这样可以降低CPU和GPU的活动。
+
+#### 状态处理
+
+使用GLSurfaceView需要注意程序的生命周期，Activity及Fragment会有暂停和恢复等状态，GLSurfaceView也需根据这些状态来做相应的处理，GLSurfaceView具有onResume和onPause两个同Activity及Fragment中的生命周期同名的方法，在Activity或者Fragment中的onResume和onPause方法中，需要主动调用GLSurfaceView的实例的这两个方法，这样能使OpenGLES的内部线程做出正确的判断，从而保证应用程序的稳定性。
+
+
+#### GLSurfaceView的事件处理
+
+为了处理事件，需要继承GLSurfaceView类并重载它的事件方法，但是由于GLSurfaceView是多线程的，渲染器在独立的渲染线程中，需要使用Java的跨线程机制与渲染器进行通讯，GLSurfaceView提供了queueEvent(Runnable runnable)方法就是一种相对简单的操作，queueEvent()方法被安全的用于在UI线程和渲染线程之间进行交流通信。这块在注释里面写了:   
+
+```
+ * To handle an event you will typically subclass GLSurfaceView and override the
+ * appropriate method, just as you would with any other View. However, when handling
+ * the event, you may need to communicate with the Renderer object
+ * that's running in the rendering thread. You can do this using any
+ * standard Java cross-thread communication mechanism. In addition,
+ * one relatively easy way to communicate with your renderer is
+ * to call
+ * {@link #queueEvent(Runnable)}. For example:
+ * <pre class="prettyprint">
+ * class MyGLSurfaceView extends GLSurfaceView {
+ *
+ *     private MyRenderer mMyRenderer;
+ *
+ *     public void start() {
+ *         mMyRenderer = ...;
+ *         setRenderer(mMyRenderer);
+ *     }
+ *
+ *     public boolean onKeyDown(int keyCode, KeyEvent event) {
+ *         if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER) {
+ *             queueEvent(new Runnable() {
+ *                 // This method will be called on the rendering
+ *                 // thread:
+ *                 public void run() {
+ *                     mMyRenderer.handleDpadCenter();
+ *                 }});
+ *             return true;
+ *         }
+ *         return super.onKeyDown(keyCode, event);
+ *     }
+ *}
+```
+
+
+
+### SurfaceTexture
+
+说到GLSurfaceView就一定要提一下SurfaceTexture。
+
+和SurfaceView功能类似，区别是，SurfaceTexure可以不显示在界面中。使用OpenGl对图片流进行美化，添加水印，滤镜这些操作的时候我们都是通过SurfaceTexre去处理，处理完之后再通过GlSurfaceView显示。缺点，可能会导致个别帧的延迟。本身管理着BufferQueue,所以内存消耗会多一点。
+SurfaceTexture从图像流（来自Camera预览，视频解码，GL绘制场景等）中获得帧数据，当调用updateTexImage()时，根据内容流中最近的图像更新SurfaceTexture对应的GL纹理对象，接下来，就可以像操作普通GL纹理一样操作它了。  SurfaceTexture 可以将 Surface 中最近的图像数据更新到 GL Texture 中。通过 GL Texture 我们就可以拿到视频帧，然后直接渲染到 GLSurfaceView 中。
+
+通过 **setOnFrameAvailableListener(listener)** 可以向 SurfaceTexture 注册监听事件，当 Surface 有新的图像可用时，调用 SurfaceTexture 的 **updateTexImage()** 方法将图像内容更新到 GL Texture 中，然后做绘制操作。SurfaceTexture中的attachToGLContext()和detachToGLContext()可以让多个GL context共享同一个内容源。
+SurfaceTexture对象可以在任何线程上创建。 updateTexImage()只能在包含纹理对象的OpenGL ES上下文的线程上调用。 在任意线程上调用frame-available回调函数，不与updateTexImage()在同一线程上出现。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/OpenGL/3.GLSurfaceView\346\272\220\347\240\201\350\247\243\346\236\220.md" "b/VideoDevelopment/OpenGL/3.GLSurfaceView\346\272\220\347\240\201\350\247\243\346\236\220.md"
new file mode 100644
index 00000000..c4c11e8b
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/3.GLSurfaceView\346\272\220\347\240\201\350\247\243\346\236\220.md"
@@ -0,0 +1,690 @@
+GLSurfaceView源码解析
+
+我感觉还是先看一下源码，了解一下内部的流程，再接着学习其他的OpenGL部分会更合适。
+
+从上一篇文章中GLSurfaceView的使用中可以看到入口是setRenderer()方法，这里就卡一下setRenderder(Renderer renderer)方法的实现:  
+
+- Renderer接口
+
+```java
+public interface Renderer {
+		// surface创建的回调
+    void onSurfaceCreated(GL10 gl, EGLConfig config);
+		// surface大小改变的回调
+    void onSurfaceChanged(GL10 gl, int width, int height);
+		// 开始绘制每一帧的回调
+    void onDrawFrame(GL10 gl);
+}
+```
+
+- setRenderer()方法
+
+```java
+   public void setRenderer(Renderer renderer) {
+     		// 保证setRenderer方法只能被调用一次
+        checkRenderThreadState();
+        if (mEGLConfigChooser == null) {
+            // 设置EGLConfgi，如果不设置就用默认的一个RGB_888的Surface选择器
+            mEGLConfigChooser = new SimpleEGLConfigChooser(true);
+        }
+        if (mEGLContextFactory == null) {
+          	// 设置EGLContext工厂，如果不设置就用默认的EGLContext的工厂类，用他来创建EGLContext
+            mEGLContextFactory = new DefaultContextFactory();
+        }
+        if (mEGLWindowSurfaceFactory == null) {
+            // 设置EGLSurface工厂，如果不设置就用默认的EGLSurface的工厂类，我们可以通过这个方法来设置让图像渲染到其他地方的surface上，例如textureview上
+            mEGLWindowSurfaceFactory = new DefaultWindowSurfaceFactory();
+        }
+        mRenderer = renderer;
+        // 创建并开启GLThread,GL线程
+        mGLThread = new GLThread(mThisWeakRef);
+        mGLThread.start();
+    }
+```
+
+- 接下来看一下GLThread的线程的实现，GLThread是GLSurfaceView自带的一个渲染线程，同步的，不会阻塞线程，主要用来执行OpenGL的绘制工作:
+
+  ```java
+  static class GLThread extends Thread {
+          GLThread(WeakReference<GLSurfaceView> glSurfaceViewWeakRef) {
+              super();
+              mWidth = 0;
+              mHeight = 0;
+            	// 主动渲染模式下是true，如果是被动渲染模式就为false，然后通过requesetRender()方法来修改它的值
+              mRequestRender = true;
+              // 默认的渲染模式
+              mRenderMode = RENDERMODE_CONTINUOUSLY;
+              mWantRenderNotification = false;
+              mGLSurfaceViewWeakRef = glSurfaceViewWeakRef;
+          }
+  
+          @Override
+          public void run() {
+              setName("GLThread " + getId());
+              if (LOG_THREADS) {
+                  Log.i("GLThread", "starting tid=" + getId());
+              }
+  
+              try {
+                  // 具体的run方法，内部实现在下面，所有的核心都在里面，把这个方法单独放到下面说
+                  guardedRun();
+              } catch (InterruptedException e) {
+                  // fall thru and exit normally
+              } finally {
+                  sGLThreadManager.threadExiting(this);
+              }
+          }
+    				// GLSurfaceView的onPause方法会调用到这里
+            public void onPause() {
+              synchronized (sGLThreadManager) {
+                  if (LOG_PAUSE_RESUME) {
+                      Log.i("GLThread", "onPause tid=" + getId());
+                  }
+  
+                  mRequestPaused = true;
+                  // 这里使用了GLThreadManager这个类，这个类是提供线程同步控制功能的，最后会说这个类，通知EGL线程解除堵塞
+                  sGLThreadManager.notifyAll();
+                	// 保证onPause方法执行后GLThread也是pause的状态
+                  while ((! mExited) && (! mPaused)) {
+                      if (LOG_PAUSE_RESUME) {
+                          Log.i("Main thread", "onPause waiting for mPaused.");
+                      }
+                      try {
+                          sGLThreadManager.wait();
+                      } catch (InterruptedException ex) {
+                          Thread.currentThread().interrupt();
+                      }
+                  }
+              }
+          }
+  				 // GLSurfaceView的onResume方法会调用到这里
+          public void onResume() {
+              synchronized (sGLThreadManager) {
+                  if (LOG_PAUSE_RESUME) {
+                      Log.i("GLThread", "onResume tid=" + getId());
+                  }
+                  // 修改状态变量
+                  mRequestPaused = false;
+                  // 重绘一次
+                  mRequestRender = true;
+                  mRenderComplete = false;
+                  sGLThreadManager.notifyAll();
+                	// 保证onResume执行后，GLThread也是resume的状态
+                  while ((! mExited) && mPaused && (!mRenderComplete)) {
+                      if (LOG_PAUSE_RESUME) {
+                          Log.i("Main thread", "onResume waiting for !mPaused.");
+                      }
+                      try {
+                          sGLThreadManager.wait();
+                      } catch (InterruptedException ex) {
+                          Thread.currentThread().interrupt();
+                      }
+                  }
+              }
+          }
+      }
+  ```
+
+
+
+- guardeRun()方法：   
+
+  核心就是用一个while true循环，内部加了各种场景的判断，最后会调用renderer.onDrawFrame()方法进行绘制。
+
+  
+
+  ```java
+  private void guardedRun() throws InterruptedException {
+  						//GL帮助类，内部建立GL环境
+              mEglHelper = new EglHelper(mGLSurfaceViewWeakRef);
+              mHaveEglContext = false;
+              mHaveEglSurface = false;
+              mWantRenderNotification = false;
+  
+              try {
+                  GL10 gl = null;
+                  boolean createEglContext = false;
+                  boolean createEglSurface = false;
+                  boolean createGlInterface = false;
+                  boolean lostEglContext = false;
+                  boolean sizeChanged = false;
+                  boolean wantRenderNotification = false;
+                  boolean doRenderNotification = false;
+                  boolean askedToReleaseEglContext = false;
+                  int w = 0;
+                  int h = 0;
+                  Runnable event = null;
+                  Runnable finishDrawingRunnable = null;
+  
+                  while (true) {
+                      synchronized (sGLThreadManager) {
+                          while (true) {
+                          		// 外部请求退出
+                              if (mShouldExit) {
+                                  return;
+                              }
+  														// 如果还有GL线程中要处理的事件没处理完，就先处理事件
+                              if (! mEventQueue.isEmpty()) {
+                                  event = mEventQueue.remove(0);
+                                  break;
+                              }
+  														// 更新onResume和onPause时的状态变化
+                              // Update the pause state.
+                              boolean pausing = false;
+                              if (mPaused != mRequestPaused) {
+                                  pausing = mRequestPaused;
+                                  mPaused = mRequestPaused;
+                                  // onPause和onResume的时候都会用wait方法等待GL线程的响应，这时候主线程堵塞。需要调用notifyAll
+                                  sGLThreadManager.notifyAll();
+                                  if (LOG_PAUSE_RESUME) {
+                                      Log.i("GLThread", "mPaused is now " + mPaused + " tid=" + getId());
+                                  }
+                              }
+  														// 需要释放EGLContext
+                              // Do we need to give up the EGL context?
+                              if (mShouldReleaseEglContext) {
+                                  if (LOG_SURFACE) {
+                                      Log.i("GLThread", "releasing EGL context because asked to tid=" + getId());
+                                  }
+                                  stopEglSurfaceLocked();
+                                  stopEglContextLocked();
+                                  mShouldReleaseEglContext = false;
+                                  askedToReleaseEglContext = true;
+                              }
+  		                        // 如果EGLContext丢失，需要销毁EGLSurface和EGLContext
+                              // Have we lost the EGL context?
+                              if (lostEglContext) {
+                                  stopEglSurfaceLocked();
+                                  stopEglContextLocked();
+                                  lostEglContext = false;
+                              }
+  														// 如果onPause了并且当前GLSurface已经存在了，就销毁EGLSurface
+                              // When pausing, release the EGL surface:
+                              if (pausing && mHaveEglSurface) {
+                                  if (LOG_SURFACE) {
+                                      Log.i("GLThread", "releasing EGL surface because paused tid=" + getId());
+                                  }
+                                  stopEglSurfaceLocked();
+                              }
+  														// 接受了onPuase信号，并且当前EGLContext存在时，需要根据用户的设置来决定是否销毁EGLContext
+                              // When pausing, optionally release the EGL Context:
+                              if (pausing && mHaveEglContext) {
+                                  GLSurfaceView view = mGLSurfaceViewWeakRef.get();
+                                  boolean preserveEglContextOnPause = view == null ?
+                                          false : view.mPreserveEGLContextOnPause;
+                                  if (!preserveEglContextOnPause) {
+                                      stopEglContextLocked();
+                                      if (LOG_SURFACE) {
+                                          Log.i("GLThread", "releasing EGL context because paused tid=" + getId());
+                                      }
+                                  }
+                              }
+  														
+                              // Have we lost the SurfaceView surface?
+                              if ((! mHasSurface) && (! mWaitingForSurface)) {
+                                  if (LOG_SURFACE) {
+                                      Log.i("GLThread", "noticed surfaceView surface lost tid=" + getId());
+                                  }
+                                  if (mHaveEglSurface) {
+                                      stopEglSurfaceLocked();
+                                  }
+                                  mWaitingForSurface = true;
+                                  mSurfaceIsBad = false;
+                                  sGLThreadManager.notifyAll();
+                              }
+  
+                              // Have we acquired the surface view surface?
+                              if (mHasSurface && mWaitingForSurface) {
+                                  if (LOG_SURFACE) {
+                                      Log.i("GLThread", "noticed surfaceView surface acquired tid=" + getId());
+                                  }
+                                  mWaitingForSurface = false;
+                                  sGLThreadManager.notifyAll();
+                              }
+  
+                              if (doRenderNotification) {
+                                  if (LOG_SURFACE) {
+                                      Log.i("GLThread", "sending render notification tid=" + getId());
+                                  }
+                                  mWantRenderNotification = false;
+                                  doRenderNotification = false;
+                                  mRenderComplete = true;
+                                  sGLThreadManager.notifyAll();
+                              }
+  
+                              if (mFinishDrawingRunnable != null) {
+                                  finishDrawingRunnable = mFinishDrawingRunnable;
+                                  mFinishDrawingRunnable = null;
+                              }
+  														// readyToDraw()方法内部会判断是否已经pause或者mRequestRender是否是true以及是否是主动渲染模式。如果是被动渲染的模式mRequestRender就会是false，只有调用requestRender()方法后才会是true，如果是主动渲染模式readyToDraw()就不用根据mRequestRender来判断。
+                              // Ready to draw?
+                              if (readyToDraw()) {
+  																// 没有EGLContext就去调用EGLHelper来创建，第一次会走到这里先创建EGLContext
+                                  // If we don't have an EGL context, try to acquire one.
+                                  if (! mHaveEglContext) {
+                                      if (askedToReleaseEglContext) {
+                                          askedToReleaseEglContext = false;
+                                      } else {
+                                          try {
+                                              // 后面会看这个EglHelper.start()方法，初始化EGL环境，内部会去创建各种GL EGL EGLContext EGLDisplay等环境
+                                              mEglHelper.start();
+                                          } catch (RuntimeException t) {
+                                              sGLThreadManager.releaseEglContextLocked(this);
+                                              throw t;
+                                          }
+                                        	// 创建完后把该变量变成true
+                                          mHaveEglContext = true;
+                                          createEglContext = true;
+  
+                                          sGLThreadManager.notifyAll();
+                                      }
+                                  }
+  
+                                  if (mHaveEglContext && !mHaveEglSurface) {
+                                      mHaveEglSurface = true;
+                                      createEglSurface = true;
+                                      createGlInterface = true;
+                                      sizeChanged = true;
+                                  }
+  
+                                  if (mHaveEglSurface) {
+                                      if (mSizeChanged) {
+                                          sizeChanged = true;
+                                          w = mWidth;
+                                          h = mHeight;
+                                          mWantRenderNotification = true;
+                                          if (LOG_SURFACE) {
+                                              Log.i("GLThread",
+                                                      "noticing that we want render notification tid="
+                                                      + getId());
+                                          }
+  
+                                          // Destroy and recreate the EGL surface.
+                                          createEglSurface = true;
+  
+                                          mSizeChanged = false;
+                                      }
+                                      mRequestRender = false;
+                                      sGLThreadManager.notifyAll();
+                                      if (mWantRenderNotification) {
+                                          wantRenderNotification = true;
+                                      }
+                                      break;
+                                  }
+                              } else {
+                                  if (finishDrawingRunnable != null) {
+                                      Log.w(TAG, "Warning, !readyToDraw() but waiting for " +
+                                              "draw finished! Early reporting draw finished.");
+                                      finishDrawingRunnable.run();
+                                      finishDrawingRunnable = null;
+                                  }
+                              }
+                              // By design, this is the only place in a GLThread thread where we wait().
+                              sGLThreadManager.wait();
+                          }
+                      } // end of synchronized(sGLThreadManager)
+  
+                      if (event != null) {
+                         // 执行event的run方法，这个event是GLSurfaceView中提供的queueEvent(runnable run)实现的，该方法会把runnable添加到EventQueue中，然后再在这里去执行该runnable
+                          event.run();
+                          event = null;
+                          continue;
+                      }
+  
+                      if (createEglSurface) {
+  												// EglHelper创建EglSurface                      
+                          if (mEglHelper.createSurface()) {
+                              synchronized(sGLThreadManager) {
+                                  mFinishedCreatingEglSurface = true;
+                                  sGLThreadManager.notifyAll();
+                              }
+                          } else {
+                              synchronized(sGLThreadManager) {
+                                  mFinishedCreatingEglSurface = true;
+                                  mSurfaceIsBad = true;
+                                  sGLThreadManager.notifyAll();
+                              }
+                              continue;
+                          }
+                          createEglSurface = false;
+                      }
+  
+                      if (createGlInterface) {
+                          gl = (GL10) mEglHelper.createGL();
+  
+                          createGlInterface = false;
+                      }
+  
+                      if (createEglContext) {
+                          if (LOG_RENDERER) {
+                              Log.w("GLThread", "onSurfaceCreated");
+                          }
+                          GLSurfaceView view = mGLSurfaceViewWeakRef.get();
+                          if (view != null) {
+                              try {
+                                  Trace.traceBegin(Trace.TRACE_TAG_VIEW, "onSurfaceCreated");
+                                	// 回调onSurfaceCreated
+                                  view.mRenderer.onSurfaceCreated(gl, mEglHelper.mEglConfig);
+                              } finally {
+                                  Trace.traceEnd(Trace.TRACE_TAG_VIEW);
+                              }
+                          }
+                          createEglContext = false;
+                      }
+  
+                      if (sizeChanged) {
+                          if (LOG_RENDERER) {
+                              Log.w("GLThread", "onSurfaceChanged(" + w + ", " + h + ")");
+                          }
+                          GLSurfaceView view = mGLSurfaceViewWeakRef.get();
+                          if (view != null) {
+                              try {
+                                  Trace.traceBegin(Trace.TRACE_TAG_VIEW, "onSurfaceChanged");
+                                  // 回调onSurfaceChangeed
+                                  view.mRenderer.onSurfaceChanged(gl, w, h);
+                              } finally {
+                                  Trace.traceEnd(Trace.TRACE_TAG_VIEW);
+                              }
+                          }
+                          sizeChanged = false;
+                      }
+  
+                      if (LOG_RENDERER_DRAW_FRAME) {
+                          Log.w("GLThread", "onDrawFrame tid=" + getId());
+                      }
+                      {
+                          GLSurfaceView view = mGLSurfaceViewWeakRef.get();
+                          if (view != null) {
+                              // 调用renderder.onDrawFrame方法开始绘制
+                              try {
+                                  Trace.traceBegin(Trace.TRACE_TAG_VIEW, "onDrawFrame");
+                                  view.mRenderer.onDrawFrame(gl);
+                                  if (finishDrawingRunnable != null) {
+                                      finishDrawingRunnable.run();
+                                      finishDrawingRunnable = null;
+                                  }
+                              } finally {
+                                  Trace.traceEnd(Trace.TRACE_TAG_VIEW);
+                              }
+                          }
+                      }
+                      int swapError = mEglHelper.swap();
+                      switch (swapError) {
+                          case EGL10.EGL_SUCCESS:
+                              break;
+                          case EGL11.EGL_CONTEXT_LOST:
+                              if (LOG_SURFACE) {
+                                  Log.i("GLThread", "egl context lost tid=" + getId());
+                              }
+                              lostEglContext = true;
+                              break;
+                          default:
+                              // Other errors typically mean that the current surface is bad,
+                              // probably because the SurfaceView surface has been destroyed,
+                              // but we haven't been notified yet.
+                              // Log the error to help developers understand why rendering stopped.
+                              EglHelper.logEglErrorAsWarning("GLThread", "eglSwapBuffers", swapError);
+  
+                              synchronized(sGLThreadManager) {
+                                  mSurfaceIsBad = true;
+                                  sGLThreadManager.notifyAll();
+                              }
+                              break;
+                      }
+  
+                      if (wantRenderNotification) {
+                          doRenderNotification = true;
+                          wantRenderNotification = false;
+                      }
+                  }
+  
+              } finally {
+                  /*
+                   * clean-up everything...
+                   */
+                  synchronized (sGLThreadManager) {
+                      stopEglSurfaceLocked();
+                      stopEglContextLocked();
+                  }
+              }
+          }
+  ```
+
+接着看一下上面提到的几个类: 
+
+- EGLHelper
+
+```java
+/**
+     * An EGL helper class.
+     */
+
+    private static class EglHelper {
+        public EglHelper(WeakReference<GLSurfaceView> glSurfaceViewWeakRef) {
+            mGLSurfaceViewWeakRef = glSurfaceViewWeakRef;
+        }
+
+        /**
+         * 初始化EGL环境，创建EGL EGLContext EGLDisplay
+         * Initialize EGL for a given configuration spec.
+         * @param configSpec
+         */
+        public void start() {
+            if (LOG_EGL) {
+                Log.w("EglHelper", "start() tid=" + Thread.currentThread().getId());
+            }
+            /*
+             * Get an EGL instance
+             */
+            mEgl = (EGL10) EGLContext.getEGL();
+
+            /*
+             * Get to the default display.
+             */
+            mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
+
+            if (mEglDisplay == EGL10.EGL_NO_DISPLAY) {
+                throw new RuntimeException("eglGetDisplay failed");
+            }
+
+            /*
+             * We can now initialize EGL for that display
+             */
+            int[] version = new int[2];
+            if(!mEgl.eglInitialize(mEglDisplay, version)) {
+                throw new RuntimeException("eglInitialize failed");
+            }
+            GLSurfaceView view = mGLSurfaceViewWeakRef.get();
+            if (view == null) {
+                mEglConfig = null;
+                mEglContext = null;
+            } else {
+                // 使用setRender方法中setEGLConfigChooser和setEGLContextFactory中设置的部分来创建
+                mEglConfig = view.mEGLConfigChooser.chooseConfig(mEgl, mEglDisplay);
+
+                /*
+                * Create an EGL context. We want to do this as rarely as we can, because an
+                * EGL context is a somewhat heavy object.
+                */
+                mEglContext = view.mEGLContextFactory.createContext(mEgl, mEglDisplay, mEglConfig);
+            }
+            if (mEglContext == null || mEglContext == EGL10.EGL_NO_CONTEXT) {
+                mEglContext = null;
+                throwEglException("createContext");
+            }
+            if (LOG_EGL) {
+                Log.w("EglHelper", "createContext " + mEglContext + " tid=" + Thread.currentThread().getId());
+            }
+
+            mEglSurface = null;
+        }
+
+        /**
+         * 创建EGLSurface
+         * Create an egl surface for the current SurfaceHolder surface. If a surface
+         * already exists, destroy it before creating the new surface.
+         *
+         * @return true if the surface was created successfully.
+         */
+        public boolean createSurface() {
+            if (LOG_EGL) {
+                Log.w("EglHelper", "createSurface()  tid=" + Thread.currentThread().getId());
+            }
+            /*
+             * Check preconditions.
+             */
+            if (mEgl == null) {
+                throw new RuntimeException("egl not initialized");
+            }
+            if (mEglDisplay == null) {
+                throw new RuntimeException("eglDisplay not initialized");
+            }
+            if (mEglConfig == null) {
+                throw new RuntimeException("mEglConfig not initialized");
+            }
+
+            /*
+             *  The window size has changed, so we need to create a new
+             *  surface.
+             */
+            destroySurfaceImp();
+
+            /*
+             * Create an EGL surface we can render into.
+             */
+            GLSurfaceView view = mGLSurfaceViewWeakRef.get();
+            if (view != null) {
+            		// 也是通过EGLWindowSurfaceFactory来创建EGLSurface，如果没有设置就会调用默认的DefaultWindowSurfaceFactory。后面说一下这里
+                mEglSurface = view.mEGLWindowSurfaceFactory.createWindowSurface(mEgl,
+                        mEglDisplay, mEglConfig, view.getHolder());
+            } else {
+                mEglSurface = null;
+            }
+
+            /*
+            将EGLContext上下文加载到当前线程环境
+             * Before we can issue GL commands, we need to make sure
+             * the context is current and bound to a surface.
+             */
+            if (!mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext)) {
+                /*
+                 * Could not make the context current, probably because the underlying
+                 * SurfaceView surface has been destroyed.
+                 */
+                logEglErrorAsWarning("EGLHelper", "eglMakeCurrent", mEgl.eglGetError());
+                return false;
+            }
+
+            return true;
+        }
+
+        /**
+         获取OpenGL ES的编程接口
+         * Create a GL object for the current EGL context.
+         * @return
+         */
+        GL createGL() {
+            GL gl = mEglContext.getGL();
+            GLSurfaceView view = mGLSurfaceViewWeakRef.get();
+            if (view != null) {
+                if (view.mGLWrapper != null) {
+                    gl = view.mGLWrapper.wrap(gl);
+                }
+
+                if ((view.mDebugFlags & (DEBUG_CHECK_GL_ERROR | DEBUG_LOG_GL_CALLS)) != 0) {
+                    int configFlags = 0;
+                    Writer log = null;
+                    if ((view.mDebugFlags & DEBUG_CHECK_GL_ERROR) != 0) {
+                        configFlags |= GLDebugHelper.CONFIG_CHECK_GL_ERROR;
+                    }
+                    if ((view.mDebugFlags & DEBUG_LOG_GL_CALLS) != 0) {
+                        log = new LogWriter();
+                    }
+                    gl = GLDebugHelper.wrap(gl, configFlags, log);
+                }
+            }
+            return gl;
+        }
+        public void destroySurface() {
+            if (LOG_EGL) {
+                Log.w("EglHelper", "destroySurface()  tid=" + Thread.currentThread().getId());
+            }
+            destroySurfaceImp();
+        }
+
+        private void destroySurfaceImp() {
+            if (mEglSurface != null && mEglSurface != EGL10.EGL_NO_SURFACE) {
+                mEgl.eglMakeCurrent(mEglDisplay, EGL10.EGL_NO_SURFACE,
+                        EGL10.EGL_NO_SURFACE,
+                        EGL10.EGL_NO_CONTEXT);
+                GLSurfaceView view = mGLSurfaceViewWeakRef.get();
+                if (view != null) {
+                		// EGLWindowSurfaceFactory除了创建EGLSurface还有销毁的功能
+                    view.mEGLWindowSurfaceFactory.destroySurface(mEgl, mEglDisplay, mEglSurface);
+                }
+                mEglSurface = null;
+            }
+        }
+        private WeakReference<GLSurfaceView> mGLSurfaceViewWeakRef;
+        EGL10 mEgl;
+        EGLDisplay mEglDisplay;
+        EGLSurface mEglSurface;
+        EGLConfig mEglConfig;
+        EGLContext mEglContext;
+
+    }
+```
+
+- EGLWindowSurfaceFactory
+
+```java
+    /**
+     * An interface for customizing the eglCreateWindowSurface and eglDestroySurface calls.
+     * <p>
+     * This interface must be implemented by clients wishing to call
+     * {@link GLSurfaceView#setEGLWindowSurfaceFactory(EGLWindowSurfaceFactory)}
+     */
+    public interface EGLWindowSurfaceFactory {
+        /**
+         *  @return null if the surface cannot be constructed.
+         */
+        EGLSurface createWindowSurface(EGL10 egl, EGLDisplay display, EGLConfig config,
+                Object nativeWindow);
+        void destroySurface(EGL10 egl, EGLDisplay display, EGLSurface surface);
+    }
+
+    private static class DefaultWindowSurfaceFactory implements EGLWindowSurfaceFactory {
+
+        public EGLSurface createWindowSurface(EGL10 egl, EGLDisplay display,
+                EGLConfig config, Object nativeWindow) {
+            EGLSurface result = null;
+            try {
+                result = egl.eglCreateWindowSurface(display, config, nativeWindow, null);
+            } catch (IllegalArgumentException e) {
+                // This exception indicates that the surface flinger surface
+                // is not valid. This can happen if the surface flinger surface has
+                // been torn down, but the application has not yet been
+                // notified via SurfaceHolder.Callback.surfaceDestroyed.
+                // In theory the application should be notified first,
+                // but in practice sometimes it is not. See b/4588890
+                Log.e(TAG, "eglCreateWindowSurface", e);
+            }
+            return result;
+        }
+
+        public void destroySurface(EGL10 egl, EGLDisplay display,
+                EGLSurface surface) {
+            egl.eglDestroySurface(display, surface);
+        }
+    }
+
+```
+
+看到这里我们知道可以自定义WindowSurfaceFactory然后使用其他SurfaceView或者TextureView的Surface来创建EGLSurface，让其把渲染后的内容输出到SurfaceView或者TextureView上显示。
+
+- GLThreadManager类
+
+  上面看到wait和notifyall的时候sGLThreadManager.notifyAll();都用到了GLThreadManager类。它就是线程同步的锁。
+
+  这个类主要提供的是线程同步控制的功能，因为在GLSurfaceView里面有两个线程: GL线程和调用线程。所以对一些变量必须要进行同步。
+
diff --git "a/VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md" "b/VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md"
new file mode 100644
index 00000000..6f5b93fe
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md"
@@ -0,0 +1,1974 @@
+### GLTextureView
+
+系统提供了GLSurfaceView，确没有提供GLTextureView，但是我们目前的项目灰常复杂庞大，我不想去封一层接口，然后动态去选择使用GLSurfaceView(实现一些纹理效果)或者TextureView(无OpenGL效果)来播放视频。我只想在目前的基础上去扩展，我想去实现一个GLTextureView。上面分析完GLSurfaceView的源码后我们也可以自己去实现GLTextureView的功能了。具体的实现就是和GLSurfaceView的源码一模一样。
+
+我对里面的改动点主要有两个地方，这俩是为了让render传null的时候可以当做普通的TextureView来使用: 
+
+- ```java
+  if (renderer == null) {
+      // 与普通TextureView一样
+      return;
+  }
+  ```
+
+- ```java
+      @Override
+      public void setSurfaceTextureListener(SurfaceTextureListener listener) {
+          if (mRenderer == null) {
+              // 与普通TextureView一样
+              super.setSurfaceTextureListener(listener);
+          }
+          Log.e(TAG, "setSurfaceTextureListener preserved, setRenderer() instead?");
+      }
+  ```
+
+```java
+/**
+ * An implementation of TextureView that uses the dedicated surface for
+ * displaying OpenGL rendering.
+ * <p>
+ * A GLTextureView provides the following features:
+ * <p>
+ * <ul>
+ * <li>Manages a surface, which is a special piece of memory that can be
+ * composited into the Android view system.
+ * <li>Manages an EGL display, which enables OpenGL to render into a surface.
+ * <li>Accepts a user-provided Renderer object that does the actual rendering.
+ * <li>Renders on a dedicated thread to decouple rendering performance from the
+ * UI thread.
+ * <li>Supports both on-demand and continuous rendering.
+ * <li>Optionally wraps, traces, and/or error-checks the renderer's OpenGL calls.
+ * </ul>
+ *
+ * <div class="special reference">
+ * <h3>Developer Guides</h3>
+ * <p>For more information about how to use OpenGL, read the
+ * <a href="{@docRoot}guide/topics/graphics/opengl.html">OpenGL</a> developer guide.</p>
+ * </div>
+ *
+ * <h3>Using GLTextureView</h3>
+ * <p>
+ * Typically you use GLTextureView by subclassing it and overriding one or more of the
+ * View system input event methods. If your application does not need to override event
+ * methods then GLTextureView can be used as-is. For the most part
+ * GLTextureView behavior is customized by calling "set" methods rather than by subclassing.
+ * For example, unlike a regular View, drawing is delegated to a separate Renderer object which
+ * is registered with the GLTextureView
+ * using the {@link #setRenderer(Renderer)} call.
+ * <p>
+ * <h3>Initializing GLTextureView</h3>
+ * All you have to do to initialize a GLTextureView is call {@link #setRenderer(Renderer)}.
+ * However, if desired, you can modify the default behavior of GLTextureView by calling one or
+ * more of these methods before calling setRenderer:
+ * <ul>
+ * <li>{@link #setDebugFlags(int)}
+ * <li>{@link #setEGLConfigChooser(boolean)}
+ * <li>{@link #setEGLConfigChooser(EGLConfigChooser)}
+ * <li>{@link #setEGLConfigChooser(int, int, int, int, int, int)}
+ * <li>{@link #setGLWrapper(GLWrapper)}
+ * </ul>
+ * <p>
+ * <h4>Specifying the android.view.Surface</h4>
+ * By default GLTextureView will create a PixelFormat.RGB_888 format surface. If a translucent
+ * surface is required, call getHolder().setFormat(PixelFormat.TRANSLUCENT).
+ * The exact format of a TRANSLUCENT surface is device dependent, but it will be
+ * a 32-bit-per-pixel surface with 8 bits per component.
+ * <p>
+ * <h4>Choosing an EGL Configuration</h4>
+ * A given Android device may support multiple EGLConfig rendering configurations.
+ * The available configurations may differ in how may channels of data are present, as
+ * well as how many bits are allocated to each channel. Therefore, the first thing
+ * GLTextureView has to do when starting to render is choose what EGLConfig to use.
+ * <p>
+ * By default GLTextureView chooses a EGLConfig that has an RGB_888 pixel format,
+ * with at least a 16-bit depth buffer and no stencil.
+ * <p>
+ * If you would prefer a different EGLConfig
+ * you can override the default behavior by calling one of the
+ * setEGLConfigChooser methods.
+ * <p>
+ * <h4>Debug Behavior</h4>
+ * You can optionally modify the behavior of GLTextureView by calling
+ * one or more of the debugging methods {@link #setDebugFlags(int)},
+ * and {@link #setGLWrapper}. These methods may be called before and/or after setRenderer, but
+ * typically they are called before setRenderer so that they take effect immediately.
+ * <p>
+ * <h4>Setting a Renderer</h4>
+ * Finally, you must call {@link #setRenderer} to register a {@link Renderer}.
+ * The renderer is
+ * responsible for doing the actual OpenGL rendering.
+ * <p>
+ * <h3>Rendering Mode</h3>
+ * Once the renderer is set, you can control whether the renderer draws
+ * continuously or on-demand by calling
+ * {@link #setRenderMode}. The default is continuous rendering.
+ * <p>
+ * <h3>Activity Life-cycle</h3>
+ * A GLTextureView must be notified when the activity is paused and resumed. GLTextureView clients
+ * are required to call {@link #onPause()} when the activity pauses and
+ * {@link #onResume()} when the activity resumes. These calls allow GLTextureView to
+ * pause and resume the rendering thread, and also allow GLTextureView to release and recreate
+ * the OpenGL display.
+ * <p>
+ * <h3>Handling events</h3>
+ * <p>
+ * To handle an event you will typically subclass GLTextureView and override the
+ * appropriate method, just as you would with any other View. However, when handling
+ * the event, you may need to communicate with the Renderer object
+ * that's running in the rendering thread. You can do this using any
+ * standard Java cross-thread communication mechanism. In addition,
+ * one relatively easy way to communicate with your renderer is
+ * to call
+ * {@link #queueEvent(Runnable)}. For example:
+ * <pre class="prettyprint">
+ * class MyGLTextureView extends GLTextureView {
+ *
+ *     private MyRenderer mMyRenderer;
+ *
+ *     public void start() {
+ *         mMyRenderer = ...;
+ *         setRenderer(mMyRenderer);
+ *     }
+ *
+ *     public boolean onKeyDown(int keyCode, KeyEvent event) {
+ *         if (keyCode == KeyEvent.KEYCODE_DPAD_CENTER) {
+ *             queueEvent(new Runnable() {
+ *                 // This method will be called on the rendering
+ *                 // thread:
+ *                 public void run() {
+ *                     mMyRenderer.handleDpadCenter();
+ *                 }});
+ *             return true;
+ *         }
+ *         return super.onKeyDown(keyCode, event);
+ *     }
+ * }
+ * </pre>
+ *
+ */
+public class GLTextureView extends TextureView implements TextureView.SurfaceTextureListener {
+    private final static String TAG = "GLTextureView";
+
+    private final static boolean LOG_ATTACH_DETACH = false;
+    private final static boolean LOG_THREADS = false;
+    private final static boolean LOG_PAUSE_RESUME = false;
+    private final static boolean LOG_SURFACE = false;
+    private final static boolean LOG_RENDERER = false;
+    private final static boolean LOG_RENDERER_DRAW_FRAME = false;
+    private final static boolean LOG_EGL = false;
+    /**
+     * The renderer only renders
+     * when the surface is created, or when {@link #requestRender} is called.
+     *
+     * @see #getRenderMode()
+     * @see #setRenderMode(int)
+     * @see #requestRender()
+     */
+    public final static int RENDERMODE_WHEN_DIRTY = 0;
+    /**
+     * The renderer is called
+     * continuously to re-render the scene.
+     *
+     * @see #getRenderMode()
+     * @see #setRenderMode(int)
+     */
+    public final static int RENDERMODE_CONTINUOUSLY = 1;
+
+    /**
+     * Check glError() after every GL call and throw an exception if glError indicates
+     * that an error has occurred. This can be used to help track down which OpenGL ES call
+     * is causing an error.
+     *
+     * @see #getDebugFlags
+     * @see #setDebugFlags
+     */
+    public final static int DEBUG_CHECK_GL_ERROR = 1;
+
+    /**
+     * Log GL calls to the system log at "verbose" level with tag "GLTextureView".
+     *
+     * @see #getDebugFlags
+     * @see #setDebugFlags
+     */
+    public final static int DEBUG_LOG_GL_CALLS = 2;
+
+    /**
+     * Standard View constructor. In order to render something, you
+     * must call {@link #setRenderer} to register a renderer.
+     */
+    public GLTextureView(Context context) {
+        super(context);
+        init();
+    }
+
+    /**
+     * Standard View constructor. In order to render something, you
+     * must call {@link #setRenderer} to register a renderer.
+     */
+    public GLTextureView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        init();
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        try {
+            if (mGLThread != null) {
+                // GLThread may still be running if this view was never
+                // attached to a window.
+                mGLThread.requestExitAndWait();
+            }
+        } finally {
+            super.finalize();
+        }
+    }
+
+    private void init() {
+        super.setSurfaceTextureListener(this);
+    }
+
+    /**
+     * Set the glWrapper. If the glWrapper is not null, its
+     * {@link GLWrapper#wrap(GL)} method is called
+     * whenever a surface is created. A GLWrapper can be used to wrap
+     * the GL object that's passed to the renderer. Wrapping a GL
+     * object enables examining and modifying the behavior of the
+     * GL calls made by the renderer.
+     * <p>
+     * Wrapping is typically used for debugging purposes.
+     * <p>
+     * The default value is null.
+     * @param glWrapper the new GLWrapper
+     */
+    public void setGLWrapper(GLWrapper glWrapper) {
+        mGLWrapper = glWrapper;
+    }
+
+    /**
+     * Set the debug flags to a new value. The value is
+     * constructed by OR-together zero or more
+     * of the DEBUG_CHECK_* constants. The debug flags take effect
+     * whenever a surface is created. The default value is zero.
+     * @param debugFlags the new debug flags
+     * @see #DEBUG_CHECK_GL_ERROR
+     * @see #DEBUG_LOG_GL_CALLS
+     */
+    public void setDebugFlags(int debugFlags) {
+        mDebugFlags = debugFlags;
+    }
+
+    /**
+     * Get the current value of the debug flags.
+     * @return the current value of the debug flags.
+     */
+    public int getDebugFlags() {
+        return mDebugFlags;
+    }
+
+    /**
+     * Control whether the EGL context is preserved when the GLTextureView is paused and
+     * resumed.
+     * <p>
+     * If set to true, then the EGL context may be preserved when the GLTextureView is paused.
+     * Whether the EGL context is actually preserved or not depends upon whether the
+     * Android device that the program is running on can support an arbitrary number of EGL
+     * contexts or not. Devices that can only support a limited number of EGL contexts must
+     * release the  EGL context in order to allow multiple applications to share the GPU.
+     * <p>
+     * If set to false, the EGL context will be released when the GLTextureView is paused,
+     * and recreated when the GLTextureView is resumed.
+     * <p>
+     *
+     * The default is false.
+     *
+     * @param preserveOnPause preserve the EGL context when paused
+     */
+    public void setPreserveEGLContextOnPause(boolean preserveOnPause) {
+        mPreserveEGLContextOnPause = preserveOnPause;
+    }
+
+    /**
+     * @return true if the EGL context will be preserved when paused
+     */
+    public boolean getPreserveEGLContextOnPause() {
+        return mPreserveEGLContextOnPause;
+    }
+
+    /**
+     * Set the renderer associated with this view. Also starts the thread that
+     * will call the renderer, which in turn causes the rendering to start.
+     * <p>This method should be called once and only once in the life-cycle of
+     * a GLTextureView.
+     * <p>The following GLTextureView methods can only be called <em>before</em>
+     * setRenderer is called:
+     * <ul>
+     * <li>{@link #setEGLConfigChooser(boolean)}
+     * <li>{@link #setEGLConfigChooser(EGLConfigChooser)}
+     * <li>{@link #setEGLConfigChooser(int, int, int, int, int, int)}
+     * </ul>
+     * <p>
+     * The following GLTextureView methods can only be called <em>after</em>
+     * setRenderer is called:
+     * <ul>
+     * <li>{@link #getRenderMode()}
+     * <li>{@link #onPause()}
+     * <li>{@link #onResume()}
+     * <li>{@link #queueEvent(Runnable)}
+     * <li>{@link #requestRender()}
+     * <li>{@link #setRenderMode(int)}
+     * </ul>
+     *
+     * @param renderer the renderer to use to perform OpenGL drawing.
+     */
+    public void setRenderer(Renderer renderer) {
+        if (renderer == null) {
+            // 与普通TextureView一样
+            return;
+        }
+        checkRenderThreadState();
+        if (mEGLConfigChooser == null) {
+            mEGLConfigChooser = new SimpleEGLConfigChooser(true);
+        }
+        if (mEGLContextFactory == null) {
+            mEGLContextFactory = new DefaultContextFactory();
+        }
+        if (mEGLWindowSurfaceFactory == null) {
+            mEGLWindowSurfaceFactory = new DefaultWindowSurfaceFactory();
+        }
+        mRenderer = renderer;
+        mGLThread = new GLThread(mThisWeakRef);
+        mGLThread.start();
+    }
+
+    /**
+     * Install a custom EGLContextFactory.
+     * <p>If this method is
+     * called, it must be called before {@link #setRenderer(Renderer)}
+     * is called.
+     * <p>
+     * If this method is not called, then by default
+     * a context will be created with no shared context and
+     * with a null attribute list.
+     */
+    public void setEGLContextFactory(EGLContextFactory factory) {
+        checkRenderThreadState();
+        mEGLContextFactory = factory;
+    }
+
+    /**
+     * Install a custom EGLWindowSurfaceFactory.
+     * <p>If this method is
+     * called, it must be called before {@link #setRenderer(Renderer)}
+     * is called.
+     * <p>
+     * If this method is not called, then by default
+     * a window surface will be created with a null attribute list.
+     */
+    public void setEGLWindowSurfaceFactory(EGLWindowSurfaceFactory factory) {
+        checkRenderThreadState();
+        mEGLWindowSurfaceFactory = factory;
+    }
+
+    /**
+     * Install a custom EGLConfigChooser.
+     * <p>If this method is
+     * called, it must be called before {@link #setRenderer(Renderer)}
+     * is called.
+     * <p>
+     * If no setEGLConfigChooser method is called, then by default the
+     * view will choose an EGLConfig that is compatible with the current
+     * android.view.Surface, with a depth buffer depth of
+     * at least 16 bits.
+     * @param configChooser
+     */
+    public void setEGLConfigChooser(EGLConfigChooser configChooser) {
+        checkRenderThreadState();
+        mEGLConfigChooser = configChooser;
+    }
+
+    /**
+     * Install a config chooser which will choose a config
+     * as close to 16-bit RGB as possible, with or without an optional depth
+     * buffer as close to 16-bits as possible.
+     * <p>If this method is
+     * called, it must be called before {@link #setRenderer(Renderer)}
+     * is called.
+     * <p>
+     * If no setEGLConfigChooser method is called, then by default the
+     * view will choose an RGB_888 surface with a depth buffer depth of
+     * at least 16 bits.
+     *
+     * @param needDepth
+     */
+    public void setEGLConfigChooser(boolean needDepth) {
+        setEGLConfigChooser(new SimpleEGLConfigChooser(needDepth));
+    }
+
+    /**
+     * Install a config chooser which will choose a config
+     * with at least the specified depthSize and stencilSize,
+     * and exactly the specified redSize, greenSize, blueSize and alphaSize.
+     * <p>If this method is
+     * called, it must be called before {@link #setRenderer(Renderer)}
+     * is called.
+     * <p>
+     * If no setEGLConfigChooser method is called, then by default the
+     * view will choose an RGB_888 surface with a depth buffer depth of
+     * at least 16 bits.
+     *
+     */
+    public void setEGLConfigChooser(int redSize, int greenSize, int blueSize,
+                                    int alphaSize, int depthSize, int stencilSize) {
+        setEGLConfigChooser(new ComponentSizeChooser(redSize, greenSize,
+                blueSize, alphaSize, depthSize, stencilSize));
+    }
+
+    /**
+     * Inform the default EGLContextFactory and default EGLConfigChooser
+     * which EGLContext client version to pick.
+     * <p>Use this method to create an OpenGL ES 2.0-compatible context.
+     * Example:
+     * <pre class="prettyprint">
+     *     public MyView(Context context) {
+     *         super(context);
+     *         setEGLContextClientVersion(2); // Pick an OpenGL ES 2.0 context.
+     *         setRenderer(new MyRenderer());
+     *     }
+     * </pre>
+     * <p>Note: Activities which require OpenGL ES 2.0 should indicate this by
+     * setting @lt;uses-feature android:glEsVersion="0x00020000" /> in the activity's
+     * AndroidManifest.xml file.
+     * <p>If this method is called, it must be called before {@link #setRenderer(Renderer)}
+     * is called.
+     * <p>This method only affects the behavior of the default EGLContexFactory and the
+     * default EGLConfigChooser. If
+     * {@link #setEGLContextFactory(EGLContextFactory)} has been called, then the supplied
+     * EGLContextFactory is responsible for creating an OpenGL ES 2.0-compatible context.
+     * If
+     * {@link #setEGLConfigChooser(EGLConfigChooser)} has been called, then the supplied
+     * EGLConfigChooser is responsible for choosing an OpenGL ES 2.0-compatible config.
+     * @param version The EGLContext client version to choose. Use 2 for OpenGL ES 2.0
+     */
+    public void setEGLContextClientVersion(int version) {
+        checkRenderThreadState();
+        mEGLContextClientVersion = version;
+    }
+
+    /**
+     * Set the rendering mode. When renderMode is
+     * RENDERMODE_CONTINUOUSLY, the renderer is called
+     * repeatedly to re-render the scene. When renderMode
+     * is RENDERMODE_WHEN_DIRTY, the renderer only rendered when the surface
+     * is created, or when {@link #requestRender} is called. Defaults to RENDERMODE_CONTINUOUSLY.
+     * <p>
+     * Using RENDERMODE_WHEN_DIRTY can improve battery life and overall system performance
+     * by allowing the GPU and CPU to idle when the view does not need to be updated.
+     * <p>
+     * This method can only be called after {@link #setRenderer(Renderer)}
+     *
+     * @param renderMode one of the RENDERMODE_X constants
+     * @see #RENDERMODE_CONTINUOUSLY
+     * @see #RENDERMODE_WHEN_DIRTY
+     */
+    public void setRenderMode(int renderMode) {
+        mGLThread.setRenderMode(renderMode);
+    }
+
+    /**
+     * Get the current rendering mode. May be called
+     * from any thread. Must not be called before a renderer has been set.
+     * @return the current rendering mode.
+     * @see #RENDERMODE_CONTINUOUSLY
+     * @see #RENDERMODE_WHEN_DIRTY
+     */
+    public int getRenderMode() {
+        return mGLThread.getRenderMode();
+    }
+
+    /**
+     * Request that the renderer render a frame.
+     * This method is typically used when the render mode has been set to
+     * {@link #RENDERMODE_WHEN_DIRTY}, so that frames are only rendered on demand.
+     * May be called
+     * from any thread. Must not be called before a renderer has been set.
+     */
+    public void requestRender() {
+        mGLThread.requestRender();
+    }
+
+    /**
+     * use {@link #setRenderer} instead
+     */
+    @Deprecated
+    @Override
+    public void setSurfaceTextureListener(SurfaceTextureListener listener) {
+        if (mRenderer == null) {
+            // 与普通TextureView一样
+            super.setSurfaceTextureListener(listener);
+        }
+        Log.e(TAG, "setSurfaceTextureListener preserved, setRenderer() instead?");
+    }
+
+    @Override
+    public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
+        mGLThread.surfaceCreated();
+        onSurfaceTextureSizeChanged(surface, width, height);
+    }
+
+    @Override
+    public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
+        mGLThread.onWindowResize(width, height);
+    }
+
+    @Override
+    public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
+        // Surface will be destroyed when we return
+        mGLThread.surfaceDestroyed();
+        if(null != mRenderer) {
+            mRenderer.onSurfaceDestroyed();
+        }
+        return true;
+    }
+
+    @Override
+    public void onSurfaceTextureUpdated(SurfaceTexture surface) {
+
+    }
+
+    /**
+     * Inform the view that the activity is paused. The owner of this view must
+     * call this method when the activity is paused. Calling this method will
+     * pause the rendering thread.
+     * Must not be called before a renderer has been set.
+     */
+    public void onPause() {
+        mGLThread.onPause();
+    }
+
+    /**
+     * Inform the view that the activity is resumed. The owner of this view must
+     * call this method when the activity is resumed. Calling this method will
+     * recreate the OpenGL display and resume the rendering
+     * thread.
+     * Must not be called before a renderer has been set.
+     */
+    public void onResume() {
+        mGLThread.onResume();
+    }
+
+    /**
+     * Queue a runnable to be run on the GL rendering thread. This can be used
+     * to communicate with the Renderer on the rendering thread.
+     * Must not be called before a renderer has been set.
+     * @param r the runnable to be run on the GL rendering thread.
+     */
+    public void queueEvent(Runnable r) {
+        mGLThread.queueEvent(r);
+    }
+
+    /**
+     * This method is used as part of the View class and is not normally
+     * called or subclassed by clients of GLTextureView.
+     */
+    @Override
+    protected void onAttachedToWindow() {
+        super.onAttachedToWindow();
+        if (LOG_ATTACH_DETACH) {
+            Log.d(TAG, "onAttachedToWindow reattach =" + mDetached);
+        }
+        if (mDetached && (mRenderer != null)) {
+            int renderMode = RENDERMODE_CONTINUOUSLY;
+            if (mGLThread != null) {
+                renderMode = mGLThread.getRenderMode();
+            }
+            mGLThread = new GLThread(mThisWeakRef);
+            if (renderMode != RENDERMODE_CONTINUOUSLY) {
+                mGLThread.setRenderMode(renderMode);
+            }
+            mGLThread.start();
+        }
+        mDetached = false;
+    }
+
+    @Override
+    protected void onDetachedFromWindow() {
+        if (LOG_ATTACH_DETACH) {
+            Log.d(TAG, "onDetachedFromWindow");
+        }
+        if (mGLThread != null) {
+            mGLThread.requestExitAndWait();
+        }
+        mDetached = true;
+        super.onDetachedFromWindow();
+    }
+
+    // ----------------------------------------------------------------------
+
+    /**
+     * An interface used to wrap a GL interface.
+     * <p>Typically
+     * used for implementing debugging and tracing on top of the default
+     * GL interface. You would typically use this by creating your own class
+     * that implemented all the GL methods by delegating to another GL instance.
+     * Then you could add your own behavior before or after calling the
+     * delegate. All the GLWrapper would do was instantiate and return the
+     * wrapper GL instance:
+     * <pre class="prettyprint">
+     * class MyGLWrapper implements GLWrapper {
+     *     GL wrap(GL gl) {
+     *         return new MyGLImplementation(gl);
+     *     }
+     *     static class MyGLImplementation implements GL,GL10,GL11,... {
+     *         ...
+     *     }
+     * }
+     * </pre>
+     * @see #setGLWrapper(GLWrapper)
+     */
+    public interface GLWrapper {
+        /**
+         * Wraps a gl interface in another gl interface.
+         * @param gl a GL interface that is to be wrapped.
+         * @return either the input argument or another GL object that wraps the input argument.
+         */
+        GL wrap(GL gl);
+    }
+
+    /**
+     * A generic renderer interface.
+     * <p>
+     * The renderer is responsible for making OpenGL calls to render a frame.
+     * <p>
+     * GLTextureView clients typically create their own classes that implement
+     * this interface, and then call {@link GLTextureView#setRenderer} to
+     * register the renderer with the GLTextureView.
+     * <p>
+     *
+     * <div class="special reference">
+     * <h3>Developer Guides</h3>
+     * <p>For more information about how to use OpenGL, read the
+     * <a href="{@docRoot}guide/topics/graphics/opengl.html">OpenGL</a> developer guide.</p>
+     * </div>
+     *
+     * <h3>Threading</h3>
+     * The renderer will be called on a separate thread, so that rendering
+     * performance is decoupled from the UI thread. Clients typically need to
+     * communicate with the renderer from the UI thread, because that's where
+     * input events are received. Clients can communicate using any of the
+     * standard Java techniques for cross-thread communication, or they can
+     * use the {@link GLTextureView#queueEvent(Runnable)} convenience method.
+     * <p>
+     * <h3>EGL Context Lost</h3>
+     * There are situations where the EGL rendering context will be lost. This
+     * typically happens when device wakes up after going to sleep. When
+     * the EGL context is lost, all OpenGL resources (such as textures) that are
+     * associated with that context will be automatically deleted. In order to
+     * keep rendering correctly, a renderer must recreate any lost resources
+     * that it still needs. The {@link #onSurfaceCreated(GL10, EGLConfig)} method
+     * is a convenient place to do this.
+     *
+     *
+     * @see #setRenderer(Renderer)
+     */
+    public interface Renderer {
+        /**
+         * Called when the surface is created or recreated.
+         * <p>
+         * Called when the rendering thread
+         * starts and whenever the EGL context is lost. The EGL context will typically
+         * be lost when the Android device awakes after going to sleep.
+         * <p>
+         * Since this method is called at the beginning of rendering, as well as
+         * every time the EGL context is lost, this method is a convenient place to put
+         * code to create resources that need to be created when the rendering
+         * starts, and that need to be recreated when the EGL context is lost.
+         * Textures are an example of a resource that you might want to create
+         * here.
+         * <p>
+         * Note that when the EGL context is lost, all OpenGL resources associated
+         * with that context will be automatically deleted. You do not need to call
+         * the corresponding "glDelete" methods such as glDeleteTextures to
+         * manually delete these lost resources.
+         * <p>
+         * @param gl the GL interface. Use <code>instanceof</code> to
+         * test if the interface supports GL11 or higher interfaces.
+         * @param config the EGLConfig of the created surface. Can be used
+         * to create matching pbuffers.
+         */
+        void onSurfaceCreated(GL10 gl, EGLConfig config);
+
+        /**
+         * Called when the surface changed size.
+         * <p>
+         * Called after the surface is created and whenever
+         * the OpenGL ES surface size changes.
+         * <p>
+         * Typically you will set your viewport here. If your camera
+         * is fixed then you could also set your projection matrix here:
+         * <pre class="prettyprint">
+         * void onSurfaceChanged(GL10 gl, int width, int height) {
+         *     gl.glViewport(0, 0, width, height);
+         *     // for a fixed camera, set the projection too
+         *     float ratio = (float) width / height;
+         *     gl.glMatrixMode(GL10.GL_PROJECTION);
+         *     gl.glLoadIdentity();
+         *     gl.glFrustumf(-ratio, ratio, -1, 1, 1, 10);
+         * }
+         * </pre>
+         * @param gl the GL interface. Use <code>instanceof</code> to
+         * test if the interface supports GL11 or higher interfaces.
+         * @param width
+         * @param height
+         */
+        void onSurfaceChanged(GL10 gl, int width, int height);
+
+        /**
+         * Called to draw the current frame.
+         * <p>
+         * This method is responsible for drawing the current frame.
+         * <p>
+         * The implementation of this method typically looks like this:
+         * <pre class="prettyprint">
+         * void onDrawFrame(GL10 gl) {
+         *     gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
+         *     //... other gl calls to render the scene ...
+         * }
+         * </pre>
+         * @param gl the GL interface. Use <code>instanceof</code> to
+         * test if the interface supports GL11 or higher interfaces.
+         */
+        boolean onDrawFrame(GL10 gl);
+
+        void onSurfaceDestroyed();
+    }
+
+    /**
+     * An interface for customizing the eglCreateContext and eglDestroyContext calls.
+     * <p>
+     * This interface must be implemented by clients wishing to call
+     * {@link GLTextureView#setEGLContextFactory(EGLContextFactory)}
+     */
+    public interface EGLContextFactory {
+        EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig eglConfig);
+        void destroyContext(EGL10 egl, EGLDisplay display, EGLContext context);
+    }
+
+    private class DefaultContextFactory implements EGLContextFactory {
+        private int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
+
+        public EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig config) {
+            int[] attrib_list = {EGL_CONTEXT_CLIENT_VERSION, mEGLContextClientVersion,
+                    EGL10.EGL_NONE };
+
+            return egl.eglCreateContext(display, config, EGL10.EGL_NO_CONTEXT,
+                    mEGLContextClientVersion != 0 ? attrib_list : null);
+        }
+
+        public void destroyContext(EGL10 egl, EGLDisplay display,
+                                   EGLContext context) {
+            if (!egl.eglDestroyContext(display, context)) {
+                Log.e("DefaultContextFactory", "display:" + display + " context: " + context);
+                if (LOG_THREADS) {
+                    Log.i("DefaultContextFactory", "tid=" + Thread.currentThread().getId());
+                }
+                EglHelper.throwEglException("eglDestroyContex", egl.eglGetError());
+            }
+        }
+    }
+
+    /**
+     * An interface for customizing the eglCreateWindowSurface and eglDestroySurface calls.
+     * <p>
+     * This interface must be implemented by clients wishing to call
+     * {@link GLTextureView#setEGLWindowSurfaceFactory(EGLWindowSurfaceFactory)}
+     */
+    public interface EGLWindowSurfaceFactory {
+        /**
+         *  @return null if the surface cannot be constructed.
+         */
+        EGLSurface createWindowSurface(EGL10 egl, EGLDisplay display, EGLConfig config,
+                                       Object nativeWindow);
+        void destroySurface(EGL10 egl, EGLDisplay display, EGLSurface surface);
+    }
+
+    private static class DefaultWindowSurfaceFactory implements EGLWindowSurfaceFactory {
+
+        public EGLSurface createWindowSurface(EGL10 egl, EGLDisplay display,
+                                              EGLConfig config, Object nativeWindow) {
+            EGLSurface result = null;
+            try {
+                result = egl.eglCreateWindowSurface(display, config, nativeWindow, null);
+            } catch (IllegalArgumentException e) {
+                // This exception indicates that the surface flinger surface
+                // is not valid. This can happen if the surface flinger surface has
+                // been torn down, but the application has not yet been
+                // notified via SurfaceHolder.Callback.surfaceDestroyed.
+                // In theory the application should be notified first,
+                // but in practice sometimes it is not. See b/4588890
+                Log.e(TAG, "eglCreateWindowSurface", e);
+            }
+            return result;
+        }
+
+        public void destroySurface(EGL10 egl, EGLDisplay display,
+                                   EGLSurface surface) {
+            egl.eglDestroySurface(display, surface);
+        }
+    }
+
+    /**
+     * An interface for choosing an EGLConfig configuration from a list of
+     * potential configurations.
+     * <p>
+     * This interface must be implemented by clients wishing to call
+     * {@link GLTextureView#setEGLConfigChooser(EGLConfigChooser)}
+     */
+    public interface EGLConfigChooser {
+        /**
+         * Choose a configuration from the list. Implementors typically
+         * implement this method by calling
+         * {@link EGL10#eglChooseConfig} and iterating through the results. Please consult the
+         * EGL specification available from The Khronos Group to learn how to call eglChooseConfig.
+         * @param egl the EGL10 for the current display.
+         * @param display the current display.
+         * @return the chosen configuration.
+         */
+        EGLConfig chooseConfig(EGL10 egl, EGLDisplay display);
+    }
+
+    private abstract class BaseConfigChooser
+            implements EGLConfigChooser {
+        public BaseConfigChooser(int[] configSpec) {
+            mConfigSpec = filterConfigSpec(configSpec);
+        }
+
+        public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display) {
+            int[] num_config = new int[1];
+            if (!egl.eglChooseConfig(display, mConfigSpec, null, 0,
+                    num_config)) {
+                throw new IllegalArgumentException("eglChooseConfig failed");
+            }
+
+            int numConfigs = num_config[0];
+
+            if (numConfigs <= 0) {
+                throw new IllegalArgumentException(
+                        "No configs match configSpec");
+            }
+
+            EGLConfig[] configs = new EGLConfig[numConfigs];
+            if (!egl.eglChooseConfig(display, mConfigSpec, configs, numConfigs,
+                    num_config)) {
+                throw new IllegalArgumentException("eglChooseConfig#2 failed");
+            }
+            EGLConfig config = chooseConfig(egl, display, configs);
+            if (config == null) {
+                throw new IllegalArgumentException("No config chosen");
+            }
+            return config;
+        }
+
+        abstract EGLConfig chooseConfig(EGL10 egl, EGLDisplay display,
+                                        EGLConfig[] configs);
+
+        protected int[] mConfigSpec;
+
+        private int[] filterConfigSpec(int[] configSpec) {
+            if (mEGLContextClientVersion != 2 && mEGLContextClientVersion != 3) {
+                return configSpec;
+            }
+            /* We know none of the subclasses define EGL_RENDERABLE_TYPE.
+             * And we know the configSpec is well formed.
+             */
+            int len = configSpec.length;
+            int[] newConfigSpec = new int[len + 2];
+            System.arraycopy(configSpec, 0, newConfigSpec, 0, len-1);
+            newConfigSpec[len-1] = EGL10.EGL_RENDERABLE_TYPE;
+            if (mEGLContextClientVersion == 2) {
+                newConfigSpec[len] = EGL14.EGL_OPENGL_ES2_BIT;  /* EGL_OPENGL_ES2_BIT */
+            } else {
+                newConfigSpec[len] = EGLExt.EGL_OPENGL_ES3_BIT_KHR; /* EGL_OPENGL_ES3_BIT_KHR */
+            }
+            newConfigSpec[len+1] = EGL10.EGL_NONE;
+            return newConfigSpec;
+        }
+    }
+
+    /**
+     * Choose a configuration with exactly the specified r,g,b,a sizes,
+     * and at least the specified depth and stencil sizes.
+     */
+    private class ComponentSizeChooser extends BaseConfigChooser {
+        public ComponentSizeChooser(int redSize, int greenSize, int blueSize,
+                                    int alphaSize, int depthSize, int stencilSize) {
+            super(new int[] {
+                    EGL10.EGL_RED_SIZE, redSize,
+                    EGL10.EGL_GREEN_SIZE, greenSize,
+                    EGL10.EGL_BLUE_SIZE, blueSize,
+                    EGL10.EGL_ALPHA_SIZE, alphaSize,
+                    EGL10.EGL_DEPTH_SIZE, depthSize,
+                    EGL10.EGL_STENCIL_SIZE, stencilSize,
+                    EGL10.EGL_NONE});
+            mValue = new int[1];
+            mRedSize = redSize;
+            mGreenSize = greenSize;
+            mBlueSize = blueSize;
+            mAlphaSize = alphaSize;
+            mDepthSize = depthSize;
+            mStencilSize = stencilSize;
+        }
+
+        @Override
+        public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display,
+                                      EGLConfig[] configs) {
+            for (EGLConfig config : configs) {
+                int d = findConfigAttrib(egl, display, config,
+                        EGL10.EGL_DEPTH_SIZE, 0);
+                int s = findConfigAttrib(egl, display, config,
+                        EGL10.EGL_STENCIL_SIZE, 0);
+                if ((d >= mDepthSize) && (s >= mStencilSize)) {
+                    int r = findConfigAttrib(egl, display, config,
+                            EGL10.EGL_RED_SIZE, 0);
+                    int g = findConfigAttrib(egl, display, config,
+                            EGL10.EGL_GREEN_SIZE, 0);
+                    int b = findConfigAttrib(egl, display, config,
+                            EGL10.EGL_BLUE_SIZE, 0);
+                    int a = findConfigAttrib(egl, display, config,
+                            EGL10.EGL_ALPHA_SIZE, 0);
+                    if ((r == mRedSize) && (g == mGreenSize)
+                            && (b == mBlueSize) && (a == mAlphaSize)) {
+                        return config;
+                    }
+                }
+            }
+            return null;
+        }
+
+        private int findConfigAttrib(EGL10 egl, EGLDisplay display,
+                                     EGLConfig config, int attribute, int defaultValue) {
+
+            if (egl.eglGetConfigAttrib(display, config, attribute, mValue)) {
+                return mValue[0];
+            }
+            return defaultValue;
+        }
+
+        private int[] mValue;
+        // Subclasses can adjust these values:
+        protected int mRedSize;
+        protected int mGreenSize;
+        protected int mBlueSize;
+        protected int mAlphaSize;
+        protected int mDepthSize;
+        protected int mStencilSize;
+    }
+
+    /**
+     * This class will choose a RGB_888 surface with
+     * or without a depth buffer.
+     *
+     */
+    private class SimpleEGLConfigChooser extends ComponentSizeChooser {
+        public SimpleEGLConfigChooser(boolean withDepthBuffer) {
+            super(8, 8, 8, 0, withDepthBuffer ? 16 : 0, 0);
+        }
+    }
+
+    /**
+     * An EGL helper class.
+     */
+
+    private static class EglHelper {
+        public EglHelper(WeakReference<GLTextureView> glTextureViewWeakRef) {
+            mGLTextureViewWeakRef = glTextureViewWeakRef;
+        }
+
+        /**
+         * Initialize EGL for a given configuration spec.
+         */
+        public void start() {
+            if (LOG_EGL) {
+                Log.w("EglHelper", "start() tid=" + Thread.currentThread().getId());
+            }
+            /*
+             * Get an EGL instance
+             */
+            mEgl = (EGL10) EGLContext.getEGL();
+
+            /*
+             * Get to the default display.
+             */
+            mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
+
+            if (mEglDisplay == EGL10.EGL_NO_DISPLAY) {
+                throw new RuntimeException("eglGetDisplay failed");
+            }
+
+            /*
+             * We can now initialize EGL for that display
+             */
+            int[] version = new int[2];
+            if(!mEgl.eglInitialize(mEglDisplay, version)) {
+                throw new RuntimeException("eglInitialize failed");
+            }
+            GLTextureView view = mGLTextureViewWeakRef.get();
+            if (view == null) {
+                mEglConfig = null;
+                mEglContext = null;
+            } else {
+                mEglConfig = view.mEGLConfigChooser.chooseConfig(mEgl, mEglDisplay);
+
+                /*
+                * Create an EGL context. We want to do this as rarely as we can, because an
+                * EGL context is a somewhat heavy object.
+                */
+                mEglContext = view.mEGLContextFactory.createContext(mEgl, mEglDisplay, mEglConfig);
+            }
+            if (mEglContext == null || mEglContext == EGL10.EGL_NO_CONTEXT) {
+                mEglContext = null;
+                throwEglException("createContext");
+            }
+            if (LOG_EGL) {
+                Log.w("EglHelper", "createContext " + mEglContext + " tid=" + Thread.currentThread().getId());
+            }
+
+            mEglSurface = null;
+        }
+
+        /**
+         * Create an egl surface for the current SurfaceHolder surface. If a surface
+         * already exists, destroy it before creating the new surface.
+         *
+         * @return true if the surface was created successfully.
+         */
+        public boolean createSurface() {
+            if (LOG_EGL) {
+                Log.w("EglHelper", "createSurface()  tid=" + Thread.currentThread().getId());
+            }
+            /*
+             * Check preconditions.
+             */
+            if (mEgl == null) {
+                throw new RuntimeException("egl not initialized");
+            }
+            if (mEglDisplay == null) {
+                throw new RuntimeException("eglDisplay not initialized");
+            }
+            if (mEglConfig == null) {
+                throw new RuntimeException("mEglConfig not initialized");
+            }
+
+            /*
+             *  The window size has changed, so we need to create a new
+             *  surface.
+             */
+            destroySurfaceImp();
+
+            /*
+             * Create an EGL surface we can render into.
+             */
+            GLTextureView view = mGLTextureViewWeakRef.get();
+            if (view != null) {
+                mEglSurface = view.mEGLWindowSurfaceFactory.createWindowSurface(mEgl,
+                        mEglDisplay, mEglConfig, view.getSurfaceTexture());
+            } else {
+                mEglSurface = null;
+            }
+
+            if (mEglSurface == null || mEglSurface == EGL10.EGL_NO_SURFACE) {
+                int error = mEgl.eglGetError();
+                if (error == EGL10.EGL_BAD_NATIVE_WINDOW) {
+                    Log.e("EglHelper", "createWindowSurface returned EGL_BAD_NATIVE_WINDOW.");
+                }
+                return false;
+            }
+
+            /*
+             * Before we can issue GL commands, we need to make sure
+             * the context is current and bound to a surface.
+             */
+            if (!mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext)) {
+                /*
+                 * Could not make the context current, probably because the underlying
+                 * TextureView surface has been destroyed.
+                 */
+                logEglErrorAsWarning("EGLHelper", "eglMakeCurrent", mEgl.eglGetError());
+                return false;
+            }
+
+            return true;
+        }
+
+        /**
+         * Create a GL object for the current EGL context.
+         * @return
+         */
+        GL createGL() {
+
+            GL gl = mEglContext.getGL();
+            GLTextureView view = mGLTextureViewWeakRef.get();
+            if (view != null) {
+                if (view.mGLWrapper != null) {
+                    gl = view.mGLWrapper.wrap(gl);
+                }
+
+                if ((view.mDebugFlags & (DEBUG_CHECK_GL_ERROR | DEBUG_LOG_GL_CALLS)) != 0) {
+                    int configFlags = 0;
+                    Writer log = null;
+                    if ((view.mDebugFlags & DEBUG_CHECK_GL_ERROR) != 0) {
+                        configFlags |= GLDebugHelper.CONFIG_CHECK_GL_ERROR;
+                    }
+                    if ((view.mDebugFlags & DEBUG_LOG_GL_CALLS) != 0) {
+                        log = new LogWriter();
+                    }
+                    gl = GLDebugHelper.wrap(gl, configFlags, log);
+                }
+            }
+            return gl;
+        }
+
+        /**
+         * Display the current render surface.
+         * @return the EGL error code from eglSwapBuffers.
+         */
+        public int swap() {
+            if (! mEgl.eglSwapBuffers(mEglDisplay, mEglSurface)) {
+                return mEgl.eglGetError();
+            }
+            return EGL10.EGL_SUCCESS;
+        }
+
+        public void destroySurface() {
+            if (LOG_EGL) {
+                Log.w("EglHelper", "destroySurface()  tid=" + Thread.currentThread().getId());
+            }
+            destroySurfaceImp();
+        }
+
+        private void destroySurfaceImp() {
+            if (mEglSurface != null && mEglSurface != EGL10.EGL_NO_SURFACE) {
+                mEgl.eglMakeCurrent(mEglDisplay, EGL10.EGL_NO_SURFACE,
+                        EGL10.EGL_NO_SURFACE,
+                        EGL10.EGL_NO_CONTEXT);
+                GLTextureView view = mGLTextureViewWeakRef.get();
+                if (view != null) {
+                    view.mEGLWindowSurfaceFactory.destroySurface(mEgl, mEglDisplay, mEglSurface);
+                }
+                mEglSurface = null;
+            }
+        }
+
+        public void finish() {
+            if (LOG_EGL) {
+                Log.w("EglHelper", "finish() tid=" + Thread.currentThread().getId());
+            }
+            if (mEglContext != null) {
+                GLTextureView view = mGLTextureViewWeakRef.get();
+                if (view != null) {
+                    view.mEGLContextFactory.destroyContext(mEgl, mEglDisplay, mEglContext);
+                }
+                mEglContext = null;
+            }
+            if (mEglDisplay != null) {
+                mEgl.eglTerminate(mEglDisplay);
+                mEglDisplay = null;
+            }
+        }
+
+        private void throwEglException(String function) {
+            throwEglException(function, mEgl.eglGetError());
+        }
+
+        public static void throwEglException(String function, int error) {
+            String message = formatEglError(function, error);
+            if (LOG_THREADS) {
+                Log.e("EglHelper", "throwEglException tid=" + Thread.currentThread().getId() + " "
+                        + message);
+            }
+            throw new RuntimeException(message);
+        }
+
+        public static void logEglErrorAsWarning(String tag, String function, int error) {
+            Log.w(tag, formatEglError(function, error));
+        }
+
+        public static String formatEglError(String function, int error) {
+            return function + " failed: " + eglGetErrorString(error);
+        }
+
+        static String eglGetErrorString(int error) {
+            switch (error) {
+                case EGL11.EGL_SUCCESS:
+                    return "EGL_SUCCESS";
+                case EGL11.EGL_NOT_INITIALIZED:
+                    return "EGL_NOT_INITIALIZED";
+                case EGL11.EGL_BAD_ACCESS:
+                    return "EGL_BAD_ACCESS";
+                case EGL11.EGL_BAD_ALLOC:
+                    return "EGL_BAD_ALLOC";
+                case EGL11.EGL_BAD_ATTRIBUTE:
+                    return "EGL_BAD_ATTRIBUTE";
+                case EGL11.EGL_BAD_CONFIG:
+                    return "EGL_BAD_CONFIG";
+                case EGL11.EGL_BAD_CONTEXT:
+                    return "EGL_BAD_CONTEXT";
+                case EGL11.EGL_BAD_CURRENT_SURFACE:
+                    return "EGL_BAD_CURRENT_SURFACE";
+                case EGL11.EGL_BAD_DISPLAY:
+                    return "EGL_BAD_DISPLAY";
+                case EGL11.EGL_BAD_MATCH:
+                    return "EGL_BAD_MATCH";
+                case EGL11.EGL_BAD_NATIVE_PIXMAP:
+                    return "EGL_BAD_NATIVE_PIXMAP";
+                case EGL11.EGL_BAD_NATIVE_WINDOW:
+                    return "EGL_BAD_NATIVE_WINDOW";
+                case EGL11.EGL_BAD_PARAMETER:
+                    return "EGL_BAD_PARAMETER";
+                case EGL11.EGL_BAD_SURFACE:
+                    return "EGL_BAD_SURFACE";
+                case EGL11.EGL_CONTEXT_LOST:
+                    return "EGL_CONTEXT_LOST";
+                default:
+                    return "0x" + Integer.toHexString(error);
+            }
+        }
+
+        private WeakReference<GLTextureView> mGLTextureViewWeakRef;
+        EGL10 mEgl;
+        EGLDisplay mEglDisplay;
+        EGLSurface mEglSurface;
+        EGLConfig mEglConfig;
+        EGLContext mEglContext;
+
+    }
+
+    /**
+     * A generic GL Thread. Takes care of initializing EGL and GL. Delegates
+     * to a Renderer instance to do the actual drawing. Can be configured to
+     * render continuously or on request.
+     *
+     * All potentially blocking synchronization is done through the
+     * sGLThreadManager object. This avoids multiple-lock ordering issues.
+     *
+     */
+    static class GLThread extends Thread {
+        GLThread(WeakReference<GLTextureView> glTextureViewWeakRef) {
+            super();
+            mWidth = 0;
+            mHeight = 0;
+            mRequestRender = true;
+            mRenderMode = RENDERMODE_CONTINUOUSLY;
+            mGLTextureViewWeakRef = glTextureViewWeakRef;
+        }
+
+        @Override
+        public void run() {
+            setName("GLThread " + getId());
+            if (LOG_THREADS) {
+                Log.i("GLThread", "starting tid=" + getId());
+            }
+
+            try {
+                guardedRun();
+            } catch (InterruptedException e) {
+                // fall thru and exit normally
+            } finally {
+                sGLThreadManager.threadExiting(this);
+            }
+        }
+
+        /*
+         * This private method should only be called inside a
+         * synchronized(sGLThreadManager) block.
+         */
+        private void stopEglSurfaceLocked() {
+            if (mHaveEglSurface) {
+                mHaveEglSurface = false;
+                mEglHelper.destroySurface();
+            }
+        }
+
+        /*
+         * This private method should only be called inside a
+         * synchronized(sGLThreadManager) block.
+         */
+        private void stopEglContextLocked() {
+            if (mHaveEglContext) {
+                mEglHelper.finish();
+                mHaveEglContext = false;
+                sGLThreadManager.releaseEglContextLocked(this);
+            }
+        }
+        private void guardedRun() throws InterruptedException {
+            mEglHelper = new EglHelper(mGLTextureViewWeakRef);
+            mHaveEglContext = false;
+            mHaveEglSurface = false;
+            try {
+                GL10 gl = null;
+                boolean createEglContext = false;
+                boolean createEglSurface = false;
+                boolean createGlInterface = false;
+                boolean lostEglContext = false;
+                boolean sizeChanged = false;
+                boolean wantRenderNotification = false;
+                boolean doRenderNotification = false;
+                boolean askedToReleaseEglContext = false;
+                int w = 0;
+                int h = 0;
+                Runnable event = null;
+
+                while (true) {
+                    synchronized (sGLThreadManager) {
+                        while (true) {
+                            if (mShouldExit) {
+                                return;
+                            }
+
+                            if (! mEventQueue.isEmpty()) {
+                                event = mEventQueue.remove(0);
+                                break;
+                            }
+
+                            // Update the pause state.
+                            boolean pausing = false;
+                            if (mPaused != mRequestPaused) {
+                                pausing = mRequestPaused;
+                                mPaused = mRequestPaused;
+                                sGLThreadManager.notifyAll();
+                                if (LOG_PAUSE_RESUME) {
+                                    Log.i("GLThread", "mPaused is now " + mPaused + " tid=" + getId());
+                                }
+                            }
+
+                            // Do we need to give up the EGL context?
+                            if (mShouldReleaseEglContext) {
+                                if (LOG_SURFACE) {
+                                    Log.i("GLThread", "releasing EGL context because asked to tid=" + getId());
+                                }
+                                stopEglSurfaceLocked();
+                                stopEglContextLocked();
+                                mShouldReleaseEglContext = false;
+                                askedToReleaseEglContext = true;
+                            }
+
+                            // Have we lost the EGL context?
+                            if (lostEglContext) {
+                                stopEglSurfaceLocked();
+                                stopEglContextLocked();
+                                lostEglContext = false;
+                            }
+
+                            // When pausing, release the EGL surface:
+                            if (pausing && mHaveEglSurface) {
+                                if (LOG_SURFACE) {
+                                    Log.i("GLThread", "releasing EGL surface because paused tid=" + getId());
+                                }
+                                stopEglSurfaceLocked();
+                            }
+
+                            // When pausing, optionally release the EGL Context:
+                            if (pausing && mHaveEglContext) {
+                                GLTextureView view = mGLTextureViewWeakRef.get();
+                                boolean preserveEglContextOnPause = view == null ?
+                                        false : view.mPreserveEGLContextOnPause;
+                                if (!preserveEglContextOnPause || sGLThreadManager.shouldReleaseEGLContextWhenPausing()) {
+                                    stopEglContextLocked();
+                                    if (LOG_SURFACE) {
+                                        Log.i("GLThread", "releasing EGL context because paused tid=" + getId());
+                                    }
+                                }
+                            }
+
+                            // When pausing, optionally terminate EGL:
+                            if (pausing) {
+                                if (sGLThreadManager.shouldTerminateEGLWhenPausing()) {
+                                    mEglHelper.finish();
+                                    if (LOG_SURFACE) {
+                                        Log.i("GLThread", "terminating EGL because paused tid=" + getId());
+                                    }
+                                }
+                            }
+
+                            // Have we lost the TextureView surface?
+                            if ((! mHasSurface) && (! mWaitingForSurface)) {
+                                if (LOG_SURFACE) {
+                                    Log.i("GLThread", "noticed TextureView surface lost tid=" + getId());
+                                }
+                                if (mHaveEglSurface) {
+                                    stopEglSurfaceLocked();
+                                }
+                                mWaitingForSurface = true;
+                                mSurfaceIsBad = false;
+                                sGLThreadManager.notifyAll();
+                            }
+
+                            // Have we acquired the surface view surface?
+                            if (mHasSurface && mWaitingForSurface) {
+                                if (LOG_SURFACE) {
+                                    Log.i("GLThread", "noticed TextureView surface acquired tid=" + getId());
+                                }
+                                mWaitingForSurface = false;
+                                sGLThreadManager.notifyAll();
+                            }
+
+                            if (doRenderNotification) {
+                                if (LOG_SURFACE) {
+                                    Log.i("GLThread", "sending render notification tid=" + getId());
+                                }
+                                wantRenderNotification = false;
+                                doRenderNotification = false;
+                                mRenderComplete = true;
+                                sGLThreadManager.notifyAll();
+                            }
+
+                            // Ready to draw?
+                            if (readyToDraw()) {
+
+                                // If we don't have an EGL context, try to acquire one.
+                                if (! mHaveEglContext) {
+                                    if (askedToReleaseEglContext) {
+                                        askedToReleaseEglContext = false;
+                                    } else if (sGLThreadManager.tryAcquireEglContextLocked(this)) {
+                                        try {
+                                            mEglHelper.start();
+                                        } catch (RuntimeException t) {
+                                            sGLThreadManager.releaseEglContextLocked(this);
+                                            throw t;
+                                        }
+                                        mHaveEglContext = true;
+                                        createEglContext = true;
+
+                                        sGLThreadManager.notifyAll();
+                                    }
+                                }
+
+                                if (mHaveEglContext && !mHaveEglSurface) {
+                                    mHaveEglSurface = true;
+                                    createEglSurface = true;
+                                    createGlInterface = true;
+                                    sizeChanged = true;
+                                }
+
+                                if (mHaveEglSurface) {
+                                    if (mSizeChanged) {
+                                        sizeChanged = true;
+                                        w = mWidth;
+                                        h = mHeight;
+                                        wantRenderNotification = true;
+                                        if (LOG_SURFACE) {
+                                            Log.i("GLThread",
+                                                    "noticing that we want render notification tid="
+                                                            + getId());
+                                        }
+
+                                        // Destroy and recreate the EGL surface.
+                                        createEglSurface = true;
+
+                                        mSizeChanged = false;
+                                    }
+                                    mRequestRender = false;
+                                    sGLThreadManager.notifyAll();
+                                    break;
+                                }
+                            }
+
+                            // By design, this is the only place in a GLThread thread where we wait().
+                            if (LOG_THREADS) {
+                                Log.i("GLThread", "waiting tid=" + getId()
+                                        + " mHaveEglContext: " + mHaveEglContext
+                                        + " mHaveEglSurface: " + mHaveEglSurface
+                                        + " mFinishedCreatingEglSurface: " + mFinishedCreatingEglSurface
+                                        + " mPaused: " + mPaused
+                                        + " mHasSurface: " + mHasSurface
+                                        + " mSurfaceIsBad: " + mSurfaceIsBad
+                                        + " mWaitingForSurface: " + mWaitingForSurface
+                                        + " mWidth: " + mWidth
+                                        + " mHeight: " + mHeight
+                                        + " mRequestRender: " + mRequestRender
+                                        + " mRenderMode: " + mRenderMode);
+                            }
+                            sGLThreadManager.wait();
+                        }
+                    } // end of synchronized(sGLThreadManager)
+
+                    if (event != null) {
+                        event.run();
+                        event = null;
+                        continue;
+                    }
+
+                    if (createEglSurface) {
+                        if (LOG_SURFACE) {
+                            Log.w("GLThread", "egl createSurface");
+                        }
+                        if (mEglHelper.createSurface()) {
+                            synchronized(sGLThreadManager) {
+                                mFinishedCreatingEglSurface = true;
+                                sGLThreadManager.notifyAll();
+                            }
+                        } else {
+                            synchronized(sGLThreadManager) {
+                                mFinishedCreatingEglSurface = true;
+                                mSurfaceIsBad = true;
+                                sGLThreadManager.notifyAll();
+                            }
+                            continue;
+                        }
+                        createEglSurface = false;
+                    }
+
+                    if (createGlInterface) {
+                        gl = (GL10) mEglHelper.createGL();
+
+                        sGLThreadManager.checkGLDriver(gl);
+                        createGlInterface = false;
+                    }
+
+                    if (createEglContext) {
+                        if (LOG_RENDERER) {
+                            Log.w("GLThread", "onSurfaceCreated");
+                        }
+                        GLTextureView view = mGLTextureViewWeakRef.get();
+                        if (view != null) {
+                            view.mRenderer.onSurfaceCreated(gl, mEglHelper.mEglConfig);
+                        }
+                        createEglContext = false;
+                    }
+
+                    if (sizeChanged) {
+                        if (LOG_RENDERER) {
+                            Log.w("GLThread", "onSurfaceChanged(" + w + ", " + h + ")");
+                        }
+                        GLTextureView view = mGLTextureViewWeakRef.get();
+                        if (view != null) {
+                            view.mRenderer.onSurfaceChanged(gl, w, h);
+                        }
+                        sizeChanged = false;
+                    }
+
+                    if (LOG_RENDERER_DRAW_FRAME) {
+                        Log.w("GLThread", "onDrawFrame tid=" + getId());
+                    }
+                    boolean needSwap = false;
+                    GLTextureView view = mGLTextureViewWeakRef.get();
+                    if (view != null) {
+                        needSwap = view.mRenderer.onDrawFrame(gl);
+                    }
+                    if(needSwap) {
+                        int swapError = mEglHelper.swap();
+                        switch (swapError) {
+                            case EGL10.EGL_SUCCESS:
+                                break;
+                            case EGL11.EGL_CONTEXT_LOST:
+                                if (LOG_SURFACE) {
+                                    Log.i("GLThread", "egl context lost tid=" + getId());
+                                }
+                                lostEglContext = true;
+                                break;
+                            default:
+                                // Other errors typically mean that the current surface is bad,
+                                // probably because the TextureView surface has been destroyed,
+                                // but we haven't been notified yet.
+                                // Log the error to help developers understand why rendering stopped.
+                                EglHelper.logEglErrorAsWarning("GLThread", "eglSwapBuffers", swapError);
+
+                                synchronized (sGLThreadManager) {
+                                    mSurfaceIsBad = true;
+                                    sGLThreadManager.notifyAll();
+                                }
+                                break;
+                        }
+                    }
+
+                    if (wantRenderNotification) {
+                        doRenderNotification = true;
+                    }
+                }
+
+            } finally {
+                /*
+                 * clean-up everything...
+                 */
+                synchronized (sGLThreadManager) {
+                    stopEglSurfaceLocked();
+                    stopEglContextLocked();
+                }
+            }
+        }
+
+        public boolean ableToDraw() {
+            return mHaveEglContext && mHaveEglSurface && readyToDraw();
+        }
+
+        private boolean readyToDraw() {
+            return (!mPaused) && mHasSurface && (!mSurfaceIsBad)
+                    && (mWidth > 0) && (mHeight > 0)
+                    && (mRequestRender || (mRenderMode == RENDERMODE_CONTINUOUSLY));
+        }
+
+        public void setRenderMode(int renderMode) {
+            if ( !((RENDERMODE_WHEN_DIRTY <= renderMode) && (renderMode <= RENDERMODE_CONTINUOUSLY)) ) {
+                throw new IllegalArgumentException("renderMode");
+            }
+            synchronized(sGLThreadManager) {
+                mRenderMode = renderMode;
+                sGLThreadManager.notifyAll();
+            }
+        }
+
+        public int getRenderMode() {
+            synchronized(sGLThreadManager) {
+                return mRenderMode;
+            }
+        }
+
+        public void requestRender() {
+            synchronized(sGLThreadManager) {
+                mRequestRender = true;
+                sGLThreadManager.notifyAll();
+            }
+        }
+
+        public void surfaceCreated() {
+            synchronized(sGLThreadManager) {
+                if (LOG_THREADS) {
+                    Log.i("GLThread", "surfaceCreated tid=" + getId());
+                }
+                mHasSurface = true;
+                mFinishedCreatingEglSurface = false;
+                sGLThreadManager.notifyAll();
+                while (mWaitingForSurface
+                        && !mFinishedCreatingEglSurface
+                        && !mExited) {
+                    try {
+                        sGLThreadManager.wait();
+                    } catch (InterruptedException e) {
+                        Thread.currentThread().interrupt();
+                    }
+                }
+            }
+        }
+
+        public void surfaceDestroyed() {
+            synchronized(sGLThreadManager) {
+                if (LOG_THREADS) {
+                    Log.i("GLThread", "surfaceDestroyed tid=" + getId());
+                }
+                mHasSurface = false;
+                sGLThreadManager.notifyAll();
+                while((!mWaitingForSurface) && (!mExited)) {
+                    try {
+                        sGLThreadManager.wait();
+                    } catch (InterruptedException e) {
+                        Thread.currentThread().interrupt();
+                    }
+                }
+            }
+        }
+
+        public void onPause() {
+            synchronized (sGLThreadManager) {
+                if (LOG_PAUSE_RESUME) {
+                    Log.i("GLThread", "onPause tid=" + getId());
+                }
+                mRequestPaused = true;
+                sGLThreadManager.notifyAll();
+                while ((! mExited) && (! mPaused)) {
+                    if (LOG_PAUSE_RESUME) {
+                        Log.i("Main thread", "onPause waiting for mPaused.");
+                    }
+                    try {
+                        sGLThreadManager.wait();
+                    } catch (InterruptedException ex) {
+                        Thread.currentThread().interrupt();
+                    }
+                }
+            }
+        }
+
+        public void onResume() {
+            synchronized (sGLThreadManager) {
+                if (LOG_PAUSE_RESUME) {
+                    Log.i("GLThread", "onResume tid=" + getId());
+                }
+                mRequestPaused = false;
+                mRequestRender = true;
+                mRenderComplete = false;
+                sGLThreadManager.notifyAll();
+                while ((! mExited) && mPaused && (!mRenderComplete)) {
+                    if (LOG_PAUSE_RESUME) {
+                        Log.i("Main thread", "onResume waiting for !mPaused.");
+                    }
+                    try {
+                        sGLThreadManager.wait();
+                    } catch (InterruptedException ex) {
+                        Thread.currentThread().interrupt();
+                    }
+                }
+            }
+        }
+
+        public void onWindowResize(int w, int h) {
+            synchronized (sGLThreadManager) {
+                mWidth = w;
+                mHeight = h;
+                mSizeChanged = true;
+                mRequestRender = true;
+                mRenderComplete = false;
+                sGLThreadManager.notifyAll();
+
+                // Wait for thread to react to resize and render a frame
+                while (! mExited && !mPaused && !mRenderComplete
+                        && ableToDraw()) {
+                    if (LOG_SURFACE) {
+                        Log.i("Main thread", "onWindowResize waiting for render complete from tid=" + getId());
+                    }
+                    try {
+                        sGLThreadManager.wait();
+                    } catch (InterruptedException ex) {
+                        Thread.currentThread().interrupt();
+                    }
+                }
+            }
+        }
+
+        public void requestExitAndWait() {
+            // don't call this from GLThread thread or it is a guaranteed
+            // deadlock!
+            synchronized(sGLThreadManager) {
+                mShouldExit = true;
+                sGLThreadManager.notifyAll();
+                while (! mExited) {
+                    try {
+                        sGLThreadManager.wait();
+                    } catch (InterruptedException ex) {
+                        Thread.currentThread().interrupt();
+                    }
+                }
+            }
+        }
+
+        public void requestReleaseEglContextLocked() {
+            mShouldReleaseEglContext = true;
+            sGLThreadManager.notifyAll();
+        }
+
+        /**
+         * Queue an "event" to be run on the GL rendering thread.
+         * @param r the runnable to be run on the GL rendering thread.
+         */
+        public void queueEvent(Runnable r) {
+            if (r == null) {
+                throw new IllegalArgumentException("r must not be null");
+            }
+            synchronized(sGLThreadManager) {
+                mEventQueue.add(r);
+                sGLThreadManager.notifyAll();
+            }
+        }
+
+        // Once the thread is started, all accesses to the following member
+        // variables are protected by the sGLThreadManager monitor
+        private boolean mShouldExit;
+        private boolean mExited;
+        private boolean mRequestPaused;
+        private boolean mPaused;
+        private boolean mHasSurface;
+        private boolean mSurfaceIsBad;
+        private boolean mWaitingForSurface;
+        private boolean mHaveEglContext;
+        private boolean mHaveEglSurface;
+        private boolean mFinishedCreatingEglSurface;
+        private boolean mShouldReleaseEglContext;
+        private int mWidth;
+        private int mHeight;
+        private int mRenderMode;
+        private boolean mRequestRender;
+        private boolean mRenderComplete;
+        private ArrayList<Runnable> mEventQueue = new ArrayList<Runnable>();
+        private boolean mSizeChanged = true;
+
+        // End of member variables protected by the sGLThreadManager monitor.
+
+        private EglHelper mEglHelper;
+
+        /**
+         * Set once at thread construction time, nulled out when the parent view is garbage
+         * called. This weak reference allows the GLTextureView to be garbage collected while
+         * the GLThread is still alive.
+         */
+        private WeakReference<GLTextureView> mGLTextureViewWeakRef;
+
+    }
+
+    static class LogWriter extends Writer {
+
+        @Override public void close() {
+            flushBuilder();
+        }
+
+        @Override public void flush() {
+            flushBuilder();
+        }
+
+        @Override public void write(char[] buf, int offset, int count) {
+            for(int i = 0; i < count; i++) {
+                char c = buf[offset + i];
+                if ( c == '\n') {
+                    flushBuilder();
+                }
+                else {
+                    mBuilder.append(c);
+                }
+            }
+        }
+
+        private void flushBuilder() {
+            if (mBuilder.length() > 0) {
+                Log.v("GLTextureView", mBuilder.toString());
+                mBuilder.delete(0, mBuilder.length());
+            }
+        }
+
+        private StringBuilder mBuilder = new StringBuilder();
+    }
+
+
+    private void checkRenderThreadState() {
+        if (mGLThread != null) {
+            throw new IllegalStateException(
+                    "setRenderer has already been called for this instance.");
+        }
+    }
+
+    private static class GLThreadManager {
+        private static String TAG = "GLThreadManager";
+
+        public synchronized void threadExiting(GLThread thread) {
+            if (LOG_THREADS) {
+                Log.i("GLThread", "exiting tid=" +  thread.getId());
+            }
+            thread.mExited = true;
+            if (mEglOwner == thread) {
+                mEglOwner = null;
+            }
+            notifyAll();
+        }
+
+        /*
+         * Tries once to acquire the right to use an EGL
+         * context. Does not block. Requires that we are already
+         * in the sGLThreadManager monitor when this is called.
+         *
+         * @return true if the right to use an EGL context was acquired.
+         */
+        public boolean tryAcquireEglContextLocked(GLThread thread) {
+            if (mEglOwner == thread || mEglOwner == null) {
+                mEglOwner = thread;
+                notifyAll();
+                return true;
+            }
+            checkGLESVersion();
+            if (mMultipleGLESContextsAllowed) {
+                return true;
+            }
+            // Notify the owning thread that it should release the context.
+            // TODO: implement a fairness policy. Currently
+            // if the owning thread is drawing continuously it will just
+            // reacquire the EGL context.
+            if (mEglOwner != null) {
+                mEglOwner.requestReleaseEglContextLocked();
+            }
+            return false;
+        }
+
+        /*
+         * Releases the EGL context. Requires that we are already in the
+         * sGLThreadManager monitor when this is called.
+         */
+        public void releaseEglContextLocked(GLThread thread) {
+            if (mEglOwner == thread) {
+                mEglOwner = null;
+            }
+            notifyAll();
+        }
+
+        public synchronized boolean shouldReleaseEGLContextWhenPausing() {
+            // Release the EGL context when pausing even if
+            // the hardware supports multiple EGL contexts.
+            // Otherwise the device could run out of EGL contexts.
+            return mLimitedGLESContexts;
+        }
+
+        public synchronized boolean shouldTerminateEGLWhenPausing() {
+            checkGLESVersion();
+            return !mMultipleGLESContextsAllowed;
+        }
+
+        public synchronized void checkGLDriver(GL10 gl) {
+            if (! mGLESDriverCheckComplete) {
+                checkGLESVersion();
+                String renderer = gl.glGetString(GL10.GL_RENDERER);
+                if (mGLESVersion < kGLES_20) {
+                    mMultipleGLESContextsAllowed =
+                            ! renderer.startsWith(kMSM7K_RENDERER_PREFIX);
+                    notifyAll();
+                }
+                mLimitedGLESContexts = !mMultipleGLESContextsAllowed;
+                if (LOG_SURFACE) {
+                    Log.w(TAG, "checkGLDriver renderer = \"" + renderer + "\" multipleContextsAllowed = "
+                            + mMultipleGLESContextsAllowed
+                            + " mLimitedGLESContexts = " + mLimitedGLESContexts);
+                }
+                mGLESDriverCheckComplete = true;
+            }
+        }
+
+        private void checkGLESVersion() {
+            if (! mGLESVersionCheckComplete) {
+//                mGLESVersion = minus.android.support.opengl.SystemProperties.getInt(
+//                        "ro.opengles.version",
+//                        ConfigurationInfo.GL_ES_VERSION_UNDEFINED);
+//                if (mGLESVersion >= kGLES_20) {
+                    mMultipleGLESContextsAllowed = true;
+//                }
+                if (LOG_SURFACE) {
+                    Log.w(TAG, "checkGLESVersion mGLESVersion =" +
+                            " " + mGLESVersion + " mMultipleGLESContextsAllowed = " + mMultipleGLESContextsAllowed);
+                }
+                mGLESVersionCheckComplete = true;
+            }
+        }
+
+        /**
+         * This check was required for some pre-Android-3.0 hardware. Android 3.0 provides
+         * support for hardware-accelerated views, therefore multiple EGL contexts are
+         * supported on all Android 3.0+ EGL drivers.
+         */
+        private boolean mGLESVersionCheckComplete;
+        private int mGLESVersion;
+        private boolean mGLESDriverCheckComplete;
+        private boolean mMultipleGLESContextsAllowed;
+        private boolean mLimitedGLESContexts;
+        private static final int kGLES_20 = 0x20000;
+        private static final String kMSM7K_RENDERER_PREFIX =
+                "Q3Dimension MSM7500 ";
+        private GLThread mEglOwner;
+    }
+
+    private static final GLThreadManager sGLThreadManager = new GLThreadManager();
+
+    private final WeakReference<GLTextureView> mThisWeakRef =
+            new WeakReference<GLTextureView>(this);
+    private GLThread mGLThread;
+    private Renderer mRenderer;
+    private boolean mDetached;
+    private EGLConfigChooser mEGLConfigChooser;
+    private EGLContextFactory mEGLContextFactory;
+    private EGLWindowSurfaceFactory mEGLWindowSurfaceFactory;
+    private GLWrapper mGLWrapper;
+    private int mDebugFlags;
+    private int mEGLContextClientVersion;
+    private boolean mPreserveEGLContextOnPause;
+}
+```
\ No newline at end of file
diff --git "a/VideoDevelopment/OpenGL/4.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md" "b/VideoDevelopment/OpenGL/4.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"
new file mode 100644
index 00000000..5532ef7d
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/4.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
@@ -0,0 +1,863 @@
+## OpenGL Es绘制三角形
+
+OpenGL ES的绘制需要有一下步骤:   
+
+- 顶点输入
+
+  开始绘制图形之前，我们必须先给OpenGL输入一些顶点数据。OpenGL是一个3D图形库，所以我们在OpenGL中所指定的所有坐标都是3D坐标(xyz)。OpenGL并不是简单地把所有的3D坐标变换成屏幕上的2D像素。OpenGL仅当3D坐标在3个轴(xyz)上都为-1.0到1.0的范围内采取处理它。所有在所谓的标准化设备坐标范围内的坐标才会最终呈现到屏幕上(在这个范围以外的坐标都不会显示)。
+
+- 顶点着色器
+
+  ```glsl
+  #version 330 core
+  layout (location = 0) in vec3 position;
+  
+  void main()
+  {
+      gl_Position = vec4(position.x, position.y, position.z, 1.0);
+  }
+  ```
+
+  每个着色器都起始于一个版本声明。OpenGL 3.3以及和更高版本中，GLSL版本号和OpenGL的版本是匹配的（比如说GLSL 420版本对应于OpenGL 4.2）。我们同样明确表示我们会使用核心模式。
+
+  下一步，使用`in`关键字，在顶点着色器中声明所有的输入顶点属性(Input Vertex Attribute)。现在我们只关心位置(Position)数据，所以我们只需要一个顶点属性。GLSL有一个向量数据类型，它包含1到4个`float`分量，包含的数量可以从它的后缀数字看出来。由于每个顶点都有一个3D坐标，我们就创建一个`vec3`输入变量position。我们同样也通过`layout (location = 0)`设定了输入变量的位置值(Location)你后面会看到为什么我们会需要这个位置值。
+
+  为了设置顶点着色器的输出，我们必须把位置数据赋值给预定义的gl_Position变量，它在幕后是`vec4`类型的。在main函数的最后，我们将gl_Position设置的值会成为该顶点着色器的输出。由于我们的输入是一个3分量的向量，我们必须把它转换为4分量的。我们可以把`vec3`的数据作为`vec4`构造器的参数，同时把`w`分量设置为`1.0f`（我们会在后面解释为什么）来完成这一任务。
+
+- 编译着色器
+
+  写完顶点着色器后，为了能让OpenGL使用它，我们必须在运行时动态编译它。
+
+- 片段着色器
+
+  片断着色器全是关于计算你的像素最后的颜色输出。颜色使用RGBA。
+
+  ```glsl
+  #version 330 core
+  
+  out vec4 color;
+  
+  void main()
+  {
+      color = vec4(1.0f, 0.5f, 0.2f, 1.0f);
+  }
+  ```
+
+  片段着色器只需要一个输出变量，这个变量是一个4分量向量，它表示的是最终的输出颜色，我们应该自己将其计算出来。我们可以用`out`关键字声明输出变量，这里我们命名为color。下面，我们将一个alpha值为1.0(1.0代表完全不透明)的橘黄色的`vec4`赋值给颜色输出。之后也是需要编译着色器。
+
+- 着色器程序(Shader Program Object)
+
+  着色器程序对象(Shader Program Object)是多个着色器合并之后并最终链接完成的版本。如果要使用刚才编译的着色器我们必须把它们链接为一个着色器程序对象，然后在渲染对象的时候激活这个着色器程序。已激活着色器程序的着色器将在我们发送渲染调用的时候被使用。
+
+  当链接着色器至一个程序的时候，它会把每个着色器的输出链接到下个着色器的输入。当输出和输入不匹配的时候，你会得到一个连接错误。我们需要把之前编译的着色器附加到程序队形上，然后使用glLinkProgram链接他们:
+
+  ```java
+  glAttachShader(shaderProgram, vertexShader);
+  glAttachShader(shaderProgram, fragmentShader);
+  glLinkProgram(shaderProgram);
+  ```
+
+  链接完后需要使用glUseProgram方法，用刚创建的程序对象作为参数，以激活这个程序对象。
+
+- 链接顶点属性
+
+  顶点着色器允许我们指定任何以顶点属性为形式的输入。这使其具有很强的灵活性的同时，它还的确意味着我们必须手动指定输入数据的哪一个部分对应顶点着色器的哪一个顶点属性。所以，我们必须在渲染前指定OpenGL该如何解释顶点数据。
+
+  我们的顶点缓冲数据会被解析成下面的样子:  
+
+  ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/vertex_attribute_pointer.png)
+
+  有了这些信息我们就可以使用glVertexAttribPointer函数告诉OpenGL该如何解析顶点数据（应用到逐个顶点属性上）了：
+
+  ```
+  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (GLvoid*)0);
+  glEnableVertexAttribArray(0);
+  ```
+
+  glVertexAttribPointer函数的参数非常多，所以我会逐一介绍它们：
+
+  - 第一个参数指定我们要配置的顶点属性。还记得我们在顶点着色器中使用`layout(location = 0)`定义了position顶点属性的位置值(Location)吗？它可以把顶点属性的位置值设置为`0`。因为我们希望把数据传递到这一个顶点属性中，所以这里我们传入`0`。
+  - 第二个参数指定顶点属性的大小。顶点属性是一个`vec3`，它由3个值组成，所以大小是3。
+  - 第三个参数指定数据的类型，这里是GL_FLOAT(GLSL中`vec*`都是由浮点数值组成的)。
+  - 下个参数定义我们是否希望数据被标准化(Normalize)。如果我们设置为GL_TRUE，所有数据都会被映射到0（对于有符号型signed数据是-1）到1之间。我们把它设置为GL_FALSE。
+  - 第五个参数叫做步长(Stride)，它告诉我们在连续的顶点属性组之间的间隔。由于下个组位置数据在3个`GLfloat`之后，我们把步长设置为`3 * sizeof(GLfloat)`。要注意的是由于我们知道这个数组是紧密排列的（在两个顶点属性之间没有空隙）我们也可以设置为0来让OpenGL决定具体步长是多少（只有当数值是紧密排列时才可用）。一旦我们有更多的顶点属性，我们就必须更小心地定义每个顶点属性之间的间隔，我们在后面会看到更多的例子(译注: 这个参数的意思简单说就是从这个属性第二次出现的地方到整个数组0位置之间有多少字节)。
+  - 最后一个参数的类型是`GLvoid*`，所以需要我们进行这个奇怪的强制类型转换。它表示位置数据在缓冲中起始位置的偏移量(Offset)。由于位置数据在数组的开头，所以这里是0。我们会在后面详细解释这个参数。
+
+
+
+下面需要实现GLSurfaceView.Render接口，实现要绘制的部分:   
+
+- 写顶点着色器和片段着色器文件。
+- 加载编译顶点着色器和片段着色器。
+- 确定需要绘制图形的坐标和颜色数据。
+- 创建program对象，连接顶点和片断着色器，将坐标数据、颜色数据传到OpenGL ES程序中。]
+- 设置视图窗口(viewport)。
+- 使颜色缓冲区的内容显示到屏幕上。
+
+
+
+### GLSL配置
+
+编写着色器需要用到GLSL，但是在Studio中默认是不支持关键字高亮和智能提示的，所以需要先安装插件。   
+
+Preferences -> Plugins -> 搜GLSL Support安装就可以了。
+
+
+
+### 编写着色器
+
+安装完GLSL插件后，就可以开始了。一般将GLSL文件放到raw或assets目录，我们这里在raw目录上右键New，然后选择GLSL Shader创建就可以了，创建后默认会生成一个main()函数。
+
+- 顶点着色器(vertex_simple_shade.glsl)
+
+  ```glsl
+  // 声明着色器的版本
+  #version 300 es
+  // 顶点着色器的顶点位置，输入一个名为vPosition的4分量向量，layout (location = 0)表示这个变量的位置是顶点属性0。
+  layout (location = 0) in vec4 vPosition;
+  // 顶点着色器的顶点颜色数据，输入一个名为aColor的4分量向量，layout (location = 1)表示这个变量的位置是顶点属性1。
+  layout (location = 1) in vec4 aColor;
+  // 输出一个名为vColor的4分量向量，后面输入到片段着色器中。
+  out vec4 vColor;
+  void main() {
+      // gl_Position为Shader内置变量，为顶点位置，将其赋值为vPosition
+      gl_Position  = vPosition;
+      // gl_PointSize为Shader内置变量，为点的直径
+      gl_PointSize = 10.0;
+      // 将输入数据aColor拷贝到vColor的变量中。
+      vColor = aColor;
+  }
+  ```
+
+- 片段着色器(fragment_simple_shade.glsl)
+
+  ```glsl
+  // 声明着色器的版本
+  #version 300 es
+  // 声明着色器中浮点变量的默认精度
+  precision mediump float;
+  // 声明一个输入名为vColor的4分向量，来自上面的顶点着色器
+  in vec4 vColor;
+  // 声明一个4分向量的输出变量fragColor
+  out vec4 fragColor;
+  void main() {
+      // 将输入的颜色值数据拷贝到fragColor变量中，输出到颜色缓冲区
+      fragColor = vColor;
+  }
+  ```
+
+
+
+### 编写GLSurfaceView.Render类
+
+主要有以下功能:  
+
+1. 声明绘制图形的坐标和颜色数据
+2. 为顶点位置及颜色申请本地内存
+3. 加载编译顶点着色器和片段着色器
+4. 创建program，连接顶点和片段着色器并链接program
+5. 设置窗口大小
+6. 完成绘制
+
+```java
+public class MainActivity extends AppCompatActivity {
+    private GLSurfaceView mGlSurfaceView;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        mGlSurfaceView = new MyGLSurfaceView(this);
+        setContentView(mGlSurfaceView);
+    }
+}
+
+class MyGLSurfaceView extends GLSurfaceView {
+    private final MyGLRenderer renderer;
+
+    public MyGLSurfaceView(Context context) {
+        super(context);
+        setEGLContextClientVersion(3);
+        renderer = new MyGLRenderer();
+        setRenderer(renderer);
+    }
+}
+
+class MyGLRenderer implements GLSurfaceView.Renderer {
+    //一个Float占用4Byte
+    private static final int BYTES_PER_FLOAT = 4;
+    //三个顶点
+    private static final int POSITION_COMPONENT_COUNT = 3;
+    //顶点位置缓存
+    private final FloatBuffer vertexBuffer;
+    //顶点颜色缓存
+    private final FloatBuffer colorBuffer;
+    //渲染程序
+    private int mProgram;
+
+    /*****************1.声明绘制图形的坐标和颜色数据 start**************/
+    //三个顶点的位置参数
+    private float triangleCoords[] = {
+            0.5f, 0.5f, 0.0f, // top
+            -0.5f, -0.5f, 0.0f, // bottom left
+            0.5f, -0.5f, 0.0f // bottom right
+    };
+
+    //三个顶点的颜色参数
+    private float color[] = {
+            1.0f, 0.0f, 0.0f, 1.0f,// top
+            0.0f, 1.0f, 0.0f, 1.0f,// bottom left
+            0.0f, 0.0f, 1.0f, 1.0f// bottom right
+    };
+    /*****************1.声明绘制图形的坐标和颜色数据 end**************/
+    public MyGLRenderer() {
+        /****************2.为顶点位置及颜色申请本地内存 start************/
+        //顶点位置相关
+        //分配本地内存空间,每个浮点型占4字节空间；将坐标数据转换为FloatBuffer，用以传入给OpenGL ES程序
+        vertexBuffer = ByteBuffer.allocateDirect(triangleCoords.length * BYTES_PER_FLOAT)
+                .order(ByteOrder.nativeOrder())
+                .asFloatBuffer();
+        vertexBuffer.put(triangleCoords);
+        // 将数组数据put进buffer之后，指针并不是在首位，所以一定要position到0，至关重要！否则会有很多奇妙的错误！将缓冲区的指针移动到头部，保证数据是从最开始处读取
+        vertexBuffer.position(0);
+
+        //顶点颜色相关
+        colorBuffer = ByteBuffer.allocateDirect(color.length * BYTES_PER_FLOAT)
+                .order(ByteOrder.nativeOrder())
+                .asFloatBuffer();
+        colorBuffer.put(color);
+        colorBuffer.position(0);
+        /****************2.为顶点位置及颜色申请本地内存 end************/
+    }
+
+
+    public void onSurfaceCreated(GL10 unused, EGLConfig config) {
+        //将背景设置为白色
+        GLES30.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
+
+        /******************3.加载编译顶点着色器和片段着色器 start**********/
+        //编译顶点着色程序
+        String vertexShaderStr = readResource(MyApplication.getInstance(), R.raw.vertex_simple_shade);
+        int vertexShaderId = compileVertexShader(vertexShaderStr);
+        //编译片段着色程序
+        String fragmentShaderStr = readResource(MyApplication.getInstance(), R.raw.fragment_simple_shade);
+        int fragmentShaderId = compileFragmentShader(fragmentShaderStr);
+        /******************3.加载编译顶点着色器和片段着色器 end**********/
+        /******************4.创建program，连接顶点和片段着色器并链接program start***********/
+        //连接程序
+        mProgram = linkProgram(vertexShaderId, fragmentShaderId);
+        /******************4.创建program，连接顶点和片段着色器并链接program end***********/
+        //在OpenGLES环境中使用程序
+        GLES30.glUseProgram(mProgram);
+    }
+    public void onSurfaceChanged(GL10 unused, int width, int height) {
+        /*********5.设置绘制窗口********/
+        GLES30.glViewport(0, 0, width, height);
+    }
+    public void onDrawFrame(GL10 unused) {
+        /**********6.绘制************/
+        //把颜色缓冲区设置为我们预设的颜色
+        GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT);
+
+        //绑定vertex坐标数据，告诉OpenGL可以在缓冲区vertextBuffer中获取数据
+        GLES30.glVertexAttribPointer(0, 3, GLES30.GL_FLOAT, false, 0, vertexBuffer);
+        //启用顶点位置句柄
+        GLES30.glEnableVertexAttribArray(0);
+
+        //准备颜色数据
+        /**
+         * glVertexAttribPointer()方法的参数分别为: 
+         * index：顶点属性的索引.（这里我们的顶点位置和颜色向量在着色器中分别为0和1）layout (location = 0) in vec4 vPosition; layout (location = 1) in vec4 aColor;
+         * size: 指定每个通用顶点属性的元素个数。必须是1、2、3、4。此外，glvertexattribpointer接受符号常量gl_bgra。初始值为4（也就是涉及颜色的时候必为4）。
+         * type：属性的元素类型。（上面都是Float所以使用GLES30.GL_FLOAT）；
+         * normalized：转换的时候是否要经过规范化，true：是；false：直接转化；
+         * stride：跨距，默认是0。（由于我们将顶点位置和颜色数据分别存放没写在一个数组中，所以使用默认值0）
+         * ptr： 本地数据缓存（这里我们的是顶点的位置和颜色数据）。
+         */
+        GLES30.glVertexAttribPointer(1, 4, GLES30.GL_FLOAT, false, 0, colorBuffer);
+        //启用顶点颜色句柄
+        GLES30.glEnableVertexAttribArray(1);
+
+        //绘制三个点
+//        GLES30.glDrawArrays(GLES30.GL_POINTS, 0, POSITION_COMPONENT_COUNT);
+
+        //绘制三条线
+//        GLES30.glLineWidth(3);//设置线宽
+//        GLES30.glDrawArrays(GLES30.GL_LINE_LOOP, 0, POSITION_COMPONENT_COUNT);
+
+        //绘制三角形
+        GLES30.glDrawArrays(GLES30.GL_TRIANGLES, 0, POSITION_COMPONENT_COUNT);
+
+        //禁止顶点数组的句柄
+        GLES30.glDisableVertexAttribArray(0);
+        GLES30.glDisableVertexAttribArray(1);
+    }
+    /**
+     * 编译顶点着色器
+     *
+     * @param shaderCode
+     */
+    public static int compileVertexShader(String shaderCode) {
+        return compileShader(GLES30.GL_VERTEX_SHADER, shaderCode);
+    }
+
+    /**
+     * 编译片段着色器
+     *
+     * @param shaderCode
+     */
+    public static int compileFragmentShader(String shaderCode) {
+        return compileShader(GLES30.GL_FRAGMENT_SHADER, shaderCode);
+    }
+
+    /**
+     * 加载并编译着色器代码
+     *
+     * @param type       顶点着色器:GLES30.GL_VERTEX_SHADER
+     *                   片段着色器:GLES30.GL_FRAGMENT_SHADER
+     * @param shaderCode
+     */
+    private static int compileShader(int type, String shaderCode) {
+        //传入渲染器类型参数的type，创建一个对应的着色器对象
+        final int shaderId = GLES30.glCreateShader(type);
+        if (shaderId != 0) {
+            // 传入着色器对象和字符串shaderCode定义的源代码，将二者关联起来
+            GLES30.glShaderSource(shaderId, shaderCode);
+            // 传入着色器对象，并对其进行编译
+            GLES30.glCompileShader(shaderId);
+            //检测状态
+            final int[] compileStatus = new int[1];
+            GLES30.glGetShaderiv(shaderId, GLES30.GL_COMPILE_STATUS, compileStatus, 0);
+            if (compileStatus[0] == 0) {
+                String logInfo = GLES30.glGetShaderInfoLog(shaderId);
+                System.err.println(logInfo);
+                //创建失败
+                GLES30.glDeleteShader(shaderId);
+                return 0;
+            }
+            return shaderId;
+        } else {
+            //创建失败
+            return 0;
+        }
+    }
+
+    /**
+     * 链接小程序
+     *
+     * @param vertexShaderId   顶点着色器
+     * @param fragmentShaderId 片段着色器
+     */
+    public static int linkProgram(int vertexShaderId, int fragmentShaderId) {
+        //创建一个空的OpenGLES程序
+        final int programId = GLES30.glCreateProgram();
+        if (programId != 0) {
+            //将顶点着色器加入到程序
+            GLES30.glAttachShader(programId, vertexShaderId);
+            //将片元着色器加入到程序中
+            GLES30.glAttachShader(programId, fragmentShaderId);
+            //链接着色器程序
+            GLES30.glLinkProgram(programId);
+            final int[] linkStatus = new int[1];
+
+            GLES30.glGetProgramiv(programId, GLES30.GL_LINK_STATUS, linkStatus, 0);
+            if (linkStatus[0] == 0) {
+                String logInfo = GLES30.glGetProgramInfoLog(programId);
+                System.err.println(logInfo);
+                GLES30.glDeleteProgram(programId);
+                return 0;
+            }
+            return programId;
+        } else {
+            //创建失败
+            return 0;
+        }
+    }
+
+    /**
+     * 验证程序片段是否有效
+     *
+     * @param programObjectId
+     */
+    public static boolean validProgram(int programObjectId) {
+        GLES30.glValidateProgram(programObjectId);
+        final int[] programStatus = new int[1];
+        GLES30.glGetProgramiv(programObjectId, GLES30.GL_VALIDATE_STATUS, programStatus, 0);
+        return programStatus[0] != 0;
+    }
+
+    /**
+     * 读取资源
+     *
+     * @param resourceId
+     */
+    public static String readResource(Context context, int resourceId) {
+        StringBuilder builder = new StringBuilder();
+        try {
+            InputStream inputStream = context.getApplicationContext().getResources().openRawResource(resourceId);
+            InputStreamReader streamReader = new InputStreamReader(inputStream);
+
+            BufferedReader bufferedReader = new BufferedReader(streamReader);
+            String textLine;
+            while ((textLine = bufferedReader.readLine()) != null) {
+                builder.append(textLine);
+                builder.append("\n");
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        } catch (Resources.NotFoundException e) {
+            e.printStackTrace();
+        }
+        return builder.toString();
+    }
+}
+```
+
+效果如下:   
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_tri.jpg)
+
+我们设置的是数据来看，应该是等腰三角形，但是实际效果并不是，这是因为前面说到的OpenGL ES使用的是虚拟坐标导致的。如果想让绘制一个等腰三角形该怎么做呢？ 
+
+### 变成等腰三角形的原理
+
+打个比方现在屏幕的宽高比是1：2，那上面的话的三角形的高度就是宽度的2，我们只需要通过换算把高度变成现在的高度 * 1/2 就可以得到等腰三角形了。
+
+这里就牵扯到了要对坐标向量进行换算，这里的换算需要使用矩阵来进行。总体分为两部分:   
+
+- 或者获得一个矩阵，可以把坐标范围从【-2，2】换算成【-1，1】的范围内。(提供了Matrix.orthoM来处理矩阵)
+- 如何将这个矩阵传递给GLSL中。(与获取顶点索引类似，可以在GLSL中声明一个mat4类型的矩阵变量，获取其索引，再传递值给它)
+
+
+
+### 向量（Vector)
+
+具有大小和方向的量。它可以形象化的表示为带箭头的线段。箭头代表方向、长度代表大小。在GLSL中一个向量有最多4个分量，每个分量值都代表空间中的一个坐标，它们可以通过vec.x、vec.y、vec.z和vec.w来获取。vec.w分量不是用作表达空间中的位置(因为我们处理的是3D不是4D)，而是用在所谓透视划分上。
+
+### 矩阵
+
+由m*n个数按照一定顺序排列成m行n列的矩形数表称为矩阵，而向量则是由n个有序数组成的数组。
+
+所以矩阵中的每一个行可以看做一个行向量，每一列也可以看成一个列向量，所以说向量是矩阵的一部分。
+
+在三维图形学中，一般使用的是4阶矩阵。在DirectX中使用的是行向量，如[xyzw]，所以与矩阵相乘时，向量在前矩阵在后。OpenGL中使用的是列向量，如[xyzx]T，所以与矩阵相乘时，矩阵在前，向量在后，最终通过变换矩阵得到想要的向量。
+
+
+
+### 相机
+
+这里的相机指的是观察外界的视角并不是我们生活中的相机。这里的相机是指我们从照相机或者摄像机的角度来观察这个世界。 相机对应于OpenGL的世界，决定相机拍摄的结果(最终屏幕上展示的结果)，包括相机位置、相机观察方向以及相机的UP方向。
+
+1. 相机位置:相机在3D空间里面的坐标点。
+2. 相机观察方向:相机镜头的朝向，朝前拍、朝后拍、朝左拍、朝右拍。
+3. 相机UP方向:相机顶端志祥的方向，例如斜着拿、反着拿。
+
+Android OpenGL ES程序中，我们可以通过Matrix.setLookAtm来对相机进行设置:   
+
+```java
+/**
+* Defines a viewing transformation in terms of an eye point, a center of
+* view, and an up vector.
+*
+* @param rm returns the result
+* @param rmOffset index into rm where the result matrix starts
+* @param eyeX eye point X
+* @param eyeY eye point Y
+* @param eyeZ eye point Z
+* @param centerX center of view X
+* @param centerY center of view Y
+* @param centerZ center of view Z
+* @param upX up vector X
+* @param upY up vector Y
+* @param upZ up vector Z
+*/
+public static void setLookAtM(float[] rm, //接收相机变换矩阵
+int rmOffset, //变换矩阵的起始位置（偏移量）
+float eyeX,float eyeY, float eyeZ, //相机位置
+float centerX,float centerY,float centerZ,  //观测点位置
+float upX,float upY,float upZ)  //up向量在xyz上的分量) {
+
+------------省略代码-------------
+}
+```
+
+
+
+### 投影 
+
+相机视角观察到的世界最终要变成平面2D图像展示到屏幕上，这个过程就是投影，从3D到2D的转换。
+
+Android OpenGL ES的投影分为两种:   
+
+- 正交投影
+
+  物体呈现出来的大小不会随着其距离视点的远近而发生变化。通过Matrix.orthoM()来设置正交投影。 
+
+  ```java
+  	/**
+       * Computes an orthographic projection matrix.
+       *
+       * @param m returns the result
+       * @param mOffset
+       * @param left
+       * @param right
+       * @param bottom
+       * @param top
+       * @param near
+       * @param far
+       */
+      public static void orthoM(float[] m, //接收正交投影的变换矩阵
+                  int mOffset, //变换矩阵的起始位置（偏移量）
+                  float left, //相对观察点近面的左边距
+                  float right,//相对观察点近面的右边距
+                  float bottom, //相对观察点近面的下边距
+                  float top,//相对观察点近面的上边距
+                  float near,//相对观察点近面距离
+                  float far) //相对观察点远面距离{
+  		---------------省略代码--------------
+  	}
+  ```
+
+  
+
+- 透视投影
+
+  物体离视点越远，呈现出来的越小。离视点越近，呈现出来的越大。通过Matrix.frustumM()来设置透明投影:     
+
+  ```java
+     /**
+       * Defines a projection matrix in terms of six clip planes.
+       *
+       * @param m the float array that holds the output perspective matrix
+       * @param offset the offset into float array m where the perspective
+       *        matrix data is written
+       * @param left
+       * @param right
+       * @param bottom
+       * @param top
+       * @param near
+       * @param far
+       */
+      public static void frustumM(float[] m, //接收透视投影的变换矩阵
+  				                int mOffset, //变换矩阵的起始位置（偏移量）
+  				                float left,//相对观察点近面的左边距
+  				                float right,//相对观察点近面的右边距
+  				                float bottom, //相对观察点近面的下边距
+  				                float top, //相对观察点近面的上边距
+  				                float near, //相对观察点近面距离
+  				                float far) //相对观察点远面距离 {
+  			---------------省略代码--------------
+  	}
+  ```
+
+
+
+### 变换矩阵
+
+在OpenGL ES中顶点位置信息的表示都是使用的向量，如下每一行是一个顶点的位置向量(x,y,z)。想要使三角形显示为等腰三角形，就需要在虚拟坐标系中完成对各个顶点位置的变换，也就是对三个向量的变换。而想要实现对向量的变换就要用到变换矩阵。
+
+```java
+//三个顶点的位置参数
+private float triangleCoords[] = {
+  0.5f, 0.5f, 0.0f, // top
+  -0.5f, -0.5f, 0.0f, // bottom left
+  0.5f, -0.5f, 0.0f // bottom right
+};
+```
+
+变换矩阵需要透过相应的相机和投影的操作才能得到，具体方法如下:   
+
+```java
+Matrix.multiplyMM (float[] result, //接收相乘结果
+                int resultOffset,  //接收矩阵的起始位置（偏移量）
+                float[] lhs,       //左矩阵
+                int lhsOffset,     //左矩阵的起始位置（偏移量）
+                float[] rhs,       //右矩阵
+                int rhsOffset)     //右矩阵的起始位置（偏移量）
+```
+
+
+
+也就是说为了解决坐标中宽高不一样的问题，我们可以应用OpenGL正确的比例下通过投影模式和相机视图坐标转换图形对象来完成。为了应用投影和相机视图，我们创建一个投影矩阵和一个相机视图矩阵，并把他们应用于OpenGL渲染管道中，投影矩阵重新计算你的图形的坐标，使他们正确的映射到Android设备的屏幕，相机视图矩阵创建一个转换，它将从一个特定的位置显示对象。
+
+### 绘制等腰三角形
+
+​	在上面绘制三角形的基础上进行修改。
+
+### 工具类
+
+将用到的着色器功能以及资源读取glsl的功能封装成工具类:   
+
+```java
+public class ShaderUtils {
+    private static final String TAG = "ShaderUtils";
+    /**
+     * 编译顶点着色器
+     * @param shaderCode
+     */
+    public static int compileVertexShader(String shaderCode) {
+        return compileShader(GLES30.GL_VERTEX_SHADER, shaderCode);
+    }
+
+    /**
+     * 编译片段着色器
+     * @param shaderCode
+     */
+    public static int compileFragmentShader(String shaderCode) {
+        return compileShader(GLES30.GL_FRAGMENT_SHADER, shaderCode);
+    }
+
+    /**
+     * 编译
+     * @param type       顶点着色器:GLES30.GL_VERTEX_SHADER
+     *                   片段着色器:GLES30.GL_FRAGMENT_SHADER
+     * @param shaderCode
+     */
+    private static int compileShader(int type, String shaderCode) {
+        //创建一个着色器
+        final int shaderId = GLES30.glCreateShader(type);
+        if (shaderId != 0) {
+            GLES30.glShaderSource(shaderId, shaderCode);
+            GLES30.glCompileShader(shaderId);
+            //检测状态
+            final int[] compileStatus = new int[1];
+            GLES30.glGetShaderiv(shaderId, GLES30.GL_COMPILE_STATUS, compileStatus, 0);
+            if (compileStatus[0] == 0) {
+                String logInfo = GLES30.glGetShaderInfoLog(shaderId);
+                System.err.println(logInfo);
+                //创建失败
+                GLES30.glDeleteShader(shaderId);
+                return 0;
+            }
+            return shaderId;
+        } else {
+            //创建失败
+            return 0;
+        }
+    }
+
+    /**
+     * 链接小程序
+     * @param vertexShaderId   顶点着色器
+     * @param fragmentShaderId 片段着色器
+     */
+    public static int linkProgram(int vertexShaderId, int fragmentShaderId) {
+        //创建一个空的OpenGLES程序
+        final int programId = GLES30.glCreateProgram();
+        if (programId != 0) {
+            //将顶点着色器加入到程序
+            GLES30.glAttachShader(programId, vertexShaderId);
+            //将片元着色器加入到程序中
+            GLES30.glAttachShader(programId, fragmentShaderId);
+            //链接着色器程序
+            GLES30.glLinkProgram(programId);
+            final int[] linkStatus = new int[1];
+
+            GLES30.glGetProgramiv(programId, GLES30.GL_LINK_STATUS, linkStatus, 0);
+            if (linkStatus[0] == 0) {
+                String logInfo = GLES30.glGetProgramInfoLog(programId);
+                System.err.println(logInfo);
+                GLES30.glDeleteProgram(programId);
+                return 0;
+            }
+            return programId;
+        } else {
+            //创建失败
+            return 0;
+        }
+    }
+
+    /**
+     * 验证程序片段是否有效
+     * @param programObjectId
+     */
+    public static boolean validProgram(int programObjectId) {
+        GLES30.glValidateProgram(programObjectId);
+        final int[] programStatus = new int[1];
+        GLES30.glGetProgramiv(programObjectId, GLES30.GL_VALIDATE_STATUS, programStatus, 0);
+        return programStatus[0] != 0;
+    }
+}
+```
+
+
+
+```java
+public class ResReadUtils {
+
+    /**
+     * 读取资源
+     * @param resourceId
+     */
+    public static String readResource(int resourceId) {
+        StringBuilder builder = new StringBuilder();
+        try {
+            InputStream inputStream = MyApplication.getInstance().getResources().openRawResource(resourceId);
+            InputStreamReader streamReader = new InputStreamReader(inputStream);
+
+            BufferedReader bufferedReader = new BufferedReader(streamReader);
+            String textLine;
+            while ((textLine = bufferedReader.readLine()) != null) {
+                builder.append(textLine);
+                builder.append("\n");
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        } catch (Resources.NotFoundException e) {
+            e.printStackTrace();
+        }
+        return builder.toString();
+    }
+}
+```
+
+
+
+- 修改顶点着色器，增加矩阵变换(修改vertex_simple_shade.glsl)
+
+  ```glsl
+  #version 300 es
+  // 输入一个名为vPosition的4分量向量，layout (location = 0)表示这个变量的位置是顶点属性0。
+  layout (location = 0) in vec4 vPosition;
+  // 输入一个名为aColor的4分量向量，layout (location = 1)表示这个变量的位置是顶点属性1。
+  layout (location = 1) in vec4 aColor;
+  // 输出一个名为vColor的4分量向量，后面输入到片段着色器中。
+  out vec4 vColor;
+  // 变换矩阵4*4
+  uniform mat4 u_Matrix;
+  
+  void main() {
+      // gl_Position为Shader内置变量，为顶点位置，将其赋值为vPosition
+      gl_Position  = u_Matrix * vPosition;
+      // gl_PointSize为Shader内置变量，为点的直径
+      gl_PointSize = 10.0;
+      // 将输入数据aColor拷贝到vColor的变量中。
+      vColor = aColor;
+  }
+  ```
+
+- 在GLSurfaceView.Render实现类中定义矩阵变量
+
+- 把变换矩阵设置给顶点渲染器
+
+其他所有代码都和上面的一样，只是在Renderer的实现类中增加对转换矩阵的部分
+
+```java
+class TriangleRender implements GLSurfaceView.Renderer {
+    //一个Float占用4Byte
+    private static final int BYTES_PER_FLOAT = 4;
+    //三个顶点
+    private static final int POSITION_COMPONENT_COUNT = 3;
+    //顶点位置缓存
+    private final FloatBuffer vertexBuffer;
+    //顶点颜色缓存
+    private final FloatBuffer colorBuffer;
+    //渲染程序
+    private int mProgram;
+    private int uMatrixLocation;
+    // 矩阵数组
+    private final float[] mProjectionMatrix = new float[]{
+            1, 0, 0, 0,
+            0, 1, 0, 0,
+            0, 0, 1, 0,
+            0, 0, 0, 1,
+    };
+    //三个顶点的位置参数
+    private float triangleCoords[] = {
+            0.5f, 0.5f, 0.0f, // top
+            -0.5f, -0.5f, 0.0f, // bottom left
+            0.5f, -0.5f, 0.0f // bottom right
+    };
+
+    //三个顶点的颜色参数
+    private float color[] = {
+            1.0f, 0.0f, 0.0f, 1.0f,// top
+            0.0f, 1.0f, 0.0f, 1.0f,// bottom left
+            0.0f, 0.0f, 1.0f, 1.0f// bottom right
+    };
+
+    public TriangleRender() {
+        //顶点位置相关
+        //分配本地内存空间,每个浮点型占4字节空间；将坐标数据转换为FloatBuffer，用以传入给OpenGL ES程序
+        vertexBuffer = ByteBuffer.allocateDirect(triangleCoords.length * BYTES_PER_FLOAT)
+                .order(ByteOrder.nativeOrder())
+                .asFloatBuffer();
+        vertexBuffer.put(triangleCoords);
+        vertexBuffer.position(0);
+
+        //顶点颜色相关
+        colorBuffer = ByteBuffer.allocateDirect(color.length * BYTES_PER_FLOAT)
+                .order(ByteOrder.nativeOrder())
+                .asFloatBuffer();
+        colorBuffer.put(color);
+        colorBuffer.position(0);
+    }
+
+    @Override
+    public void onSurfaceCreated(GL10 gl, EGLConfig config) {
+        //将背景设置为白色
+        GLES30.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
+        //编译顶点着色程序
+        String vertexShaderStr = readResource(R.raw.vertex_simple_shade);
+        int vertexShaderId = compileVertexShader(vertexShaderStr);
+        //编译片段着色程序
+        String fragmentShaderStr = readResource(R.raw.fragment_simple_shade);
+        int fragmentShaderId = compileFragmentShader(fragmentShaderStr);
+        //连接程序
+        mProgram = linkProgram(vertexShaderId, fragmentShaderId);
+        //在OpenGLES环境中使用程序
+        GLES30.glUseProgram(mProgram);
+
+        /**********新加的部分，获取变换矩阵以及其的位置、颜色等************/
+        uMatrixLocation = GLES30.glGetUniformLocation(mProgram, "u_Matrix");
+    }
+
+    @Override
+    public void onSurfaceChanged(GL10 gl, int width, int height) {
+        GLES30.glViewport(0, 0, width, height);
+        /**********新加的部分，将变换矩阵传入顶点渲染器************/
+        //计算宽高比
+        // 边长比(>=1)，非宽高比
+        float aspectRatio = width > height ?
+                (float) width / (float) height :
+                (float) height / (float) width;
+
+        // 1. 矩阵数组
+        // 2. 结果矩阵起始的偏移量
+        // 3. left：x的最小值
+        // 4. right：x的最大值
+        // 5. bottom：y的最小值
+        // 6. top：y的最大值
+        // 7. near：z的最小值
+        // 8. far：z的最大值
+        if (width > height) {
+            // 横屏
+            Matrix.orthoM(mProjectionMatrix, 0, -aspectRatio, aspectRatio, -1f, 1f, -1f, 1f);
+        } else {
+            // 竖屏or正方形
+            Matrix.orthoM(mProjectionMatrix, 0, -1f, 1f, -aspectRatio, aspectRatio, -1f, 1f);
+        }
+        // 更新u_Matrix的值，即更新矩阵数组
+        GLES30.glUniformMatrix4fv(uMatrixLocation, 1, false, mProjectionMatrix, 0);
+    }
+
+    @Override
+    public void onDrawFrame(GL10 gl) {
+        //把颜色缓冲区设置为我们预设的颜色
+        GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT);
+        //绑定vertex坐标数据，告诉OpenGL可以在缓冲区vertexBuffer中获取vPosition的护具
+        GLES30.glVertexAttribPointer(0, 3, GLES30.GL_FLOAT, false, 0, vertexBuffer);
+        //启用顶点位置句柄
+        GLES30.glEnableVertexAttribArray(0);
+        //准备颜色数据
+        GLES30.glVertexAttribPointer(1, 4, GLES30.GL_FLOAT, false, 0, colorBuffer);
+        //启用顶点颜色句柄
+        GLES30.glEnableVertexAttribArray(1);
+        //绘制三角形
+        GLES30.glDrawArrays(GLES30.GL_TRIANGLES, 0, POSITION_COMPONENT_COUNT);
+        //禁止顶点数组的句柄
+        GLES30.glDisableVertexAttribArray(0);
+        GLES30.glDisableVertexAttribArray(1);
+    }
+}
+```
+
diff --git "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md" "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"
new file mode 100644
index 00000000..581c449c
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"	
@@ -0,0 +1,511 @@
+## 5.OpenGL ES绘制矩形及圆形
+
+
+
+### 顶点法和索引法
+
+- 顶点法
+
+  上一篇文章中写的绘制点、线、三角形都是使用GLES30.glDrawArrays()来绘制，它是顶点法。根据传入的顶点顺序进行绘制。顶点复用情况少，可读性低。
+
+- 索引法
+
+  根据索引序列，在顶点序列中找到对应的顶点，并根据绘制的方式，组成相应的图元绘制，用的是GLES30.glDrawElements()，称为索引法。相对于顶点法在复杂图形的绘制中无法避免大量顶点重复的情况，索引法可以减少很多重复顶点占用的空间，所以复杂的图形下推荐使用索引法。顶点复用情况多，客读性高。
+
+之前说过OpenGL ES提供的的图元单位是三角形，想要绘制其他多边形，就要利用三角形来拼成。 矩形是两个三角形，而圆形则是由很多个三角形组成，个数越多，圆越圆。
+
+
+
+### 绘制矩形
+
+
+
+- 顶点着色器与上一个三角形的一样
+
+- 片段着色器与上一个三角形的一样
+
+- Render的实现如下
+
+  顶点法:   
+  
+  ```java
+  package com.charon.opengldemo.rectangle;
+  
+  import android.opengl.GLES20;
+  import android.opengl.GLES30;
+  import android.opengl.GLSurfaceView;
+  import android.opengl.Matrix;
+  
+  import com.charon.opengldemo.R;
+  import com.charon.opengldemo.util.ResReadUtils;
+  import com.charon.opengldemo.util.ShaderUtils;
+  
+  import java.nio.ByteBuffer;
+  import java.nio.ByteOrder;
+  import java.nio.FloatBuffer;
+  import java.nio.ShortBuffer;
+  
+  import javax.microedition.khronos.egl.EGLConfig;
+  import javax.microedition.khronos.opengles.GL10;
+  
+  public class RectangleRender implements GLSurfaceView.Renderer {
+      //一个Float占用4Byte
+      private static final int BYTES_PER_FLOAT = 4;
+      //顶点位置缓存
+      private final FloatBuffer vertexBuffer;
+      //顶点颜色缓存
+      private final FloatBuffer colorBuffer;
+      //渲染程序
+      private int mProgram;
+  
+      //返回属性变量的位置
+      //变换矩阵
+      private int uMatrixLocation;
+      //位置
+      private int aPositionLocation;
+      //颜色
+      private int aColorLocation;
+  
+      /**
+       * 坐标占用的向量个数
+       */
+      private static final int POSITION_COMPONENT_COUNT = 2;
+      private static final float[] POINT_DATA = {
+              -0.5f, -0.5f,
+              0.5f, -0.5f,
+              -0.5f, 0.5f,
+              0.5f, 0.5f,
+      };
+      /**
+       * 颜色占用的向量个数
+       */
+      private static final int COLOR_COMPONENT_COUNT = 4;
+      private static final float[] COLOR_DATA = {
+              // 一个顶点有3个向量数据：r、g、b、a
+              1f, 0.5f, 0.5f, 0f,
+              1f, 0f, 1f, 0f,
+              0f, 1f, 1f, 0f,
+              1f, 1f, 0f, 0f
+      };
+      private final float[] mProjectionMatrix = new float[16];
+  
+      public RectangleRender() {
+          //顶点位置相关
+          //分配本地内存空间,每个浮点型占4字节空间；将坐标数据转换为FloatBuffer，用以传入给OpenGL ES程序
+          vertexBuffer = ByteBuffer.allocateDirect(POINT_DATA.length * BYTES_PER_FLOAT)
+                  .order(ByteOrder.nativeOrder())
+                  .asFloatBuffer();
+          vertexBuffer.put(POINT_DATA);
+          vertexBuffer.position(0);
+  
+          //顶点颜色相关
+          colorBuffer = ByteBuffer.allocateDirect(COLOR_DATA.length * BYTES_PER_FLOAT)
+                  .order(ByteOrder.nativeOrder())
+                  .asFloatBuffer();
+          colorBuffer.put(COLOR_DATA);
+          colorBuffer.position(0);
+      }
+  
+      @Override
+      public void onSurfaceCreated(GL10 gl, EGLConfig config) {
+          //将背景设置为白色
+          GLES20.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
+  
+          //编译顶点着色程序
+          String vertexShaderStr = ResReadUtils.readResource(R.raw.vertex_simple_shade);
+          int vertexShaderId = ShaderUtils.compileVertexShader(vertexShaderStr);
+          //编译片段着色程序
+          String fragmentShaderStr = ResReadUtils.readResource(R.raw.fragment_simple_shade);
+          int fragmentShaderId = ShaderUtils.compileFragmentShader(fragmentShaderStr);
+          //连接程序
+          mProgram = ShaderUtils.linkProgram(vertexShaderId, fragmentShaderId);
+          //在OpenGLES环境中使用程序
+          GLES30.glUseProgram(mProgram);
+  
+  
+          uMatrixLocation = GLES30.glGetUniformLocation(mProgram, "u_Matrix");
+          aPositionLocation = GLES30.glGetAttribLocation(mProgram, "vPosition");
+          aColorLocation = GLES30.glGetAttribLocation(mProgram, "aColor");
+      }
+  
+      @Override
+      public void onSurfaceChanged(GL10 gl, int width, int height) {
+          //设置绘制窗口
+          GLES30.glViewport(0, 0, width, height);
+          //正交投影方式
+          final float aspectRatio = width > height ?
+                  (float) width / (float) height :
+                  (float) height / (float) width;
+          if (width > height) {
+              //横屏
+              Matrix.orthoM(mProjectionMatrix, 0, -aspectRatio, aspectRatio, -1f, 1f, -1f, 1f);
+          } else {
+              //竖屏
+              Matrix.orthoM(mProjectionMatrix, 0, -1f, 1f, -aspectRatio, aspectRatio, -1f, 1f);
+          }
+      }
+  
+      @Override
+      public void onDrawFrame(GL10 gl) {
+          //把颜色缓冲区设置为我们预设的颜色
+          GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT);
+  
+          //将变换矩阵传入顶点渲染器
+          GLES20.glUniformMatrix4fv(uMatrixLocation, 1, false, mProjectionMatrix, 0);
+          //准备坐标数据
+          GLES30.glVertexAttribPointer(aPositionLocation, POSITION_COMPONENT_COUNT, GLES30.GL_FLOAT, false, 0, vertexBuffer);
+          //启用顶点位置句柄
+          GLES30.glEnableVertexAttribArray(aPositionLocation);
+  
+          //准备颜色数据
+          GLES30.glVertexAttribPointer(aColorLocation, COLOR_COMPONENT_COUNT, GLES30.GL_FLOAT, false, 0, colorBuffer);
+          //启用顶点颜色句柄
+          GLES30.glEnableVertexAttribArray(aColorLocation);
+          // 开始绘制
+          GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, POINT_DATA.length / POSITION_COMPONENT_COUNT);
+          //禁止顶点数组的句柄
+          GLES30.glDisableVertexAttribArray(aPositionLocation);
+          GLES30.glDisableVertexAttribArray(aColorLocation);
+      }
+  }
+  ```
+  
+  索引法:
+  
+  ```java
+  public class RectangleRender implements GLSurfaceView.Renderer {
+      //一个Float占用4Byte
+      private static final int BYTES_PER_FLOAT = 4;
+      //顶点个数
+      private static final int POSITION_COMPONENT_COUNT = 4;
+      //顶点位置缓存
+      private final FloatBuffer vertexBuffer;
+      //顶点颜色缓存
+    private final FloatBuffer colorBuffer;
+      //顶点索引缓存
+      private final ShortBuffer indicesBuffer;
+      //渲染程序
+      private int mProgram;
+  
+      //相机矩阵
+      private final float[] mViewMatrix = new float[16];
+      //投影矩阵
+      private final float[] mProjectMatrix = new float[16];
+      //最终变换矩阵
+      private final float[] mMVPMatrix = new float[16];
+  
+      //返回属性变量的位置
+      //变换矩阵
+      private int uMatrixLocation;
+      //位置
+      private int aPositionLocation;
+      //颜色
+      private int aColorLocation;
+  
+      //四个顶点的位置参数
+      private float rectangleCoords[] = {
+              -0.5f, 0.5f, 0.0f,//top left
+              -0.5f, -0.5f, 0.0f, // bottom left
+              0.5f, -0.5f, 0.0f, // bottom right
+              0.5f, 0.5f, 0.0f // top right
+      };
+  
+      /**
+       * 顶点索引
+       */
+      private short[] indices = {
+              0, 1, 2, 0, 2, 3
+      };
+  
+      //四个顶点的颜色参数
+      private float color[] = {
+              0.0f, 0.0f, 1.0f, 1.0f,//top left
+              0.0f, 1.0f, 0.0f, 1.0f,// bottom left
+              0.0f, 0.0f, 1.0f, 1.0f,// bottom right
+              1.0f, 0.0f, 0.0f, 1.0f// top right
+      };
+  
+      public RectangleRender() {
+          //顶点位置相关
+          //分配本地内存空间,每个浮点型占4字节空间；将坐标数据转换为FloatBuffer，用以传入给OpenGL ES程序
+          vertexBuffer = ByteBuffer.allocateDirect(rectangleCoords.length * BYTES_PER_FLOAT)
+                  .order(ByteOrder.nativeOrder())
+                  .asFloatBuffer();
+          vertexBuffer.put(rectangleCoords);
+          vertexBuffer.position(0);
+  
+          //顶点颜色相关
+          colorBuffer = ByteBuffer.allocateDirect(color.length * BYTES_PER_FLOAT)
+                  .order(ByteOrder.nativeOrder())
+                  .asFloatBuffer();
+          colorBuffer.put(color);
+          colorBuffer.position(0);
+  
+          //顶点索引相关
+          indicesBuffer = ByteBuffer.allocateDirect(indices.length * 4)
+                  .order(ByteOrder.nativeOrder())
+                  .asShortBuffer();
+          indicesBuffer.put(indices);
+          indicesBuffer.position(0);
+      }
+  
+      @Override
+      public void onSurfaceCreated(GL10 gl, EGLConfig config) {
+          //将背景设置为白色
+          GLES20.glClearColor(1.0f,1.0f,1.0f,1.0f);
+  
+          //编译顶点着色程序
+          String vertexShaderStr = ResReadUtils.readResource(R.raw.vertex_simple_shade);
+          int vertexShaderId = ShaderUtils.compileVertexShader(vertexShaderStr);
+          //编译片段着色程序
+          String fragmentShaderStr = ResReadUtils.readResource(R.raw.fragment_simple_shade);
+          int fragmentShaderId = ShaderUtils.compileFragmentShader(fragmentShaderStr);
+          //连接程序
+          mProgram = ShaderUtils.linkProgram(vertexShaderId, fragmentShaderId);
+          //在OpenGLES环境中使用程序
+          GLES30.glUseProgram(mProgram);
+  
+  
+          uMatrixLocation = GLES30.glGetUniformLocation(mProgram, "u_Matrix");
+          aPositionLocation = GLES30.glGetAttribLocation(mProgram, "vPosition");
+          aColorLocation = GLES30.glGetAttribLocation(mProgram, "aColor");
+      }
+  
+      @Override
+      public void onSurfaceChanged(GL10 gl, int width, int height) {
+          //设置绘制窗口
+          GLES30.glViewport(0, 0, width, height);
+  
+  
+          //相机和透视投影方式
+          //计算宽高比
+          float ratio=(float)width/height;
+          //设置透视投影
+          Matrix.frustumM(mProjectMatrix, 0, -ratio, ratio, -1, 1, 3, 7);
+          //设置相机位置
+          Matrix.setLookAtM(mViewMatrix, 0, 0, 0, 7.0f, 0f, 0f, 0f, 0f, 1.0f, 0.0f);
+          //计算变换矩阵
+          Matrix.multiplyMM(mMVPMatrix,0,mProjectMatrix,0,mViewMatrix,0);
+  
+  
+          /*//正交投影方式
+          final float aspectRatio = width > height ?
+                  (float) width / (float) height :
+                  (float) height / (float) width;
+          if (width > height) {
+              //横屏
+              Matrix.orthoM(mMVPMatrix, 0, -aspectRatio, aspectRatio, -1f, 1f, -1f, 1f);
+          } else {
+              //竖屏
+              Matrix.orthoM(mMVPMatrix, 0, -1f, 1f, -aspectRatio, aspectRatio, -1f, 1f);
+          }*/
+      }
+  
+      @Override
+      public void onDrawFrame(GL10 gl) {
+          //把颜色缓冲区设置为我们预设的颜色
+          GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT);
+  
+          //将变换矩阵传入顶点渲染器
+          GLES20.glUniformMatrix4fv(uMatrixLocation,1,false,mMVPMatrix,0);
+          //准备坐标数据
+          GLES30.glVertexAttribPointer(aPositionLocation, 3, GLES30.GL_FLOAT, false, 0, vertexBuffer);
+          //启用顶点位置句柄
+          GLES30.glEnableVertexAttribArray(aPositionLocation);
+  
+          //准备颜色数据
+          GLES30.glVertexAttribPointer(aColorLocation, 4, GLES30.GL_FLOAT, false, 0, colorBuffer);
+          //启用顶点颜色句柄
+          GLES30.glEnableVertexAttribArray(aColorLocation);
+  
+          //绘制三角形
+          GLES30.glDrawElements(GL10.GL_TRIANGLES, indices.length, GL10.GL_UNSIGNED_SHORT, indicesBuffer);
+  
+          //禁止顶点数组的句柄
+          GLES30.glDisableVertexAttribArray(aPositionLocation);
+          GLES30.glDisableVertexAttribArray(aColorLocation);
+      }
+  }
+  ```
+  
+  
+
+### 绘制圆形
+
+其他也都和上面的一样，只有Render不同，如下:  
+
+```java
+public class CircularRender implements GLSurfaceView.Renderer {
+    //一个Float占用4Byte
+    private static final int BYTES_PER_FLOAT = 4;
+    //顶点位置缓存
+    private final FloatBuffer vertexBuffer;
+    //顶点颜色缓存
+    private final FloatBuffer colorBuffer;
+    //渲染程序
+    private int mProgram;
+
+    //相机矩阵
+    private final float[] mViewMatrix = new float[16];
+    //投影矩阵
+    private final float[] mProjectMatrix = new float[16];
+    //最终变换矩阵
+    private final float[] mMVPMatrix = new float[16];
+
+    //返回属性变量的位置
+    //变换矩阵
+    private int uMatrixLocation;
+    //位置
+    private int aPositionLocation;
+    //颜色
+    private int aColorLocation;
+
+    //圆形顶点位置
+    private float circularCoords[];
+    //顶点的颜色
+    private float color[];
+
+
+    public CircularRender() {
+        createPositions(1,60);
+
+        //顶点位置相关
+        //分配本地内存空间,每个浮点型占4字节空间；将坐标数据转换为FloatBuffer，用以传入给OpenGL ES程序
+        vertexBuffer = ByteBuffer.allocateDirect(circularCoords.length * BYTES_PER_FLOAT)
+                .order(ByteOrder.nativeOrder())
+                .asFloatBuffer();
+        vertexBuffer.put(circularCoords);
+        vertexBuffer.position(0);
+
+        //顶点颜色相关
+        colorBuffer = ByteBuffer.allocateDirect(color.length * BYTES_PER_FLOAT)
+                .order(ByteOrder.nativeOrder())
+                .asFloatBuffer();
+        colorBuffer.put(color);
+        colorBuffer.position(0);
+    }
+
+    private void createPositions(int radius, int n){
+        ArrayList<Float> data=new ArrayList<>();
+        data.add(0.0f);             //设置圆心坐标
+        data.add(0.0f);
+        data.add(0.0f);
+        float angDegSpan=360f/n;
+        for(float i=0;i<360+angDegSpan;i+=angDegSpan){
+            data.add((float) (radius*Math.sin(i*Math.PI/180f)));
+            data.add((float)(radius*Math.cos(i*Math.PI/180f)));
+            data.add(0.0f);
+        }
+        float[] f=new float[data.size()];
+        for (int i=0;i<f.length;i++){
+            f[i]=data.get(i);
+        }
+
+        circularCoords = f;
+
+        //处理各个顶点的颜色
+        color = new float[f.length*4/3];
+        ArrayList<Float> tempC = new ArrayList<>();
+        ArrayList<Float> totalC = new ArrayList<>();
+        tempC.add(1.0f);
+        tempC.add(0.0f);
+        tempC.add(0.0f);
+        tempC.add(1.0f);
+        for (int i=0;i<f.length/3;i++){
+            totalC.addAll(tempC);
+        }
+
+        for (int i=0; i<totalC.size();i++){
+            color[i]=totalC.get(i);
+        }
+    }
+
+    @Override
+    public void onSurfaceCreated(GL10 gl, EGLConfig config) {
+        //将背景设置为白色
+        GLES20.glClearColor(1.0f,1.0f,1.0f,1.0f);
+
+        //编译顶点着色程序
+        String vertexShaderStr = ResReadUtils.readResource(R.raw.vertex_simple_shade);
+        int vertexShaderId = ShaderUtils.compileVertexShader(vertexShaderStr);
+        //编译片段着色程序
+        String fragmentShaderStr = ResReadUtils.readResource(R.raw.fragment_simple_shade);
+        int fragmentShaderId = ShaderUtils.compileFragmentShader(fragmentShaderStr);
+        //连接程序
+        mProgram = ShaderUtils.linkProgram(vertexShaderId, fragmentShaderId);
+        //在OpenGLES环境中使用程序
+        GLES30.glUseProgram(mProgram);
+
+
+        uMatrixLocation = GLES30.glGetUniformLocation(mProgram, "u_Matrix");
+        aPositionLocation = GLES30.glGetAttribLocation(mProgram, "vPosition");
+        aColorLocation = GLES30.glGetAttribLocation(mProgram, "aColor");
+    }
+
+    @Override
+    public void onSurfaceChanged(GL10 gl, int width, int height) {
+        //设置绘制窗口
+        GLES30.glViewport(0, 0, width, height);
+
+
+        //相机和透视投影方式
+        //计算宽高比
+        float ratio=(float)width/height;
+        //设置透视投影
+        Matrix.frustumM(mProjectMatrix, 0, -ratio, ratio, -1, 1, 3, 7);
+        //设置相机位置
+        Matrix.setLookAtM(mViewMatrix, 0, 0, 0, 7.0f, 0f, 0f, 0f, 0f, 1.0f, 0.0f);
+        //计算变换矩阵
+        Matrix.multiplyMM(mMVPMatrix,0,mProjectMatrix,0,mViewMatrix,0);
+
+
+        /*//正交投影方式
+        final float aspectRatio = width > height ?
+                (float) width / (float) height :
+                (float) height / (float) width;
+        if (width > height) {
+            //横屏
+            Matrix.orthoM(mMVPMatrix, 0, -aspectRatio, aspectRatio, -1f, 1f, -1f, 1f);
+        } else {
+            //竖屏
+            Matrix.orthoM(mMVPMatrix, 0, -1f, 1f, -aspectRatio, aspectRatio, -1f, 1f);
+        }*/
+    }
+
+    @Override
+    public void onDrawFrame(GL10 gl) {
+        //把颜色缓冲区设置为我们预设的颜色
+        GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT);
+
+        //将变换矩阵传入顶点渲染器
+        GLES20.glUniformMatrix4fv(uMatrixLocation,1,false,mMVPMatrix,0);
+        //准备坐标数据
+        GLES30.glVertexAttribPointer(aPositionLocation, 3, GLES30.GL_FLOAT, false, 0, vertexBuffer);
+        //启用顶点位置句柄
+        GLES30.glEnableVertexAttribArray(aPositionLocation);
+
+        //准备颜色数据
+        GLES30.glVertexAttribPointer(aColorLocation, 4, GLES30.GL_FLOAT, false, 0, colorBuffer);
+        //启用顶点颜色句柄
+        GLES30.glEnableVertexAttribArray(aColorLocation);
+
+        //绘制圆形
+        GLES30.glDrawArrays(GLES30.GL_TRIANGLE_FAN, 0, circularCoords.length/3);
+
+        //禁止顶点数组的句柄
+        GLES30.glDisableVertexAttribArray(aPositionLocation);
+        GLES30.glDisableVertexAttribArray(aColorLocation);
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md" "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
new file mode 100644
index 00000000..a286783e
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
@@ -0,0 +1,232 @@
+## 6.OpenGL ES着色器语言GLSL
+
+顶点着色器:  
+
+```
+#version 330 core
+layout (location = 0) in vec3 position; // position变量的属性位置值为0
+
+out vec4 vertexColor; // 为片段着色器指定一个颜色输出
+
+void main()
+{
+    gl_Position = vec4(position, 1.0); // 注意我们如何把一个vec3作为vec4的构造器的参数
+    vertexColor = vec4(0.5f, 0.0f, 0.0f, 1.0f); // 把输出变量设置为暗红色
+}
+```
+
+片段着色器:  
+
+```
+#version 330 core
+in vec4 vertexColor; // 从顶点着色器传来的输入变量（名称相同、类型相同）
+
+out vec4 color; // 片段着色器输出的变量名可以任意命名，类型必须是vec4
+
+void main()
+{
+    color = vertexColor;
+}
+```
+
+
+
+### GLSL的特点
+
+OpenGLES的着色器语言GLSL是一种高级的图形化编程语言，其源自应用广泛的C语言。与传统的C语言不同的是，它提供了更加丰富的针对于图像处理的原生类型，诸如向量、矩阵之类。GLSL主要包含以下特性：
+
+- GLSL是一种面向过程的语言，和c相同
+- GLSL的基本语法与C/C++相同
+- 它完美的支持向量和矩阵的操作
+- 它是通过限定符操作来管理输入输出类型的
+- GLSL提供了大量的内置函数来提供丰富的扩展功能
+
+
+
+### 基本数据类型
+
+GLSL中的数据类型主要分为标量、向量、矩阵、采样器、结构体、数组、空类型七种类型。如下：
+
+- 标量 
+
+  标量表示的是只有大小没有方向的量，在GLSL中`标量只有bool、int和float三种`。对于int，和C一样，可以写为十进制（16）、八进制（020）或者十六进制（0x10）。对于标量的运算，我们最需要注意的是`精度`，防止溢出问题。
+
+- 向量
+
+  向量我们可以看做是数组，在GLSL通常用于储存颜色、坐标等数据，针对维数，可分为二维、三维和四维向量。针对存储的标量类型，可以分为bool、int和float。共有vec2、vec3、vec4，ivec2、ivec3、ivec4、bvec2、bvec3和bvec4九种类型，数组代表维数、i表示int类型、b表示bool类型。***需要注意的是，GLSL中的向量表示竖向量，所以与矩阵相乘进行变换时，矩阵在前，向量在后（与DirectX正好相反）***。向量在GPU中由硬件支持运算，比CPU快的多。
+  作为颜色向量时，用rgba表示分量，就如同取数组的中具体数据的索引值。三维颜色向量就用rgb表示分量。比如对于颜色向量vec4 color，color[0]和color.r都表示color向量的第一个值，也就是红色的分量。其他相同。
+  作为位置向量时，用xyzw表示分量，xyz分别表示xyz坐标，w表示向量的模。三维坐标向量为xyz表示分量，二维向量为xy表示分量。
+  作为纹理向量时，用stpq表示分量，三维用stp表示分量，二维用st表示分量。
+
+- 矩阵
+
+  在GLSL中矩阵拥有2*2、3*3、4*4三种类型的矩阵，分别用mat2、mat3、mat4表示。我们可以把矩阵看做是一个二维数组，也可以用二维数组下表的方式取里面具体位置的值。
+
+- 采样器
+
+  采样器是专门用来对纹理进行采样工作的，在GLSL中一般来说，一个采样器变量表示一副或者一套纹理贴图。所谓的纹理贴图可以理解为我们看到的物体上的皮肤。
+
+- 结构体
+
+  和C语言中的结构体相同，用struct来定义结构体。
+
+- 数组
+
+  数组也与C相同
+
+- 空类型
+
+  void
+
+###  变量修饰符 
+
+- none：(默认的可省略)本地变量，可读可写，函数的输入参数既是这种类型
+- const：声明变量或函数的参数为只读类型
+- attribute：用于保存顶点或法线数据,它可以在数据缓冲区中读取数据，仅能用于顶点着色器
+- uniform：在运行时 shader 无法改变 uniform 变量，一般用来放置程序传递给 shader 的变换矩阵，材质，光照参数等等，可用于顶点着色器和片元着色器
+- varying：易变量，用于修饰从顶点着色器向片元着色器传递的变量。一般是在光栅化图元的过程中计算生成，记录在每个片段中(而不是从顶点着色器直接传递给片元着色器)
+
+
+
+### 运算符
+
+[]、++、-、+、？、：、> 等等
+
+
+
+### 类型转换 
+
+GLSL的类型转换与C不同。在GLSL中类型不可以自动提升，比如float a=1;就是一种错误的写法，必须严格的写成float a=1.0，也不可以强制转换，即float a=(float)1;也是错误的写法，但是可以用内置函数来进行转换，如float a=float(1);还有float a=float(true);（true为1.0，false为0.0）等，值得注意的是，低精度的int不能转换为低精度的float
+
+### 限定符
+
+与Java中的限定符类似，放在变量类型前面，并且只能用于全局变量。
+
+- attritude：一般用于各个顶点各不相同的量。如顶点颜色、坐标等。
+- uniform：一般用于对于3D物体中所有顶点都相同的量。比如光源位置，统一变换矩阵等。
+- varying：表示易变量，一般用于顶点着色器传递到片元着色器的量。
+- const：常量。
+
+- 流程控制
+
+  常用的与java基本一样
+
+- 函数
+
+  定义函数的方式也与C语言基本相同。函数的返回值可以是GLSL中的除了采样器的任意类型。对于GLSL中函数的参数，可以用参数用途修饰符来进行修饰，常用修饰符如下：
+
+  - in：输入参数，无修饰符时默认为此修饰符。
+  - out：输出参数。
+  - inout：既可以作为输入参数，又可以作为输出参数。
+
+- 浮点精度
+
+  与顶点着色器不同的是，在片元着色器中使用浮点型时，必须指定浮点类型的精度，否则编译会报错。精度有三种，分别为：
+
+  - lowp：低精度。8位。
+  - mediump：中精度。10位。
+  - highp：高精度。16位。
+
+- 程序结构
+
+  也是main()为入口函数、全局变量、局部变量等，与java类似。    
+
+### GLSL内建变量
+
+在着色器中有一些特殊的变量，不用声明也可以使用，这些变量叫做内建变量。 他们大致可以分为两种，一种是input类型，负责向硬件(渲染管线)发送数据；另一种是output类型，负责向程序回传数据，以便编程时需要。内建变量相当于着色器硬件的输入和输出点，使用者利用这些输入点输入之后，就会看到屏幕上的输出。通过输出点可以知道输出的某些数据内容。
+
+ #### 顶点着色器的内建变量
+
+- 输入变量
+  - gl_Position:顶点坐标信息
+  - gl_PointSize:点的大小，默认是1，只有在gl.POINTS模式下才有效
+
+片段着色器的内建变量
+
+- 输入变量
+  - gl_FragCoord:当前片元在framebuffer画面的相对位置
+  - gl_FragFacing:bool型，表示是否为属于光栅化生成此片元的对应图元的正面。
+  - gl_PointCoord:经过插值计算后的纹理坐标，点的范围是0.0到1.0
+- 输出变量
+  - gl_FragColor:当前片元颜色
+  - gl_FragData:vec4类型的数据。设置当前片元的颜色，供渲染管线的后继过程使用。
+
+### 内置函数
+
+#### 常用函数
+
+- radians(x)：角度转弧度
+- degrees(x)：弧度转角度
+- sin(x)：正弦函数，传入值为弧度。相同的还有cos余弦函数、tan正切函数、asin反正弦、acos反余弦
+- atan反正切
+- pow(x,y)：xy
+- exp(x)：ex
+- exp2(x)：2x
+- log(x)：logex
+- log2(x)：log2x
+- sqrt(x)：x√
+- inversesqr(x)：1x√
+- abs(x)：取x的绝对值
+- sign(x)：x>0返回1.0，x<0返回-1.0，否则返回0.0
+- ceil(x)：返回大于或者等于x的整数
+- floor(x)：返回小于或者等于x的整数
+- fract(x)：返回x-floor(x)的值
+- mod(x,y)：取模（求余）
+- min(x,y)：获取xy中小的那个
+- max(x,y)：获取xy中大的那个
+- mix(x,y,a)：返回x∗(1−a)+y∗a
+- step(x,a)：x< a返回0.0，否则返回1.0
+- smoothstep(x,y,a)：a < x返回0.0，a>y返回1.0，否则返回0.0-1.0之间平滑的Hermite插值。
+- dFdx(p)：p在x方向上的偏导数
+- dFdy(p)：p在y方向上的偏导数
+- fwidth(p)：p在x和y方向上的偏导数的绝对值之和
+
+
+
+#### 几何函数
+
+- length(x)：计算向量x的长度
+- distance(x,y)：返回向量xy之间的距离
+- dot(x,y)：返回向量xy的点积
+- cross(x,y)：返回向量xy的差积
+- normalize(x)：返回与x向量方向相同，长度为1的向量
+
+#### 矩阵函数
+
+- matrixCompMult(x,y)：将矩阵相乘
+- lessThan(x,y)：返回向量xy的各个分量执行x< y的结果，类似的有greaterThan,equal,notEqual
+- lessThanEqual(x,y)：返回向量xy的各个分量执行x<= y的结果，类似的有类似的有greaterThanEqual
+- any(bvec x)：x有一个元素为true，则为true
+- all(bvec x)：x所有元素为true，则返回true，否则返回false
+- not(bvec x)：x所有分量执行逻辑非运算
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/OpenGL/7.GLES\347\261\273\345\217\212Matrix\347\261\273.md" "b/VideoDevelopment/OpenGL/7.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
new file mode 100644
index 00000000..72141be7
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/7.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
@@ -0,0 +1,143 @@
+## 7.GLES类及Matrix类
+
+
+
+GLES30作为我们与着色器连接的工具类提供了丰富的api。
+
+上一篇文章说到GLSL中的变量修饰符有以下部分:    
+
+- none：(默认的可省略)本地变量，可读可写，函数的输入参数既是这种类型
+- const：声明变量或函数的参数为只读类型
+- attribute：用于保存顶点或法线数据,它可以在数据缓冲区中读取数据，仅能用于顶点着色器
+- uniform：在运行时 shader 无法改变 uniform 变量，一般用来放置程序传递给 shader 的变换矩阵，材质，光照参数等等，可用于顶点着色器和片元着色器
+- varying：用于修饰从顶点着色器向片元着色器传递的变量
+
+
+
+### 获取着色器程序内成员变量的id(句柄、指针)
+
+- mPostionHandler = GLES30.glGetAttribLocation(mProgram, "aPosition"):获取着色器程序中，指定为attribute类型的变量id。
+- mMatrixHnadler = GLES30.glGetUniformLocation(mProgram, "uMVPMatrix"):获取着色器程序中，指定为uniform类型的变量id。
+
+### 向着色器传递数据
+
+上面获取到指向着色器中相应数据成员的各个id后，就能将我们要设置的顶点数据、颜色数据等传递到着色器中了。
+
+```
+// 将最终变换矩阵传入shader程序
+GLES20.glUniformMatrix4fv(muMVPMatrixHandle, 1, false, MatrixState.getFinalMatrix(), 0);
+// 顶点位置数据传入着色器
+GLES20.glVertexAttribPointer(maPositionHandle, 3, GLES20.GL_FLOAT, false, 20, mRectBuffer);
+// 顶点颜色数据传入着色器中
+GLES20.glVertexAttribPointer(maColorHandle, 4, GLES20.GL_FLOAT, false, 4*4, mColorBuffer);
+// 顶点坐标传递到顶点着色器
+GLES20.glVertexAttribPointer(maTextureHandle, 2, GLES20.GL_FLOAT, false, 20, mRectBuffer);
+```
+
+### 定义顶点属性数组
+
+
+
+        /**
+         * glVertexAttribPointer()方法的参数分别为: 
+         * index：顶点属性的索引.（这里我们的顶点位置和颜色向量在着色器中分别为0和1）layout (location = 0) in vec4 vPosition; layout (location = 1) in vec4 aColor;
+         * size: 指定每个通用顶点属性的元素个数。必须是1、2、3、4。此外，glvertexattribpointer接受符号常量gl_bgra。初始值为4（也就是涉及颜色的时候必为4）。
+         * type：属性的元素类型。（上面都是Float所以使用GLES30.GL_FLOAT）；
+         * normalized：转换的时候是否要经过规范化，true：是；false：直接转化；
+         * stride：跨距，默认是0。（由于我们将顶点位置和颜色数据分别存放没写在一个数组中，所以使用默认值0）
+         * ptr： 本地数据缓存（这里我们的是顶点的位置和颜色数据）。
+         */
+        GLES30.glVertexAttribPointer(1, 4, GLES30.GL_FLOAT, false, 0, colorBuffer);
+
+
+### 启用或禁用顶点属性数组
+
+调用GLES20.glEnableVertexAttribArray和GLES20.glDisableVertexAttribArray传入参数index。如果启用，那么当GLES20.glDrawArrays或者GLES20.glDrawElements被调用时，顶点属性数组会被使用。
+
+### 选择活动纹理单元
+
+```
+void glActiveTexture(int texture)
+```
+
+texture指定哪一个纹理单元被置为活动状态。texture必须是GL_TEXTUREi之一，其中0 <= i < GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS，初始值为GL_TEXTURE0。
+GLES20.glActiveTexture()确定了后续的纹理状态改变影响哪个纹理，纹理单元的数量是依据该纹理单元所被支持的具体实现。
+
+## Matrix
+
+而`Matrix就是专门设计出来帮助我们简化矩阵和向量运算操作的，里面所有的实现原理都是线性代数中的运算`。
+
+我们知道OpenGl中实现图形的操作大量使用了矩阵，在OpenGL中使用的向量为列向量，我们通过利用矩阵与列向量（颜色、坐标都可看做列向量）相乘，得到一个新的列向量。利用这点，我们构建一个的矩阵，与图形所有的顶点坐标坐标相乘，得到新的顶点坐标集合，当这个矩阵构造恰当的话，新得到的顶点坐标集合形成的图形相对原图形就会出现平移、旋转、缩放或拉伸、抑或扭曲的效果。
+`Matrix：专门为处理4*4矩阵和4元素向量设计的，其中的方法都是static的，不需要初始化Matrix实例`。
+
+- multiplyMM
+
+  两个4x4矩阵相乘，并将结果存储到第三个4x4矩阵中。
+
+  ```
+  public static native void multiplyMM(float[] result, int resultOffset,
+              float[] lhs, int lhsOffset, float[] rhs, int rhsOffset);
+  ```
+
+- multiplyMV
+
+  将一个4x4矩阵和一个四元素向量相乘，得到一个新的四元素向量
+
+  ```
+  public static native void multiplyMV(float[] resultVec,int resultVecOffset,
+  			 float[] lhsMat, int lhsMatOffset,
+              float[] rhsVec, int rhsVecOffset);
+  ```
+
+- transposeM
+
+  获取逆矩阵
+
+- invertM
+
+  计算正交投影和透视投影
+
+- orthoM
+
+  计算正交投影矩阵
+
+- frustumM
+
+  计算透视投影矩阵
+
+- perspectiveM
+
+  根据视场角度、纵横比和Z裁剪平面定义投影矩阵
+
+- length
+
+  计算向量长度
+
+- setldentityM
+
+  创建单位矩阵
+
+- scaleM
+
+- translateM
+
+- rotateM
+
+- setRotateM
+
+- setRotateEulerM
+
+- setLookAtm
+
+  定义相机视图
+
+  
+
+
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/OpenGL/8.OpenGL ES\347\272\271\347\220\206.md" "b/VideoDevelopment/OpenGL/8.OpenGL ES\347\272\271\347\220\206.md"
new file mode 100644
index 00000000..f7c28838
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/8.OpenGL ES\347\272\271\347\220\206.md"	
@@ -0,0 +1,547 @@
+## OpenGL ES纹理
+
+
+
+### 纹理
+
+在OpenGL中简单理解就是一张图片。
+
+- 纹理Id:纹理的直接饮用
+
+- 纹理单元:纹理的操作容器，有GL_TEXTURE0、GL_TEXTURE1、GL_TEXTURE2等，纹理单元的数量是有限的，最多16个。所以在最多只能同时操作16个纹理。在切换使用纹理单元的时候，使用glActiveTexture方法。
+
+- 纹理目标:一个纹理单元中包含了多个类型的纹理目标，有GL_TEXTURE_1D、GL_TEXTURE_2D、CUBE_MAP等。本章中，将纹理ID绑定到纹理单元0的GL_TEXTURE_2D纹理目标上，之后对纹理目标的操作都是对纹理Id对应的数据进行操作。
+
+  OpenGL要操作一个纹理，那么是将纹理ID装进纹理单元这个容器里，然后再通过操作纹理单元的方式去实现的。这样的话，我们可以加载出很多很多个纹理ID(但要注意爆内存问题)，但只有16个纹理单元，在Fragment Shader里最多同时能操作16个单元。
+
+  
+
+### 纹理与渐变色的区别
+
+渐变色:光栅化过程中计算出颜色值，然后再片段着色器的时候可以直接赋值。
+
+纹理:光栅化过程中，计算出当前片段在纹理上的坐标位置，然后在片段着色器中根据这个纹理上的坐标，去纹理中取出相应的颜色值。
+
+### 纹理坐标
+
+OpenGL中，2D纹理也有自己的坐标体系，取值范围在(0,0)到(1,1)内，两个维度分别为S、T，所以一般称为ST纹理坐标。有些时候也叫UV坐标。纹理左边的方向性和Android上的canvas移植，都是顶点在左上角。
+
+纹理上的每个顶点与定点坐标上的顶点一一对应。如下图，左边是顶点坐标，右边是纹理坐标，只要两个坐标的ABCD定义顺序一致，就可以正常地映射出对应的图形。顶点坐标内光栅化后的每个片段，都会在纹理坐标内取得对应的颜色值。
+
+
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_texture_position.jpg)
+
+### 纹理尺寸
+
+在OpenGL ES 2.0中规定，纹理的每个维度必须是2次幂，也就是2、4、8....等等，纹理的最大值上限通常比较大，例如2048*2048。
+
+### 文件读取
+
+OpenGL不能直接加载jpg或者png这类被编码的压缩格式，需要加载原始数据，也就是bitmpa。我们在内置图片到工程中，应该将图片放到drawable-nodpi中，避免读取时被压缩，通过BitmapFactory解码读取图片时，要设置为非缩放的方式，即options.isScaled=false。
+
+### 纹理过滤
+
+当我们通过光栅化将图形处理成一个个小片段的时候，再讲纹理采样，渲染到指定位置上时，通常会遇到纹理元素和小片段并非一一对应。这时候，会出现纹理的压缩或者放大。那么在这两种情况下，就会有不同的处理方案，这就是纹理过滤了。
+
+### 加载纹理
+
+下面是一个工具类方法，相对通用，能解决大部分需求，这个方法可以将内置的图片资源加载出对应的纹理ID。
+
+ ```java
+/**
+ * 纹理加载助手类
+ */
+public class TextureHelper {
+    private static final String TAG = "TextureHelper";
+
+    /**
+     * 根据资源ID获取相应的OpenGL纹理ID，若加载失败则返回0
+     * <br>必须在GL线程中调用
+     */
+    public static TextureBean loadTexture(Context context, int resourceId) {
+        TextureBean bean = new TextureBean();
+        final int[] textureObjectIds = new int[1];
+        // 1. 创建纹理对象
+        GLES20.glGenTextures(1, textureObjectIds, 0);
+
+        if (textureObjectIds[0] == 0) {
+            if (LoggerConfig.ON) {
+                Log.w(TAG, "Could not generate a new OpenGL texture object.");
+            }
+            return bean;
+        }
+
+        final BitmapFactory.Options options = new BitmapFactory.Options();
+        options.inScaled = false;
+
+        final Bitmap bitmap = BitmapFactory.decodeResource(
+                context.getResources(), resourceId, options);
+
+        if (bitmap == null) {
+            if (LoggerConfig.ON) {
+                Log.w(TAG, "Resource ID " + resourceId + " could not be decoded.");
+            }
+            // 加载Bitmap资源失败，删除纹理Id
+            GLES20.glDeleteTextures(1, textureObjectIds, 0);
+            return bean;
+        }
+        // 2. 将纹理绑定到OpenGL对象上
+        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, textureObjectIds[0]);
+
+        // 3. 设置纹理过滤参数:解决纹理缩放过程中的锯齿问题。若不设置，则会导致纹理为黑色
+        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR_MIPMAP_LINEAR);
+        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
+        // 4. 通过OpenGL对象读取Bitmap数据，并且绑定到纹理对象上，之后就可以回收Bitmap对象
+        GLUtils.texImage2D(GLES20.GL_TEXTURE_2D, 0, bitmap, 0);
+
+        // Note: Following code may cause an error to be reported in the
+        // ADB log as follows: E/IMGSRV(20095): :0: HardwareMipGen:
+        // Failed to generate texture mipmap levels (error=3)
+        // No OpenGL error will be encountered (glGetError() will return
+        // 0). If this happens, just squash the source image to be
+        // square. It will look the same because of texture coordinates,
+        // and mipmap generation will work.
+        // 5. 生成Mip位图
+        GLES20.glGenerateMipmap(GLES20.GL_TEXTURE_2D);
+
+        // 6. 回收Bitmap对象
+        bean.setWidth(bitmap.getWidth());
+        bean.setHeight(bitmap.getHeight());
+        bitmap.recycle();
+
+        // 7. 将纹理从OpenGL对象上解绑
+        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
+
+        // 所以整个流程中，OpenGL对象类似一个容器或者中间者的方式，将Bitmap数据转移到OpenGL纹理上
+        bean.setTextureId(textureObjectIds[0]);
+        return bean;
+    }
+
+    /**
+     * 纹理数据
+     */
+    public static class TextureBean {
+        private int mTextureId;
+        private int mWidth;
+        private int mHeight;
+
+        public int getTextureId() {
+            return mTextureId;
+        }
+
+        void setTextureId(int textureId) {
+            mTextureId = textureId;
+        }
+
+        public int getWidth() {
+            return mWidth;
+        }
+
+        public void setWidth(int width) {
+            mWidth = width;
+        }
+
+        public int getHeight() {
+            return mHeight;
+        }
+
+        public void setHeight(int height) {
+            mHeight = height;
+        }
+    }
+}
+ ```
+
+上面的工具类要求图片必须是2次幂的尺寸，不过大部分情况下应该不会有问题。
+
+
+
+### 纹理实现
+
+- 顶点着色器
+
+  将之前颜色向量`vec4 aColor`变为了纹理向量`vec2 aTextureCoord`；
+
+  ```
+  #version 300 es
+  layout (location = 0) in vec4 vPosition;
+  layout (location = 1) in vec2 aTextureCoord;
+  uniform mat4 u_Matrix;
+  //输出纹理坐标(s,t)
+  out vec2 vTexCoord;
+  void main() {
+      gl_Position  = u_Matrix*vPosition;
+      gl_PointSize = 10.0;
+      vTexCoord = aTextureCoord;
+  }
+  ```
+
+  
+
+- 片段着色器
+
+  之前直接输出顶点着色器来的颜色，现在变为经过纹理处理最终成为输出颜色`。
+
+  ```
+  #version 300 es
+  precision mediump float;
+  uniform sampler2D uTextureUnit;
+  //接收刚才顶点着色器传入的纹理坐标(s,t)
+  in vec2 vTexCoord;
+  out vec4 vFragColor;
+  void main() {
+      vFragColor = texture(uTextureUnit,vTexCoord);
+  }
+  ```
+
+  
+
+- render实现类
+
+  区别就是把前面绘制矩形时的color部分换成了纹理，其他都是一样的。
+
+  纹理的绘制:  
+
+  ```
+          //激活纹理，设置当前活动的纹理单元为单元0
+          GLES30.glActiveTexture(GLES30.GL_TEXTURE0);
+          //绑定纹理，将纹理id绑定到当前活动的纹理单元上
+          GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, textureId);
+          // 将纹理单元传递片段着色器的u_TextureUnit
+          GLES20.glUniform1i(aTextureLocation, 0);
+  ```
+
+  
+
+  
+
+  ```java
+  public class TextureRender implements GLSurfaceView.Renderer {
+      //一个Float占用4Byte
+      private static final int BYTES_PER_FLOAT = 4;
+      //顶点位置缓存
+      private final FloatBuffer vertexBuffer;
+      //顶点颜色缓存
+      private final FloatBuffer textureBuffer;
+      //渲染程序
+      private int mProgram;
+  
+      //返回属性变量的位置
+      //变换矩阵
+      private int uMatrixLocation;
+      //位置
+      private int aPositionLocation;
+      //颜色
+      private int aTextureLocation;
+      private int textureId;
+  
+      /**
+       * 坐标占用的向量个数
+       */
+      private static final int POSITION_COMPONENT_COUNT = 2;
+      private static final float[] POINT_DATA = {
+              -0.5f, -0.5f,
+              0.5f, -0.5f,
+              -0.5f, 0.5f,
+              0.5f, 0.5f,
+      };
+      /**
+       * 颜色占用的向量个数
+       */
+      private static final int TEXTURE_COMPONENT_COUNT = 2;
+      private static final float[] TEXTURE_DATA = {
+              0.0f, 1.0f,
+              1.0f, 1.0f,
+              0.0f, 0.0f,
+              1.0f, 0.0f
+      };
+      private final float[] mProjectionMatrix = new float[16];
+  
+      public TextureRender() {
+          //顶点位置相关
+          //分配本地内存空间,每个浮点型占4字节空间；将坐标数据转换为FloatBuffer，用以传入给OpenGL ES程序
+          vertexBuffer = ByteBuffer.allocateDirect(POINT_DATA.length * BYTES_PER_FLOAT)
+                  .order(ByteOrder.nativeOrder())
+                  .asFloatBuffer();
+          vertexBuffer.put(POINT_DATA);
+          vertexBuffer.position(0);
+  
+          //顶点颜色相关
+          textureBuffer = ByteBuffer.allocateDirect(TEXTURE_DATA.length * BYTES_PER_FLOAT)
+                  .order(ByteOrder.nativeOrder())
+                  .asFloatBuffer();
+          textureBuffer.put(TEXTURE_DATA);
+          textureBuffer.position(0);
+      }
+  
+      @Override
+      public void onSurfaceCreated(GL10 gl, EGLConfig config) {
+          //将背景设置为白色
+          GLES20.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
+  
+          //编译顶点着色程序
+          String vertexShaderStr = ResReadUtils.readResource(R.raw.texture_vertex_simple_shade);
+          int vertexShaderId = ShaderUtils.compileVertexShader(vertexShaderStr);
+          //编译片段着色程序
+          String fragmentShaderStr = ResReadUtils.readResource(R.raw.texture_fragment_simple_shade);
+          int fragmentShaderId = ShaderUtils.compileFragmentShader(fragmentShaderStr);
+          //连接程序
+          mProgram = ShaderUtils.linkProgram(vertexShaderId, fragmentShaderId);
+          //在OpenGLES环境中使用程序
+          GLES30.glUseProgram(mProgram);
+  
+  
+          uMatrixLocation = GLES30.glGetUniformLocation(mProgram, "u_Matrix");
+          aPositionLocation = GLES30.glGetAttribLocation(mProgram, "vPosition");
+          aTextureLocation = GLES30.glGetAttribLocation(mProgram, "aTextureCoord");
+          textureId = TextureHelper.loadTexture(MyApplication.getInstance(), R.drawable.img).getTextureId();
+      }
+  
+      @Override
+      public void onSurfaceChanged(GL10 gl, int width, int height) {
+          //设置绘制窗口
+          GLES30.glViewport(0, 0, width, height);
+          //正交投影方式
+          final float aspectRatio = width > height ?
+                  (float) width / (float) height :
+                  (float) height / (float) width;
+          if (width > height) {
+              //横屏
+              Matrix.orthoM(mProjectionMatrix, 0, -aspectRatio, aspectRatio, -1f, 1f, -1f, 1f);
+          } else {
+              //竖屏
+              Matrix.orthoM(mProjectionMatrix, 0, -1f, 1f, -aspectRatio, aspectRatio, -1f, 1f);
+          }
+      }
+  
+      @Override
+      public void onDrawFrame(GL10 gl) {
+          //把颜色缓冲区设置为我们预设的颜色
+          GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT);
+  
+          //将变换矩阵传入顶点渲染器
+          GLES20.glUniformMatrix4fv(uMatrixLocation, 1, false, mProjectionMatrix, 0);
+          //准备坐标数据
+          GLES30.glVertexAttribPointer(aPositionLocation, POSITION_COMPONENT_COUNT, GLES30.GL_FLOAT, false, 0, vertexBuffer);
+          //启用顶点位置句柄
+          GLES30.glEnableVertexAttribArray(aPositionLocation);
+  
+          //准备颜色数据
+          GLES30.glVertexAttribPointer(aTextureLocation, TEXTURE_COMPONENT_COUNT, GLES30.GL_FLOAT, false, 0, textureBuffer);
+          //启用顶点颜色句柄
+          GLES30.glEnableVertexAttribArray(aTextureLocation);
+  
+          //激活纹理
+          GLES30.glActiveTexture(GLES30.GL_TEXTURE0);
+          //绑定纹理
+          GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, textureId);
+          // 将纹理单元传递片段着色器的u_TextureUnit
+          GLES20.glUniform1i(aTextureLocation, 0);
+  
+  
+          // 开始绘制
+          GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, POINT_DATA.length / POSITION_COMPONENT_COUNT);
+          //禁止顶点数组的句柄
+          GLES30.glDisableVertexAttribArray(aPositionLocation);
+          GLES30.glDisableVertexAttribArray(aTextureLocation);
+      }
+  }
+  ```
+
+
+
+### 多纹理绘制 
+
+
+
+- 单纹理单元，多次绘制
+
+  多次调用glDrawArrays绘制纹理顶点的方式来实现，这样就是一张一张的按先后顺序，一层一层的绘制到当前的一帧画面。着色器与上面的完全一致，唯一不同的是要提供两个顶点位置的坐标，然后分别用这两个坐标调用两次glDrawArrays进行绘制
+
+  ```
+  public class TextureRender implements GLSurfaceView.Renderer {
+      //一个Float占用4Byte
+      private static final int BYTES_PER_FLOAT = 4;
+      //顶点位置缓存
+      private final FloatBuffer vertexBuffer;
+      private final FloatBuffer vertexBuffer2;
+      //顶点颜色缓存
+      private final FloatBuffer textureBuffer;
+      //渲染程序
+      private int mProgram;
+  
+      //返回属性变量的位置
+      //变换矩阵
+      private int uMatrixLocation;
+      //位置
+      private int aPositionLocation;
+      //颜色
+      private int aTextureLocation;
+      private int textureId;
+      private int textureId2;
+  
+      /**
+       * 坐标占用的向量个数
+       */
+      private static final int POSITION_COMPONENT_COUNT = 2;
+      private static final float[] POINT_DATA = {
+              -1f, -1f,
+              1f, -1f,
+              -1f, 1f,
+              1f, 1f,
+      };
+  
+      private static final float[] POINT_DATA2 = {
+              -0.5f, -0.5f,
+              0.5f, -0.5f,
+              -0.5f, 0.5f,
+              0.5f, 0.5f,
+      };
+  
+      /**
+       * 颜色占用的向量个数
+       */
+      private static final int TEXTURE_COMPONENT_COUNT = 2;
+      private static final float[] TEXTURE_DATA = {
+              0.0f, 1.0f,
+              1.0f, 1.0f,
+              0.0f, 0.0f,
+              1.0f, 0.0f
+      };
+      private final float[] mProjectionMatrix = new float[16];
+  
+      public TextureRender() {
+          //顶点位置相关
+          //分配本地内存空间,每个浮点型占4字节空间；将坐标数据转换为FloatBuffer，用以传入给OpenGL ES程序
+          vertexBuffer = ByteBuffer.allocateDirect(POINT_DATA.length * BYTES_PER_FLOAT)
+                  .order(ByteOrder.nativeOrder())
+                  .asFloatBuffer();
+          vertexBuffer.put(POINT_DATA);
+          vertexBuffer.position(0);
+  
+          vertexBuffer2 = ByteBuffer.allocateDirect(POINT_DATA2.length * BYTES_PER_FLOAT)
+                  .order(ByteOrder.nativeOrder())
+                  .asFloatBuffer();
+          vertexBuffer2.put(POINT_DATA2);
+          vertexBuffer2.position(0);
+  
+          //顶点颜色相关
+          textureBuffer = ByteBuffer.allocateDirect(TEXTURE_DATA.length * BYTES_PER_FLOAT)
+                  .order(ByteOrder.nativeOrder())
+                  .asFloatBuffer();
+          textureBuffer.put(TEXTURE_DATA);
+          textureBuffer.position(0);
+      }
+  
+      @Override
+      public void onSurfaceCreated(GL10 gl, EGLConfig config) {
+          //将背景设置为白色
+          GLES20.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
+  
+          //编译顶点着色程序
+          String vertexShaderStr = ResReadUtils.readResource(R.raw.texture_vertex_simple_shade);
+          int vertexShaderId = ShaderUtils.compileVertexShader(vertexShaderStr);
+          //编译片段着色程序
+          String fragmentShaderStr = ResReadUtils.readResource(R.raw.texture_fragment_simple_shade);
+          int fragmentShaderId = ShaderUtils.compileFragmentShader(fragmentShaderStr);
+          //连接程序
+          mProgram = ShaderUtils.linkProgram(vertexShaderId, fragmentShaderId);
+          //在OpenGLES环境中使用程序
+          GLES30.glUseProgram(mProgram);
+  
+          uMatrixLocation = GLES30.glGetUniformLocation(mProgram, "u_Matrix");
+          aPositionLocation = GLES30.glGetAttribLocation(mProgram, "vPosition");
+          aTextureLocation = GLES30.glGetAttribLocation(mProgram, "aTextureCoord");
+          textureId = TextureHelper.loadTexture(MyApplication.getInstance(), R.drawable.img).getTextureId();
+          textureId2 = TextureHelper.loadTexture(MyApplication.getInstance(), R.drawable.img).getTextureId();
+      }
+  
+      @Override
+      public void onSurfaceChanged(GL10 gl, int width, int height) {
+          //设置绘制窗口
+          GLES30.glViewport(0, 0, width, height);
+          //正交投影方式
+          final float aspectRatio = width > height ?
+                  (float) width / (float) height :
+                  (float) height / (float) width;
+          if (width > height) {
+              //横屏
+              Matrix.orthoM(mProjectionMatrix, 0, -aspectRatio, aspectRatio, -1f, 1f, -1f, 1f);
+          } else {
+              //竖屏
+              Matrix.orthoM(mProjectionMatrix, 0, -1f, 1f, -aspectRatio, aspectRatio, -1f, 1f);
+          }
+      }
+  
+      @Override
+      public void onDrawFrame(GL10 gl) {
+          //把颜色缓冲区设置为我们预设的颜色
+          GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT);
+  
+          //将变换矩阵传入顶点渲染器
+          GLES20.glUniformMatrix4fv(uMatrixLocation, 1, false, mProjectionMatrix, 0);
+          //准备坐标数据
+          GLES30.glVertexAttribPointer(aPositionLocation, POSITION_COMPONENT_COUNT, GLES30.GL_FLOAT,
+                  false, 0, vertexBuffer);
+          //启用顶点位置句柄
+          GLES30.glEnableVertexAttribArray(aPositionLocation);
+  
+          //准备颜色数据
+          GLES30.glVertexAttribPointer(aTextureLocation, TEXTURE_COMPONENT_COUNT, GLES30.GL_FLOAT,
+                  false, 0, textureBuffer);
+          //启用顶点颜色句柄
+          GLES30.glEnableVertexAttribArray(aTextureLocation);
+  
+          //激活纹理
+          GLES30.glActiveTexture(GLES30.GL_TEXTURE0);
+          //绑定纹理
+          GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, textureId);
+          // 将纹理单元传递片段着色器的u_TextureUnit
+          GLES20.glUniform1i(aTextureLocation, 0);
+          // 开始绘制
+          GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, POINT_DATA.length / POSITION_COMPONENT_COUNT);
+  
+  
+          //准备第二个纹理的坐标数据
+          GLES30.glVertexAttribPointer(aPositionLocation, POSITION_COMPONENT_COUNT, GLES30.GL_FLOAT,
+                  false, 0, vertexBuffer2);
+          //启用顶点位置句柄
+          GLES30.glEnableVertexAttribArray(aPositionLocation);
+          //绑定纹理，前面已经激活了，就不用再调了
+          GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, textureId2);
+          GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, POINT_DATA.length / POSITION_COMPONENT_COUNT);
+  
+          //禁止顶点数组的句柄
+          GLES30.glDisableVertexAttribArray(aPositionLocation);
+          GLES30.glDisableVertexAttribArray(aTextureLocation);
+      }
+  }
+  ```
+
+  
+
+- 多纹理单元，单词绘制
+
+  OpenGL可以同时操作的纹理单元是16个，那么我们可以利用多个纹理单元来进行绘制同一个图层，从而达到目的。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/OpenGL/9.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md" "b/VideoDevelopment/OpenGL/9.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
new file mode 100644
index 00000000..b6682af6
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/9.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
@@ -0,0 +1,108 @@
+## 9.GLSurfaceView+MediaPlayer播放视频
+
+
+
+平时的视频播放都是使用mediaplayer+textureview或者mediaplayer+surfaceview，但是如果我们要对视频进行一些OpenGL的操作，打个比方说我要在视频播放的时候添加一个滤镜，这个时候就需要用都SurfaceTexture了。
+
+
+
+### TextureView+MediaPlayer播放视频
+
+```java
+public class VideoActivity extends Activity {
+    private static final String VIDEO_PATH = "http://60.28.125.129/video19.ifeng.com/video06/2012/04/11/629da9ec-60d4-4814-a940-997e6487804a.mp4";
+    private Surface mSurface;
+    private TextureView mTextureView;
+    private MediaPlayer mMediaPlayer;
+
+    @Override
+    protected void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_video);
+        mTextureView = findViewById(R.id.textureview);
+        mTextureView.setSurfaceTextureListener(new TextureView.SurfaceTextureListener() {
+            @Override
+            public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
+                // 创建surface对象，让其从surfacetexture中获取数据
+                mSurface = new Surface(surface);
+                startPlay();
+            }
+
+            @Override
+            public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
+
+            }
+
+            @Override
+            public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
+                mSurface = null;
+                if (mMediaPlayer != null) {
+                    mMediaPlayer.stop();
+                    mMediaPlayer.release();
+                    mMediaPlayer = null;
+                }
+                return true;
+            }
+
+            @Override
+            public void onSurfaceTextureUpdated(SurfaceTexture surface) {
+
+            }
+        });
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+        if (mTextureView.isAvailable()) {
+            startPlay();
+        }
+    }
+
+    private void startPlay() {
+        if (mMediaPlayer != null) {
+            return;
+        }
+        mMediaPlayer = new MediaPlayer();
+        try {
+            mMediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
+            mMediaPlayer.setDataSource(this, Uri.parse(VIDEO_PATH));
+            mMediaPlayer.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
+                @Override
+                public void onPrepared(MediaPlayer mp) {
+                    if (mp != null) {
+                        mp.start();
+                    }
+                }
+            });
+            mMediaPlayer.setOnErrorListener(new MediaPlayer.OnErrorListener() {
+                @Override
+                public boolean onError(MediaPlayer mp, int what, int extra) {
+                    return false;
+                }
+            });
+            // 将surface设置给mediaplayer
+            mMediaPlayer.setSurface(mSurface);
+            mMediaPlayer.setScreenOnWhilePlaying(true);
+            mMediaPlayer.setLooping(true);
+            mMediaPlayer.prepareAsync();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    protected void onPause() {
+        super.onPause();
+        if (mMediaPlayer != null) {
+            mMediaPlayer.reset();
+            mMediaPlayer.release();
+            mMediaPlayer = null;
+        }
+    }
+}
+```
+
+
+
+### 增加OpenGL ES
\ No newline at end of file
diff --git "a/VideoDevelopment/OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL\347\256\200\344\273\213.md"
deleted file mode 100644
index faa9d102..00000000
--- "a/VideoDevelopment/OpenGL\347\256\200\344\273\213.md"
+++ /dev/null
@@ -1,52 +0,0 @@
-### OpenGL简介
-
-OpenGL(Open Graphics Library开发图形接口)是一个跨平台的图形API，用于指定3D图形处理硬件中的标准软件接口。    
-
-OpenGl的前身是SGI公司为其图形工作站开发的IRIS GL,后来因为IRIS GL的移植性不好，所以在其基础上，开发出了OpenGl。OpenGl一般用于在图形工作站，PC端使用，由于性能各方面原因，在移动端使用OpenGl基本带不动。为此，Khronos公司就为OpenGl提供了一个子集，OpenGl ES(OpenGl for Embedded System)。
-
-
-
-### OpenGL ES
-
-OpenGl ES是免费的跨平台的功能完善的2D/3D图形库接口的API,是OpenGL的一个子集。
-
-移动端使用到的基本上都是OpenGl ES，当然Android开发下还专门为OpenGl提供了android.opengl包，并且提供了GlSurfaceView,GLU,GlUtils等工具类。
-
-
-
-### OpenGL的作用
-
-
-
-手机上做图像处理用很多方法，但是目前为止最高效的方法就是有效的使用图形处理单元(GPU)，图像的处理和渲染就是在将要渲染到窗口上的像素上做很多的浮点匀速，而GPU可以并行的做浮点运算，所以用GPU来分担CPU的部分，可以提高效率。
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git "a/VideoDevelopment/SurfaceView\344\270\216TextureView.md" "b/VideoDevelopment/SurfaceView\344\270\216TextureView.md"
index 9af6ad15..4234918a 100644
--- "a/VideoDevelopment/SurfaceView\344\270\216TextureView.md"
+++ "b/VideoDevelopment/SurfaceView\344\270\216TextureView.md"
@@ -8,7 +8,7 @@ SurfaceView与TextureView
 
 ### `Surface`简介
 
-- `Surface`就是“表面”的意思。在`SDK`的文档中，对`Surface`的描述是这样的：“`Handle onto a raw buffer that is being managed by the screen compositor`”，
+- `Surface`就是“表面”的意思，可以简单理解为内存中的一段绘图缓冲区。在`SDK`的文档中，对`Surface`的描述是这样的：“`Handle onto a raw buffer that is being managed by the screen compositor`”，
     翻译成中文就是“由屏幕显示内容合成器`(screen compositor)`所管理的原生缓冲器的句柄”，   这句话包括下面两个意思:     
 
     - 通过`Surface`（因为`Surface`是句柄）就可以获得原生缓冲器以及其中的内容。就像在`C`语言中，可以通过一个文件的句柄，就可以获得文件的内容一样；
diff --git "a/VideoDevelopment/\345\205\263\351\224\256\345\270\247.md" "b/VideoDevelopment/\345\205\263\351\224\256\345\270\247.md"
index 21cb5ad1..ac0d3d9b 100644
--- "a/VideoDevelopment/\345\205\263\351\224\256\345\270\247.md"
+++ "b/VideoDevelopment/\345\205\263\351\224\256\345\270\247.md"
@@ -14,9 +14,48 @@ MP4是一种格式的规范，这个规范是被ISO机构认证的，你如果
 
 - P帧(Predictive coded picture):预测编码图像帧简称差别帧，这一帧跟之前的一个关键帧或P帧的差别，解码时需要用之前缓存的画面叠加上本帧定义的差别，生成最终的画面。也就是说P帧没有完整的画面数据，只有与前一帧的画面差别的数据。 
 - B帧(Bidirectionally predicted picture):双向预测编码图像帧简称双向差别帧，也就是B帧记录的是本帧与前后帧的差别。也就是要解码B帧，不仅要取得之前的缓存画面，还要解码之后的画面，通过前后画面与本帧数据的叠加来获取最终的画面。B帧压缩率高，但是解码时会更耗CPU。
-
 - GOP(Group of Pictures)是一组连续的画面，由一张I帧和数张B/P帧组成，是视频图像编码器和解码器存取的基本单位，它的排列顺序将会一直重复到影像结束。
 编码器将多张图像进行编码后生产成一段一段的 GOP ，解码器在播放时则是读取一段一段的GOP进行解码后读取画面再渲染显示。
+
+
+
+### 数据压缩比
+
+数据压缩比大约为: 
+
+I帧 : P帧 : B帧 = 7 ：20 : 50
+
+P帧和B帧极大的节省了数据量，节省出来的空间可以用来多保存一些I帧，以实现在相同码率下，提供更好的画质。    
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
diff --git "a/VideoDevelopment/\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md" "b/VideoDevelopment/\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
index 45b3f6bf..398deaa6 100644
--- "a/VideoDevelopment/\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
+++ "b/VideoDevelopment/\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
@@ -6,18 +6,39 @@
 ---
 
 - ***媒体***：是表示，传输，存储信息的载体，常人们见到的文字、声音、图像、图形等都是表示信息的媒体。
+
 - ***多媒体***：是声音、动画、文字、图像和录像等各种媒体的组合，以图文并茂，生动活泼的动态形式表现出来，给人以很强的视觉冲击力，留下深刻印象.
+
 - ***多媒体技术***：是将文字、声音、图形、静态图像、动态图像与计算集成在一起的技术。它要解决的问题是计算机进一步帮助人类按最自然的和最习惯的方式接受和处理信息。
+
 - ***流媒体***：流媒体是指采用流式传输的方式在`Internet`播放的连续时基媒体格式，实际指的是一种新的媒体传送方式，而不是一种新的媒体格式（在网络上传输音/视频等多媒体信息现在主要有下载和流式传输两种方式）流式传输分两种方法：实时流式传输方式(`Realtime Streaming`)和顺序流式传输方式(`Progressive Streaming`)。
+
 - ***多媒体文件***:是既包括视频又包括音频，甚至还带有脚本的一个集合，也可以叫容器。
+
 - ***媒体编码***:是文件当中的视频和音频所采用的压缩算法。也就是说一个`avi`的文件，当中的视频编码有可能是`A`，也可能是`B`，而其音频编码有可能是`1`，也有可能是`2`。
+
 - ***转码***:指将一段多媒体包括音频、视频或者其他的内容从一种编码格式转换成为另外一种编码格式。
+
 - ***帧***:帧就是一段数据的组合，它是数据传输的基本单位。就是影像动画中最小单位的单幅影像画面，相当于电影胶片上的每一格镜头。一帧就是一副静止的画面，连续的帧就形成动画，如电视图像等。
+
 - ***视频***：连续的图象变化每秒超过24帧(`Frame`)画面以上时，根据视觉暂留原理，人眼无法辨别单幅的静态画面，看上去是平滑连续的视觉效果，这样连续的画面叫做视频.
+
 - ***音频***:人类能听到的声音都成为音频，但是一般我们所说到的音频时存储在计算机里的声音。
-- ***码率***:码率就是数据传输时单位时间传送的数据位数,一般我们用的单位是`kbps`即千位每秒。 通俗一点的理解就是取样率，单位时间内取样率越大，精度就越高，处理出来的文件就越接近原始文件，但是文件体积与取样率是成正比的，所以几乎所有的编码格式重视的都是如何用最低的码率达到最少的失真。但是因为编码算法不一样，所以也不能用码率来统一衡量音质或者画质.文件大小(b) = 码率(b/s) * 时长(s)。
+
+- ***比特率(码率)***:码率就是数据传输时单位时间传送的数据位数,一般我们用的单位是`kbps`即千位(bit)每秒，也就是每秒钟传送多少个千位的信息。 通俗一点的理解就是取样率，单位时间内取样率越大，精度就越高，处理出来的文件就越接近原始文件，但是文件体积与取样率是成正比的，所以几乎所有的编码格式重视的都是如何用最低的码率达到最少的失真。但是因为编码算法不一样，所以也不能用码率来统一衡量音质或者画质.小写的b表示bit(位)，大写的B表示byte(字节)，一个字节=8个位，即1B=8b；前面的k表示1024的意思，即1024个位(Kb)或者1024个字节(KB)，表示文件的大小单位，一般使用KB。1KB/s=8Kbps。码率(kbps)=文件大小(KB)*8/时间(秒)。     
+  - 动态码率(VBR: Variable Bit Rate)
+
+     比特率可以随着图像复杂程度的不同而随之变化。图像内容简单的片段采用较小的码率，图像
+
+    内容复杂的片段采用较大的码率，这样既保证了播放质量，又兼顾了数据量的限制。例如RMVB视频文件，其中的VB就是指VBR，表示采用动态比特率编码方式，达到播放质量与体积兼得的效果。
+
+  - 静态比特率(CBR: Constant Bit Rate)
+
+    比特率恒定，图像内容复杂的片段质量不稳定，图像内容简单的片段质量较好。
+
 - ***帧率***:帧/秒(`frames per second`)的缩写帧率即每秒显示帧数，帧率表示图形处理器处理场时每秒钟能够更新的次数。高的帧率可以得到更流畅、更逼真的动画。一般来说`30fps`就是可以接受的，但是将性能提升至`60fps`则可以明显提升交互感和逼真感，但是一般来说超过`75fps`一般就不容易察觉到有明显的流畅度提升了。如果帧率超过屏幕刷新率只会浪费图形处理的能力，因为监视器不能以这么快的速度更新，这样超过新率的帧率就浪费掉了。
-![image](https://github.com/CharonChui/Pictures/blob/master/fps.gif?raw=true)
+  ![image](https://github.com/CharonChui/Pictures/blob/master/fps.gif?raw=true)
+
 - ***关键帧***:相当于二维动画中的原画，指角色或者物体运动或变化中的关键动作所处的那一帧，它包含了图像的所有信息，后来帧仅包含了改变了的信息。如果你没有足够的关键帧，你的影片品质可能比较差，因为所有的帧从别的帧处产生。对于一般的用途，一个比较好的原则是每5秒设一个关键键。但如果时那种实时传输的流文件，那么要考虑传输网络的可靠度，所以要1到2秒增加一个关键帧。
 
 
@@ -162,6 +183,59 @@ PAR DAR SAR
 - DAR(Display Aspect Ratio):显示横纵比。即最终播放出来的画面的宽和高的比，正规的播放器需要按照DAR来播放视频。
 - SAR(Sample Aspect Ratio):采样横纵比。表示横向的像素点数和纵向的像素点数的比值。这也就是我们说的分辨率。
 - DAR = PAR x SAR
+
+
+
+### 视频播放原理
+
+播放一个本地视频文件，需要经过解封装，解码音视频，音视频同步等步骤。
+
+![image](https://github.com/CharonChui/Pictures/blob/master/video_player_decode.png?raw=true)
+
+
+
+- 解封装: 就是将输入的封装格式的数据，分离成音频压缩编码数据和视频压缩编码数据。例如，FLV格式的数据，经过解封装操作后，输出H264编码的视频码流和AAC编码的音频码流。
+
+- 解码: 将视频/音频压缩编码数据，解码成本非压缩的视频/音频原始数据。通过解码，压缩编码的视频数据输出成为非压缩的颜色数据，例如YUV420p，RGB等等；压缩编码的音频数据输出成为非压缩的音频抽样数据，例如PCM数据。
+- 音视频同步: 根据解封装模块处理过程中获取到的参数信息，同步解码出来的视频和音频数据，并将音视频数据送至系统的显卡和声卡播放出来。
+
+
+
+### 流媒体
+
+上面播放器的是本地视频文件，如果播放的是网络上的视频，步骤则为: 解协议、解封装、解码音视频、音视频同步，多了一个接协议的步骤。
+
+- 解协议: 将流媒体协议的数据，解析为标准的相应的封装格式数据。
+
+  音视频在网络上传播的时候，常常采用各种流媒体协议，例如HTTP、RTMP等等，这些协议在传输音视频数据的同时也会传输一些信令数据。这些信令数据包括对播放的控制(播放、暂停、停止)或者对网络状态的描述等。解协议的过程中会去除掉信令数据而只保留音视频数据。例如，采用RTMP协议传输的数据，经过解协议操作后，输出FLV格式的数据。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 

From 79488e4ee00ac5819bb42942f11af851e6918cad Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 18 Mar 2020 16:26:33 +0800
Subject: [PATCH 002/213] update opengl notes

---
 README.md                                       | 17 ++++++++++++++++-
 .../10.OpenGL ES\347\272\271\347\220\206.md"    |  0
 ...\255\346\224\276\350\247\206\351\242\221.md" |  0
 .../12.OpenGL ES\346\273\244\351\225\234.md"    |  0
 .../5.GLTextureView\345\256\236\347\216\260.md" |  0
 ...\266\344\270\211\350\247\222\345\275\242.md" |  0
 ...\242\345\217\212\345\234\206\345\275\242.md" |  0
 ...\345\231\250\350\257\255\350\250\200GLSL.md" |  0
 ...47\261\273\345\217\212Matrix\347\261\273.md" |  0
 9 files changed, 16 insertions(+), 1 deletion(-)
 rename "VideoDevelopment/OpenGL/8.OpenGL ES\347\272\271\347\220\206.md" => "VideoDevelopment/OpenGL/10.OpenGL ES\347\272\271\347\220\206.md" (100%)
 rename "VideoDevelopment/OpenGL/9.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md" => "VideoDevelopment/OpenGL/11.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md" (100%)
 rename "VideoDevelopment/OpenGL/10.OpenGL ES\346\273\244\351\225\234.md" => "VideoDevelopment/OpenGL/12.OpenGL ES\346\273\244\351\225\234.md" (100%)
 rename "VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md" => "VideoDevelopment/OpenGL/5.GLTextureView\345\256\236\347\216\260.md" (100%)
 rename "VideoDevelopment/OpenGL/4.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md" => "VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md" (100%)
 rename "VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md" => "VideoDevelopment/OpenGL/7.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md" (100%)
 rename "VideoDevelopment/OpenGL/6.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md" => "VideoDevelopment/OpenGL/8.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md" (100%)
 rename "VideoDevelopment/OpenGL/7.GLES\347\261\273\345\217\212Matrix\347\261\273.md" => "VideoDevelopment/OpenGL/9.GLES\347\261\273\345\217\212Matrix\347\261\273.md" (100%)

diff --git a/README.md b/README.md
index 929bf3f5..3c3e2f83 100644
--- a/README.md
+++ b/README.md
@@ -66,7 +66,20 @@ Android学习笔记
     - [CDN及PCDN][228]
     - [P2P][229]
     - [播放器性能优化][230]
-    
+    - [OpenGL][231]
+        - [1.OpenGL简介][232]
+        - [][]
+        - [][]
+        - [][]
+        - [][]
+        - [][]
+        - [][]
+        - [][]
+        - [][]
+        - [][]
+        - [][]
+    - [弹幕][]
+        - [][]
 -  [图片加载][45]
     - [Glide简介(上)][25]
     - [Glide简介(下)][26]
@@ -492,6 +505,8 @@ Android学习笔记
 [228]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/CDN%E5%8F%8APCDN.md "CDN及PCDN"
 [229]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/P2P.md "P2P"
 [230]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%92%AD%E6%94%BE%E5%99%A8%E6%80%A7%E8%83%BD%E4%BC%98%E5%8C%96.md "播放器性能优化"
+[231]: hhttps://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/OpenGL  "OpenGL"
+[232]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/1.OpenGL%E7%AE%80%E4%BB%8B.md "1.OpenGL简介.md"
 
 
 
diff --git "a/VideoDevelopment/OpenGL/8.OpenGL ES\347\272\271\347\220\206.md" "b/VideoDevelopment/OpenGL/10.OpenGL ES\347\272\271\347\220\206.md"
similarity index 100%
rename from "VideoDevelopment/OpenGL/8.OpenGL ES\347\272\271\347\220\206.md"
rename to "VideoDevelopment/OpenGL/10.OpenGL ES\347\272\271\347\220\206.md"
diff --git "a/VideoDevelopment/OpenGL/9.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md" "b/VideoDevelopment/OpenGL/11.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
similarity index 100%
rename from "VideoDevelopment/OpenGL/9.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
rename to "VideoDevelopment/OpenGL/11.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
diff --git "a/VideoDevelopment/OpenGL/10.OpenGL ES\346\273\244\351\225\234.md" "b/VideoDevelopment/OpenGL/12.OpenGL ES\346\273\244\351\225\234.md"
similarity index 100%
rename from "VideoDevelopment/OpenGL/10.OpenGL ES\346\273\244\351\225\234.md"
rename to "VideoDevelopment/OpenGL/12.OpenGL ES\346\273\244\351\225\234.md"
diff --git "a/VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md" "b/VideoDevelopment/OpenGL/5.GLTextureView\345\256\236\347\216\260.md"
similarity index 100%
rename from "VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md"
rename to "VideoDevelopment/OpenGL/5.GLTextureView\345\256\236\347\216\260.md"
diff --git "a/VideoDevelopment/OpenGL/4.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md" "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"
similarity index 100%
rename from "VideoDevelopment/OpenGL/4.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"
rename to "VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"
diff --git "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md" "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"
similarity index 100%
rename from "VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"
rename to "VideoDevelopment/OpenGL/7.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"
diff --git "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md" "b/VideoDevelopment/OpenGL/8.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
similarity index 100%
rename from "VideoDevelopment/OpenGL/6.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
rename to "VideoDevelopment/OpenGL/8.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
diff --git "a/VideoDevelopment/OpenGL/7.GLES\347\261\273\345\217\212Matrix\347\261\273.md" "b/VideoDevelopment/OpenGL/9.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
similarity index 100%
rename from "VideoDevelopment/OpenGL/7.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
rename to "VideoDevelopment/OpenGL/9.GLES\347\261\273\345\217\212Matrix\347\261\273.md"

From ca8eb7b3bccf74007cde6979c27f032d29b926db Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 18 Mar 2020 16:30:27 +0800
Subject: [PATCH 003/213] add iamges

---
 README.md                                                 | 8 +++++---
 ...er\346\222\255\346\224\276\350\247\206\351\242\221.md" | 0
 .../OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"       | 0
 .../OpenGL/4.GLTextureView\345\256\236\347\216\260.md"    | 0
 ...30\345\210\266\344\270\211\350\247\222\345\275\242.md" | 0
 ...51\345\275\242\345\217\212\345\234\206\345\275\242.md" | 0
 ...50\211\262\345\231\250\350\257\255\350\250\200GLSL.md" | 0
 .../8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"  | 0
 .../OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"        | 0
 9 files changed, 5 insertions(+), 3 deletions(-)
 rename "VideoDevelopment/OpenGL/11.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md" => "VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md" (100%)
 rename "VideoDevelopment/OpenGL/12.OpenGL ES\346\273\244\351\225\234.md" => "VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md" (100%)
 rename "VideoDevelopment/OpenGL/5.GLTextureView\345\256\236\347\216\260.md" => "VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md" (100%)
 rename "VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md" => "VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md" (100%)
 rename "VideoDevelopment/OpenGL/7.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md" => "VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md" (100%)
 rename "VideoDevelopment/OpenGL/8.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md" => "VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md" (100%)
 rename "VideoDevelopment/OpenGL/9.GLES\347\261\273\345\217\212Matrix\347\261\273.md" => "VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md" (100%)
 rename "VideoDevelopment/OpenGL/10.OpenGL ES\347\272\271\347\220\206.md" => "VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md" (100%)

diff --git a/README.md b/README.md
index 3c3e2f83..f14907ef 100644
--- a/README.md
+++ b/README.md
@@ -68,8 +68,8 @@ Android学习笔记
     - [播放器性能优化][230]
     - [OpenGL][231]
         - [1.OpenGL简介][232]
-        - [][]
-        - [][]
+        - [2.GLSurfaceView简介][233]
+        - [3.GLSurfaceView源码解析][234]
         - [][]
         - [][]
         - [][]
@@ -506,7 +506,9 @@ Android学习笔记
 [229]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/P2P.md "P2P"
 [230]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%92%AD%E6%94%BE%E5%99%A8%E6%80%A7%E8%83%BD%E4%BC%98%E5%8C%96.md "播放器性能优化"
 [231]: hhttps://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/OpenGL  "OpenGL"
-[232]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/1.OpenGL%E7%AE%80%E4%BB%8B.md "1.OpenGL简介.md"
+[232]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/1.OpenGL%E7%AE%80%E4%BB%8B.md "1.OpenGL简介"
+[233]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/2.GLSurfaceView%E7%AE%80%E4%BB%8B.md "2.GLSurfaceView简介""
+[234]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/3.GLSurfaceView%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90.md "3.GLSurfaceView源码解析"
 
 
 
diff --git "a/VideoDevelopment/OpenGL/11.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md" "b/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
similarity index 100%
rename from "VideoDevelopment/OpenGL/11.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
rename to "VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
diff --git "a/VideoDevelopment/OpenGL/12.OpenGL ES\346\273\244\351\225\234.md" "b/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"
similarity index 100%
rename from "VideoDevelopment/OpenGL/12.OpenGL ES\346\273\244\351\225\234.md"
rename to "VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"
diff --git "a/VideoDevelopment/OpenGL/5.GLTextureView\345\256\236\347\216\260.md" "b/VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md"
similarity index 100%
rename from "VideoDevelopment/OpenGL/5.GLTextureView\345\256\236\347\216\260.md"
rename to "VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md"
diff --git "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md" "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"
similarity index 100%
rename from "VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"
rename to "VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"
diff --git "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md" "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"
similarity index 100%
rename from "VideoDevelopment/OpenGL/7.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"
rename to "VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"
diff --git "a/VideoDevelopment/OpenGL/8.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md" "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
similarity index 100%
rename from "VideoDevelopment/OpenGL/8.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
rename to "VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
diff --git "a/VideoDevelopment/OpenGL/9.GLES\347\261\273\345\217\212Matrix\347\261\273.md" "b/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
similarity index 100%
rename from "VideoDevelopment/OpenGL/9.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
rename to "VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
diff --git "a/VideoDevelopment/OpenGL/10.OpenGL ES\347\272\271\347\220\206.md" "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"
similarity index 100%
rename from "VideoDevelopment/OpenGL/10.OpenGL ES\347\272\271\347\220\206.md"
rename to "VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"

From 6067c8cdb654dc3567b46d5a5b637b1c556687fa Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 18 Mar 2020 17:06:28 +0800
Subject: [PATCH 004/213] update

---
 README.md                                     | 32 +++++++++++++------
 .../1.OpenGL\347\256\200\344\273\213.md"      |  6 ++++
 ...55\346\224\276\350\247\206\351\242\221.md" | 30 +++++++++++++++--
 .../11.OpenGL ES\346\273\244\351\225\234.md"  |  8 ++++-
 ....GLSurfaceView\347\256\200\344\273\213.md" | 15 ++++++---
 ...20\347\240\201\350\247\243\346\236\220.md" | 24 +++++++++++++-
 ....GLTextureView\345\256\236\347\216\260.md" | 28 ++++++++++++++--
 ...66\344\270\211\350\247\222\345\275\242.md" | 23 ++++++++++++-
 ...42\345\217\212\345\234\206\345\275\242.md" |  9 +++++-
 ...45\231\250\350\257\255\350\250\200GLSL.md" | 10 +++++-
 ...\261\273\345\217\212Matrix\347\261\273.md" | 11 ++++++-
 .../9.OpenGL ES\347\272\271\347\220\206.md"   |  9 +++++-
 12 files changed, 180 insertions(+), 25 deletions(-)

diff --git a/README.md b/README.md
index f14907ef..9ae58867 100644
--- a/README.md
+++ b/README.md
@@ -66,20 +66,21 @@ Android学习笔记
     - [CDN及PCDN][228]
     - [P2P][229]
     - [播放器性能优化][230]
+    - [MediaExtractor、MediaCodec、MediaMuxer][245]
     - [OpenGL][231]
         - [1.OpenGL简介][232]
         - [2.GLSurfaceView简介][233]
         - [3.GLSurfaceView源码解析][234]
-        - [][]
-        - [][]
-        - [][]
-        - [][]
-        - [][]
-        - [][]
-        - [][]
-        - [][]
-    - [弹幕][]
-        - [][]
+        - [4.GLTextureView实现][235]
+        - [5.OpenGL ES绘制三角形][236]
+        - [6.OpenGL ES绘制矩形及圆形][237]
+        - [7.OpenGL ES着色器语言GLSL][238]
+        - [8.GLES类及Matrix类][239]
+        - [9.OpenGL ES纹理][240]
+        - [10.GLSurfaceView+MediaPlayer播放视频][241]
+        - [11.OpenGL ES滤镜][242]
+    - [弹幕][243]
+        - [Android弹幕实现][244]
 -  [图片加载][45]
     - [Glide简介(上)][25]
     - [Glide简介(下)][26]
@@ -509,6 +510,17 @@ Android学习笔记
 [232]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/1.OpenGL%E7%AE%80%E4%BB%8B.md "1.OpenGL简介"
 [233]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/2.GLSurfaceView%E7%AE%80%E4%BB%8B.md "2.GLSurfaceView简介""
 [234]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/3.GLSurfaceView%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90.md "3.GLSurfaceView源码解析"
+[235]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/4.GLTextureView%E5%AE%9E%E7%8E%B0.md "4.GLTextureView实现.md"
+[236]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/5.OpenGL%20ES%E7%BB%98%E5%88%B6%E4%B8%89%E8%A7%92%E5%BD%A2.md "5.OpenGL ES绘制三角形"
+[237]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/6.OpenGL%20ES%E7%BB%98%E5%88%B6%E7%9F%A9%E5%BD%A2%E5%8F%8A%E5%9C%86%E5%BD%A2.md "6.OpenGL ES绘制矩形及圆形"
+[238]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/7.OpenGL%20ES%E7%9D%80%E8%89%B2%E5%99%A8%E8%AF%AD%E8%A8%80GLSL.md "7.OpenGL ES着色器语言GLSL"
+[239]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/8.GLES%E7%B1%BB%E5%8F%8AMatrix%E7%B1%BB.md "8.GLES类及Matrix类"
+[240]:  "https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/9.OpenGL%20ES%E7%BA%B9%E7%90%86.md" "9.OpenGL ES纹理"
+[241]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md "10.GLSurfaceView+MediaPlayer播放视频"
+[242]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/11.OpenGL%20ES%E6%BB%A4%E9%95%9C.md "11.OpenGL ES滤镜"
+[243]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/Danmaku "弹幕"
+[244]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/Danmaku/Android%E5%BC%B9%E5%B9%95%E5%AE%9E%E7%8E%B0.md "Android弹幕实现"
+[245]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/MediaExtractor%E3%80%81MediaCodec%E3%80%81MediaMuxer.md "MediaExtractor、MediaCodec、MediaMuxer"
 
 
 
diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
index 0c7f6f70..76c0a47f 100644
--- "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -6,6 +6,7 @@ OpenGL(Open Graphics Library开发图形库)是用于渲染2D、3D矢量图形
 
 OpenGL的前身是硅谷图形功能(SGI)公司为其图形工作站开发的IRIS GL,后来因为IRIS GL的移植性不好，所以在其基础上，开发出了OpenGl。OpenGl一般用于在图形工作站，PC端使用，由于性能各方面原因，在移动端使用OpenGl基本带不动。为此，Khronos公司就为OpenGl提供了一个子集，OpenGl ES(OpenGl for Embedded System)。
 
+网上已经有很多文章，这里为什么还要写？主要是因为最近在学的时候发现那些文章看完后还是雨里雾里的不明白。我想写一个简单的，能从入门开始一步步学习的，能简单的学会，文章里面有一些是从下面写的参考链接中拷贝过来的，也有一些是自己从书上看的。
 
 
 ### OpenGL ES
@@ -228,8 +229,13 @@ Android 框架中有如下两个基本类，用于通过 OpenGL ES API 来创建
 
 
 
+   
+[下一篇: 2.GLSurfaceView简介](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/2.GLSurfaceView%E7%AE%80%E4%BB%8B.md)
 
+---
 
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
 
 
 
diff --git "a/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md" "b/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
index b6682af6..2af47100 100644
--- "a/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
+++ "b/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
@@ -1,4 +1,4 @@
-## 9.GLSurfaceView+MediaPlayer播放视频
+## 10.GLSurfaceView+MediaPlayer播放视频
 
 
 
@@ -105,4 +105,30 @@ public class VideoActivity extends Activity {
 
 
 
-### 增加OpenGL ES
\ No newline at end of file
+### 增加OpenGL ES
+
+
+
+
+
+
+
+
+[上一篇: 9.OpenGL ES纹理](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/9.OpenGL%20ES%E7%BA%B9%E7%90%86.md)
+[下一篇: 11.OpenGL ES滤镜](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/11.OpenGL%20ES%E6%BB%A4%E9%95%9C.md)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md" "b/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"
index 026edc95..4a959561 100644
--- "a/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"	
+++ "b/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"	
@@ -1,4 +1,4 @@
-## 10.OpenGL ES滤镜
+## 11.OpenGL ES滤镜
 
 滤镜其实就是利用纹理。
 
@@ -27,6 +27,12 @@ RGB三个通道的颜色取反，而alpha通道不变。
 
 
 
+[上一篇: 10.GLSurfaceView+MediaPlayer播放视频](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
 
 
 
diff --git "a/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
index d3d7b314..aca97c0b 100644
--- "a/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
@@ -36,10 +36,11 @@ GLSurfaceView继承自SurfaceView，它主要是在SurfaceView的基础上加入
 
 OpenGL ES 3.0/3.1 API 软件包        
 
-- ```
-  android.opengl: 此软件包提供了 OpenGL ES 3.0/3.1 类的接口。版本 3.0 从 Android 4.3（API 级别 18）开始可用。版本 3.1 从 Android 5.0（API 级别 21）开始可用。          
-  ```
-
+- 
+  android.opengl: 此软件包提供了 OpenGL ES 3.0/3.1 类的接口。    
+  版本 3.0 从 Android 4.3（API 级别 18）开始可用。   
+  版本 3.1 从 Android 5.0（API 级别 21）开始可用。             
+  
   - `GLES30`
   - `GLES31` 
   - `GLES31Ext` ([Android Extension Pack](https://developer.android.google.cn/guide/topics/graphics/opengl#aep))
@@ -198,7 +199,13 @@ SurfaceTexture对象可以在任何线程上创建。 updateTexImage()只能在
 
 
 
+[上一篇: 1.OpenGL简介](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/1.OpenGL%E7%AE%80%E4%BB%8B.md)        
+[下一篇: 3.GLSurfaceView源码解析](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/3.GLSurfaceView%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90.md)
+
+---
 
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
 
 
 
diff --git "a/VideoDevelopment/OpenGL/3.GLSurfaceView\346\272\220\347\240\201\350\247\243\346\236\220.md" "b/VideoDevelopment/OpenGL/3.GLSurfaceView\346\272\220\347\240\201\350\247\243\346\236\220.md"
index c4c11e8b..e2659c45 100644
--- "a/VideoDevelopment/OpenGL/3.GLSurfaceView\346\272\220\347\240\201\350\247\243\346\236\220.md"
+++ "b/VideoDevelopment/OpenGL/3.GLSurfaceView\346\272\220\347\240\201\350\247\243\346\236\220.md"
@@ -1,4 +1,4 @@
-GLSurfaceView源码解析
+## 3.GLSurfaceView源码解析
 
 我感觉还是先看一下源码，了解一下内部的流程，再接着学习其他的OpenGL部分会更合适。
 
@@ -688,3 +688,25 @@ public interface Renderer {
 
   这个类主要提供的是线程同步控制的功能，因为在GLSurfaceView里面有两个线程: GL线程和调用线程。所以对一些变量必须要进行同步。
 
+
+
+
+[上一篇: 2.GLSurfaceView简介](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/2.GLSurfaceView%E7%AE%80%E4%BB%8B.md)
+[下一篇: 4.GLTextureView实现](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/4.GLTextureView%E5%AE%9E%E7%8E%B0.md)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md" "b/VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md"
index 6f5b93fe..661e256f 100644
--- "a/VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md"
+++ "b/VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md"
@@ -1,4 +1,4 @@
-### GLTextureView
+### 4.GLTextureView
 
 系统提供了GLSurfaceView，确没有提供GLTextureView，但是我们目前的项目灰常复杂庞大，我不想去封一层接口，然后动态去选择使用GLSurfaceView(实现一些纹理效果)或者TextureView(无OpenGL效果)来播放视频。我只想在目前的基础上去扩展，我想去实现一个GLTextureView。上面分析完GLSurfaceView的源码后我们也可以自己去实现GLTextureView的功能了。具体的实现就是和GLSurfaceView的源码一模一样。
 
@@ -1971,4 +1971,28 @@ public class GLTextureView extends TextureView implements TextureView.SurfaceTex
     private int mEGLContextClientVersion;
     private boolean mPreserveEGLContextOnPause;
 }
-```
\ No newline at end of file
+```
+
+
+
+
+
+
+[上一篇: 3.GLSurfaceView源码解析](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/3.GLSurfaceView%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90.md)
+[下一篇: 5.OpenGL ES绘制三角形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/5.OpenGL%20ES%E7%BB%98%E5%88%B6%E4%B8%89%E8%A7%92%E5%BD%A2.md)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md" "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"
index 5532ef7d..e14647ae 100644
--- "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
@@ -1,4 +1,4 @@
-## OpenGL Es绘制三角形
+## 5.OpenGL Es绘制三角形
 
 OpenGL ES的绘制需要有一下步骤:   
 
@@ -861,3 +861,24 @@ class TriangleRender implements GLSurfaceView.Renderer {
 }
 ```
 
+
+
+
+[上一篇: 4.GLTextureView实现](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/4.GLTextureView%E5%AE%9E%E7%8E%B0.md)
+[下一篇: 6.OpenGL ES绘制矩形及圆形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/6.OpenGL%20ES%E7%BB%98%E5%88%B6%E7%9F%A9%E5%BD%A2%E5%8F%8A%E5%9C%86%E5%BD%A2.md)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md" "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"
index 581c449c..3c40dc74 100644
--- "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"	
@@ -1,4 +1,4 @@
-## 5.OpenGL ES绘制矩形及圆形
+## 6.OpenGL ES绘制矩形及圆形
 
 
 
@@ -500,6 +500,13 @@ public class CircularRender implements GLSurfaceView.Renderer {
 ```
 
 
+[上一篇: 5.OpenGL ES绘制三角形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/5.OpenGL%20ES%E7%BB%98%E5%88%B6%E4%B8%89%E8%A7%92%E5%BD%A2.md
+[下一篇: 7.OpenGL ES着色器语言GLSL](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/7.OpenGL%20ES%E7%9D%80%E8%89%B2%E5%99%A8%E8%AF%AD%E8%A8%80GLSL.md)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
 
 
 
diff --git "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md" "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
index a286783e..0dd05b65 100644
--- "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
+++ "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
@@ -1,4 +1,4 @@
-## 6.OpenGL ES着色器语言GLSL
+## 7.OpenGL ES着色器语言GLSL
 
 顶点着色器:  
 
@@ -205,6 +205,14 @@ GLSL的类型转换与C不同。在GLSL中类型不可以自动提升，比如fl
 
 
 
+[上一篇: 6.OpenGL ES绘制矩形及圆形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/6.OpenGL%20ES%E7%BB%98%E5%88%B6%E7%9F%A9%E5%BD%A2%E5%8F%8A%E5%9C%86%E5%BD%A2.md)
+[下一篇: 8.GLES类及Matrix类](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/8.GLES%E7%B1%BB%E5%8F%8AMatrix%E7%B1%BB.md)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
 
 
 
diff --git "a/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md" "b/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
index 72141be7..a8b903a6 100644
--- "a/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
+++ "b/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
@@ -1,4 +1,4 @@
-## 7.GLES类及Matrix类
+## 8.GLES类及Matrix类
 
 
 
@@ -136,6 +136,15 @@ GLES20.glActiveTexture()确定了后续的纹理状态改变影响哪个纹理
 
 
 
+[上一篇: 7.OpenGL ES着色器语言GLSL](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/7.OpenGL%20ES%E7%9D%80%E8%89%B2%E5%99%A8%E8%AF%AD%E8%A8%80GLSL.md)
+[下一篇: 9.OpenGL ES纹理](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/9.OpenGL%20ES%E7%BA%B9%E7%90%86.md)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+
 
 
 
diff --git "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md" "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"
index f7c28838..c712f597 100644
--- "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
+++ "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
@@ -1,4 +1,4 @@
-## OpenGL ES纹理
+## 9.OpenGL ES纹理
 
 
 
@@ -528,6 +528,13 @@ public class TextureHelper {
 
 
 
+[上一篇: 8.GLES类及Matrix类](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/8.GLES%E7%B1%BB%E5%8F%8AMatrix%E7%B1%BB.md)
+[下一篇: 10.GLSurfaceView+MediaPlayer播放视频](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
 
 
 

From b82bcd94c18df151d783f43a680450108f7ecf00 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 18 Mar 2020 17:25:20 +0800
Subject: [PATCH 005/213] update

---
 README.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index 9ae58867..409e491a 100644
--- a/README.md
+++ b/README.md
@@ -506,17 +506,17 @@ Android学习笔记
 [228]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/CDN%E5%8F%8APCDN.md "CDN及PCDN"
 [229]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/P2P.md "P2P"
 [230]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%92%AD%E6%94%BE%E5%99%A8%E6%80%A7%E8%83%BD%E4%BC%98%E5%8C%96.md "播放器性能优化"
-[231]: hhttps://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/OpenGL  "OpenGL"
-[232]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/1.OpenGL%E7%AE%80%E4%BB%8B.md "1.OpenGL简介"
-[233]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/2.GLSurfaceView%E7%AE%80%E4%BB%8B.md "2.GLSurfaceView简介""
+[231]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/OpenGL  "OpenGL"
+[232]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/1.OpenGL%E7%AE%80%E4%BB%8B.md  "1.OpenGL简介"
+[233]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/2.GLSurfaceView%E7%AE%80%E4%BB%8B.md "2.GLSurfaceView简介"
 [234]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/3.GLSurfaceView%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90.md "3.GLSurfaceView源码解析"
-[235]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/4.GLTextureView%E5%AE%9E%E7%8E%B0.md "4.GLTextureView实现.md"
+[235]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/4.GLTextureView%E5%AE%9E%E7%8E%B0.md  "4.GLTextureView实现.md"
 [236]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/5.OpenGL%20ES%E7%BB%98%E5%88%B6%E4%B8%89%E8%A7%92%E5%BD%A2.md "5.OpenGL ES绘制三角形"
 [237]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/6.OpenGL%20ES%E7%BB%98%E5%88%B6%E7%9F%A9%E5%BD%A2%E5%8F%8A%E5%9C%86%E5%BD%A2.md "6.OpenGL ES绘制矩形及圆形"
 [238]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/7.OpenGL%20ES%E7%9D%80%E8%89%B2%E5%99%A8%E8%AF%AD%E8%A8%80GLSL.md "7.OpenGL ES着色器语言GLSL"
 [239]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/8.GLES%E7%B1%BB%E5%8F%8AMatrix%E7%B1%BB.md "8.GLES类及Matrix类"
 [240]:  "https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/9.OpenGL%20ES%E7%BA%B9%E7%90%86.md" "9.OpenGL ES纹理"
-[241]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md "10.GLSurfaceView+MediaPlayer播放视频"
+[241]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md " 10.GLSurfaceView+MediaPlayer播放视频"
 [242]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/11.OpenGL%20ES%E6%BB%A4%E9%95%9C.md "11.OpenGL ES滤镜"
 [243]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/Danmaku "弹幕"
 [244]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/Danmaku/Android%E5%BC%B9%E5%B9%95%E5%AE%9E%E7%8E%B0.md "Android弹幕实现"

From 7ddae18873f0fd5407370550f63c619de7dd82e4 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 18 Mar 2020 19:58:30 +0800
Subject: [PATCH 006/213] update

---
 .../Git\347\256\200\344\273\213.md"           |  1 -
 README.md                                     |  2 +-
 .../1.OpenGL\347\256\200\344\273\213.md"      |  8 +--
 ....GLSurfaceView\347\256\200\344\273\213.md" | 47 ++++++-----------
 ...20\347\240\201\350\247\243\346\236\220.md" | 50 +++++++++----------
 ....GLTextureView\345\256\236\347\216\260.md" |  4 +-
 ...66\344\270\211\350\247\222\345\275\242.md" | 17 +++----
 7 files changed, 55 insertions(+), 74 deletions(-)

diff --git "a/JavaKnowledge/Git\347\256\200\344\273\213.md" "b/JavaKnowledge/Git\347\256\200\344\273\213.md"
index b77fac3c..f98977be 100644
--- "a/JavaKnowledge/Git\347\256\200\344\273\213.md"
+++ "b/JavaKnowledge/Git\347\256\200\344\273\213.md"
@@ -19,7 +19,6 @@ Git简介
     和集中式版本控制系统相比，分布式版本控制系统的安全性要高很多，因为每个人电脑里都有完整的版本库，某一个 人   的电脑坏掉了不要紧，随便从其他人那里复制一个就可以了。而集中式版本控制系统的中央服务器要是出了问题，所有人都没法干活了。    
     在实际使用分布式版本控制系统的时候，其实很少在两人之间的电脑上推送版本库的修改，因为可能你们俩不在一个局域网内，两台电脑互相访问不了，也可能今天你的同事病了，他的电脑压根没有开机。因此，分布式版本控制系统通常也有一台充当“中央服务器”的电脑，但这个服务器的作用仅仅是用来方便“交换”大家的修改，没有它大家也一样干活，只是交换修改不方便而已。          
     ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_fenbu.jpeg)             
-dddd
 
 版本库
 ---
diff --git a/README.md b/README.md
index 409e491a..82ccb40e 100644
--- a/README.md
+++ b/README.md
@@ -515,7 +515,7 @@ Android学习笔记
 [237]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/6.OpenGL%20ES%E7%BB%98%E5%88%B6%E7%9F%A9%E5%BD%A2%E5%8F%8A%E5%9C%86%E5%BD%A2.md "6.OpenGL ES绘制矩形及圆形"
 [238]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/7.OpenGL%20ES%E7%9D%80%E8%89%B2%E5%99%A8%E8%AF%AD%E8%A8%80GLSL.md "7.OpenGL ES着色器语言GLSL"
 [239]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/8.GLES%E7%B1%BB%E5%8F%8AMatrix%E7%B1%BB.md "8.GLES类及Matrix类"
-[240]:  "https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/9.OpenGL%20ES%E7%BA%B9%E7%90%86.md" "9.OpenGL ES纹理"
+[240]:  "https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/9.OpenGL%20ES%E7%BA%B9%E7%90%86.md "9.OpenGL ES纹理"
 [241]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md " 10.GLSurfaceView+MediaPlayer播放视频"
 [242]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/11.OpenGL%20ES%E6%BB%A4%E9%95%9C.md "11.OpenGL ES滤镜"
 [243]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/Danmaku "弹幕"
diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
index 76c0a47f..bbd77b44 100644
--- "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -1,8 +1,8 @@
 ## 1.OpenGL简介
 
-[OpenGL官网]（https://www.opengl.org/）
+[OpenGL官网](https://www.opengl.org/)
 
-OpenGL(Open Graphics Library开发图形库)是用于渲染2D、3D矢量图形的跨语言、跨平台的应用程序编程接口。
+OpenGL(Open Graphics Library开放图形库)是用于渲染2D、3D矢量图形的跨语言、跨平台的应用程序编程接口。
 
 OpenGL的前身是硅谷图形功能(SGI)公司为其图形工作站开发的IRIS GL,后来因为IRIS GL的移植性不好，所以在其基础上，开发出了OpenGl。OpenGl一般用于在图形工作站，PC端使用，由于性能各方面原因，在移动端使用OpenGl基本带不动。为此，Khronos公司就为OpenGl提供了一个子集，OpenGl ES(OpenGl for Embedded System)。
 
@@ -11,7 +11,7 @@ OpenGL的前身是硅谷图形功能(SGI)公司为其图形工作站开发的IRI
 
 ### OpenGL ES
 
-[OpenGL ES 官网]（https://www.khronos.org/opengles/）
+[OpenGL ES 官网](https://www.khronos.org/opengles/)
 
 OpenGL ES是免费的跨平台的功能完善的2D/3D图形库接口的API,是OpenGL的一个子集,主要针对手机、Pad和游戏主机等嵌入式设备而设计。
 
@@ -174,7 +174,7 @@ OpenGL是一个仅仅关注图像渲染的图像接口库，在渲染过程中
 
 EGL为双缓冲工作模式，既有一个Back Frame Buffer和一个Front Frame Buffer，正常绘制的目标都是Back Frame Buffer，绘制完成后再调用eglSwapBuffer API，将绘制完毕的FrameBuffer交换到Front Frame Buffer并显示出来。   
 
-要在Android平台实现OpenGL渲染，需要完成一系列的EGL操作，主要为下面几步:   
+要在Android平台实现OpenGL渲染，需要完成一系列的EGL操作，主要为下面几步(后面分析GLSurfaceView源码的时候也是这样来实现的):   
 
 1. 获取显示设备(EGL Display)
 
diff --git "a/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
index aca97c0b..dab69c89 100644
--- "a/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
@@ -2,9 +2,9 @@
 
 Android 通过其框架 API 和原生开发套件 (NDK) 来支持 OpenGL。
 
-Android 框架中有如下两个基本类，用于通过 OpenGL ES API 来创建和操控图形：`GLSurfaceView` 和 `GLSurfaceView.Renderer`。也就是说我们想在Android中使用OpenGL ES的最简单的方法就是将我们要显示的图像渲染到GLSurfaceView上，但它只是一个展示类，至于怎么渲染到上面我们就要自己去实现GLSurfaceView.Renderer来生成我们自己的渲染器从而完成渲染操作。    
+Android 框架中有如下两个基本类，用于通过 OpenGL ES API 来创建和操控图形：`GLSurfaceView` 和 `GLSurfaceView.Renderer`。也就是说我们想在Android中使用OpenGL ES的最简单的方法就是将我们要显示的图像渲染到GLSurfaceView上，但它只是一个展示类，至于怎么渲染到上面我们就要自己去实现GLSurfaceView.Renderer来生成我们自己的渲染器从而完成渲染操作，这里是不是感觉Android框架提供的类太少了，怎么没有GLTextureView，后面在分析完GLSurfaceView的源码后，可以直接拷贝自己去实现GLTextureView，[有关SurfaceView与TextureView的区别可以看这篇文章](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/SurfaceView%E4%B8%8ETextureView.md)。    
 
-######## GLSurfaceView(使用OpenGL绘制的图形的视图容器)
+### GLSurfaceView(使用OpenGL绘制的图形的视图容器)
 
 SurfaceView在View的基础上创建了独立的Surface，拥有SurfaceHolder来管理它的Surface，渲染的工作可以不再主线程中做。可以通过SurfaceHolder得到Canvas，在单独的线程中，利用Canvas绘制需要显示的内容，然后更新到Surface上。
 
@@ -16,39 +16,28 @@ GLSurfaceView继承自SurfaceView，它主要是在SurfaceView的基础上加入
 - onPause:暂停渲染，最好在Activity、Fragment的onPause方法内调用，减少不必要的性能开销，避免不必要的崩溃
 - onResume:恢复渲染
 - setRender:设置渲染器
-- setRenderMode:设置渲染模式
+- setRenderMode:设置渲染模式，有连续渲染和按需渲染两种模式，按需渲染需要调用下面的requestRender方法才会去渲染
 - requestRender:请求渲染，请求异步线程进行渲染，调用后不会立即进行渲染。渲染会回调到Renderer接口的onDrawFrame()方法
 - queueEvent:插入一个Runnable任务到后台渲染线程上执行。相应的，渲染线程中可以通过Activity的runOnUIThread的方法来传递事件给主线程去执行
 
 #### GLSurfaceView.Renderer(可控制该视图中绘制的图形)
 
-此接口定义了在 `GLSurfaceView` 中绘制图形所需的方法。您必须将此接口的一个实现作为单独的类提供，并使用 `GLSurfaceView.setRenderer()` 将其附加到您的 `GLSurfaceView` 实例。         
+此接口定义了在GLSurfaceView中绘制图形所需的方法。您必须将此接口的一个实现作为单独的类提供，并使用GLSurfaceView.setRenderer()将其附加到您的GLSurfaceView实例。         
 
-`GLSurfaceView.Renderer` 接口要求您实现以下方法: 
+GLSurfaceView.Renderer接口要求您实现以下方法:     
+- onSurfaceCreated():系统会在创建GLSurface时调用一次此方法。使用此方法可执行仅需发生一次的操作，例如设置OpenGL环境参数或初始化OpenGL图形对象。          
+- onDrawFrame():完成绘制工作，每一帧图像的渲染都要在这里完成，系统会在每次重新绘制GLSurfaceView时调用此方法。请将此方法作为绘制（和重新绘制）图形对象的主要执行点。
+- onSurfaceChanged():系统会在GLSurfaceView几何图形发生变化（包括GLSurfaceView大小发生变化或设备屏幕方向发生变化）时调用此方法。例如，系统会在设备屏幕方向由纵向变为横向时调用此方法。使用此方法可响应GLSurfaceView容器中的更改。          
 
-- `onSurfaceCreated()`：系统会在创建 `GLSurfaceView` 时调用一次此方法。使用此方法可执行仅需发生一次的操作，例如设置 OpenGL 环境参数或初始化 OpenGL 图形对象。          
-- `onDrawFrame()`：完成绘制工作，每一帧图像的渲染都要在这里完成，系统会在每次重新绘制 `GLSurfaceView` 时调用此方法。请将此方法作为绘制（和重新绘制）图形对象的主要执行点。
-- `onSurfaceChanged()`：系统会在 `GLSurfaceView` 几何图形发生变化（包括 `GLSurfaceView` 大小发生变化或设备屏幕方向发生变化）时调用此方法。例如，系统会在设备屏幕方向由纵向变为横向时调用此方法。使用此方法可响应 `GLSurfaceView` 容器中的更改。          
+使用GLSurfaceView和GLSurfaceView.Renderer为OpenGL ES建立容器视图后，您便可以开始使用以下类调用 OpenGL API：
 
-
-
-使用 `GLSurfaceView` 和 `GLSurfaceView.Renderer` 为 OpenGL ES 建立容器视图后，您便可以开始使用以下类调用 OpenGL API：
-
-OpenGL ES 3.0/3.1 API 软件包        
-
-- 
-  android.opengl: 此软件包提供了 OpenGL ES 3.0/3.1 类的接口。    
-  版本 3.0 从 Android 4.3（API 级别 18）开始可用。   
-  版本 3.1 从 Android 5.0（API 级别 21）开始可用。             
-  
+OpenGL ES 3.0/3.1 API 软件包:   
+- android.opengl: 此软件包提供了 OpenGL ES 3.0/3.1 类的接口。    
   - `GLES30`
   - `GLES31` 
   - `GLES31Ext` ([Android Extension Pack](https://developer.android.google.cn/guide/topics/graphics/opengl#aep))
 
-
-
-[SurfaceView与TextureView](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/SurfaceView%E4%B8%8ETextureView.md)
-
+### GLSurfaceView类
 ```java
 package android.opengl;
 /**
@@ -60,13 +49,9 @@ package android.opengl;
 
 ```
 
-GPU加速：GLSurfaceView的效率是SurfaceView的30倍以上，SurfaceView使用画布进行绘制，GLSurfaceView利用GPU加速提高了绘制效率。
-View的绘制onDraw(Canvas canvas)使用Skia渲染引擎渲染，而GLSurfaceView的渲染器Renderer的onDrawFrame(GL10 gl)使用opengl绘制引擎进行渲染。
-
-
+GPU加速：GLSurfaceView的效率是SurfaceView的30倍以上，SurfaceView使用画布进行绘制，GLSurfaceView利用GPU加速提高了绘制效率。View的绘制onDraw(Canvas canvas)使用Skia渲染引擎渲染，而GLSurfaceView的渲染器Renderer的onDrawFrame(GL10 gl)使用OpenGL绘制引擎进行渲染。  
 
 GLSurfaceView的特性:    
-
 - 管理一个surface，这个surface就是一块特殊的内存，能直接排版到android的视图view上。
 - 管理一个EGL Display，它能让OpenGL把内容渲染到surface上
 - 用户自定义渲染器render
@@ -82,13 +67,13 @@ GLSurfaceView的特性:
 
 首选现在AndroidManifest.xml文件中声明使用OpenGL ES的版本： 
 
-```
+```xml
 <uses-feature android:glEsVersion="0x00030000" android:required="true" />
 ```
 
 
 
-```
+```java
 public class MainActivity extends AppCompatActivity {
     private GLSurfaceView mGlSurfaceView;
 
@@ -140,7 +125,7 @@ Render接口重写的三个方法中调用了GLES31的API方法:
 
 #### RenderMode
 
-GLSurfaceView默认采用的是RENDERMODE_CONTINUOUSLY连续渲染的方式，刷新的帧率是60FPS，16ms就重绘一次，可以通过mGLView.setRenderMode()更改其渲染方式为RENDERMODE_WHEN_DIRTY，表示被动渲染，在surfaceCreate的时候会绘制一次，之后只有在调用requestRender或者onResume等方法主动请求重绘时才会进行渲染，如果你的界面不需要频繁的刷新最好使用RENDERMODE_WHEN_DIRTY，这样可以降低CPU和GPU的活动。
+GLSurfaceView默认采用的是RENDERMODE_CONTINUOUSLY连续渲染的方式，刷新的帧率是60FPS，16ms就重绘一次，可以通过mGLView.setRenderMode()更改其渲染方式为RENDERMODE_WHEN_DIRTY，表示按需渲染，在surfaceCreate的时候会绘制一次，之后只有在调用requestRender或者onResume等方法主动请求重绘时才会进行渲染，如果你的界面不需要频繁的刷新最好使用RENDERMODE_WHEN_DIRTY，这样可以降低CPU和GPU的活动。
 
 #### 状态处理
 
diff --git "a/VideoDevelopment/OpenGL/3.GLSurfaceView\346\272\220\347\240\201\350\247\243\346\236\220.md" "b/VideoDevelopment/OpenGL/3.GLSurfaceView\346\272\220\347\240\201\350\247\243\346\236\220.md"
index e2659c45..d9cbc25a 100644
--- "a/VideoDevelopment/OpenGL/3.GLSurfaceView\346\272\220\347\240\201\350\247\243\346\236\220.md"
+++ "b/VideoDevelopment/OpenGL/3.GLSurfaceView\346\272\220\347\240\201\350\247\243\346\236\220.md"
@@ -8,11 +8,11 @@
 
 ```java
 public interface Renderer {
-		// surface创建的回调
+    // surface创建的回调
     void onSurfaceCreated(GL10 gl, EGLConfig config);
-		// surface大小改变的回调
+    // surface大小改变的回调
     void onSurfaceChanged(GL10 gl, int width, int height);
-		// 开始绘制每一帧的回调
+    // 开始绘制每一帧的回调
     void onDrawFrame(GL10 gl);
 }
 ```
@@ -20,26 +20,26 @@ public interface Renderer {
 - setRenderer()方法
 
 ```java
-   public void setRenderer(Renderer renderer) {
-     		// 保证setRenderer方法只能被调用一次
-        checkRenderThreadState();
-        if (mEGLConfigChooser == null) {
-            // 设置EGLConfgi，如果不设置就用默认的一个RGB_888的Surface选择器
-            mEGLConfigChooser = new SimpleEGLConfigChooser(true);
-        }
-        if (mEGLContextFactory == null) {
-          	// 设置EGLContext工厂，如果不设置就用默认的EGLContext的工厂类，用他来创建EGLContext
-            mEGLContextFactory = new DefaultContextFactory();
-        }
-        if (mEGLWindowSurfaceFactory == null) {
-            // 设置EGLSurface工厂，如果不设置就用默认的EGLSurface的工厂类，我们可以通过这个方法来设置让图像渲染到其他地方的surface上，例如textureview上
-            mEGLWindowSurfaceFactory = new DefaultWindowSurfaceFactory();
-        }
-        mRenderer = renderer;
-        // 创建并开启GLThread,GL线程
-        mGLThread = new GLThread(mThisWeakRef);
-        mGLThread.start();
-    }
+public void setRenderer(Renderer renderer) {
+  // 保证setRenderer方法只能被调用一次
+  checkRenderThreadState();
+  if (mEGLConfigChooser == null) {
+      // 设置EGLConfgi，如果不设置就用默认的一个RGB_888的Surface选择器
+      mEGLConfigChooser = new SimpleEGLConfigChooser(true);
+  }
+  if (mEGLContextFactory == null) {
+    	// 设置EGLContext工厂，如果不设置就用默认的EGLContext的工厂类，用他来创建EGLContext
+      mEGLContextFactory = new DefaultContextFactory();
+  }
+  if (mEGLWindowSurfaceFactory == null) {
+      // 设置EGLSurface工厂，如果不设置就用默认的EGLSurface的工厂类，我们可以通过这个方法来设置让图像渲染到其他地方的surface上，例如textureview上
+      mEGLWindowSurfaceFactory = new DefaultWindowSurfaceFactory();
+  }
+  mRenderer = renderer;
+  // 创建并开启GLThread,GL线程
+  mGLThread = new GLThread(mThisWeakRef);
+  mGLThread.start();
+}
 ```
 
 - 接下来看一下GLThread的线程的实现，GLThread是GLSurfaceView自带的一个渲染线程，同步的，不会阻塞线程，主要用来执行OpenGL的绘制工作:
@@ -50,7 +50,7 @@ public interface Renderer {
               super();
               mWidth = 0;
               mHeight = 0;
-            	// 主动渲染模式下是true，如果是被动渲染模式就为false，然后通过requesetRender()方法来修改它的值
+            	// 连续渲染模式下是true，如果是按需渲染模式就为false，然后通过requesetRender()方法来修改它的值
               mRequestRender = true;
               // 默认的渲染模式
               mRenderMode = RENDERMODE_CONTINUOUSLY;
@@ -691,7 +691,7 @@ public interface Renderer {
 
 
 
-[上一篇: 2.GLSurfaceView简介](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/2.GLSurfaceView%E7%AE%80%E4%BB%8B.md)
+[上一篇: 2.GLSurfaceView简介](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/2.GLSurfaceView%E7%AE%80%E4%BB%8B.md)       
 [下一篇: 4.GLTextureView实现](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/4.GLTextureView%E5%AE%9E%E7%8E%B0.md)
 
 ---
diff --git "a/VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md" "b/VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md"
index 661e256f..195b9e83 100644
--- "a/VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md"
+++ "b/VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md"
@@ -1,4 +1,4 @@
-### 4.GLTextureView
+### 4.GLTextureView实现
 
 系统提供了GLSurfaceView，确没有提供GLTextureView，但是我们目前的项目灰常复杂庞大，我不想去封一层接口，然后动态去选择使用GLSurfaceView(实现一些纹理效果)或者TextureView(无OpenGL效果)来播放视频。我只想在目前的基础上去扩展，我想去实现一个GLTextureView。上面分析完GLSurfaceView的源码后我们也可以自己去实现GLTextureView的功能了。具体的实现就是和GLSurfaceView的源码一模一样。
 
@@ -1978,7 +1978,7 @@ public class GLTextureView extends TextureView implements TextureView.SurfaceTex
 
 
 
-[上一篇: 3.GLSurfaceView源码解析](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/3.GLSurfaceView%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90.md)
+[上一篇: 3.GLSurfaceView源码解析](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/3.GLSurfaceView%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90.md)     
 [下一篇: 5.OpenGL ES绘制三角形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/5.OpenGL%20ES%E7%BB%98%E5%88%B6%E4%B8%89%E8%A7%92%E5%BD%A2.md)
 
 ---
diff --git "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md" "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"
index e14647ae..dc8c01dd 100644
--- "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
@@ -1,6 +1,6 @@
-## 5.OpenGL Es绘制三角形
+## 5.OpenGL ES绘制三角形
 
-OpenGL ES的绘制需要有一下步骤:   
+OpenGL ES的绘制需要有以下步骤:   
 
 - 顶点输入
 
@@ -20,9 +20,9 @@ OpenGL ES的绘制需要有一下步骤:
 
   每个着色器都起始于一个版本声明。OpenGL 3.3以及和更高版本中，GLSL版本号和OpenGL的版本是匹配的（比如说GLSL 420版本对应于OpenGL 4.2）。我们同样明确表示我们会使用核心模式。
 
-  下一步，使用`in`关键字，在顶点着色器中声明所有的输入顶点属性(Input Vertex Attribute)。现在我们只关心位置(Position)数据，所以我们只需要一个顶点属性。GLSL有一个向量数据类型，它包含1到4个`float`分量，包含的数量可以从它的后缀数字看出来。由于每个顶点都有一个3D坐标，我们就创建一个`vec3`输入变量position。我们同样也通过`layout (location = 0)`设定了输入变量的位置值(Location)你后面会看到为什么我们会需要这个位置值。
+  下一步，使用in关键字，在顶点着色器中声明所有的输入顶点属性(Input Vertex Attribute)。现在我们只关心位置(Position)数据，所以我们只需要一个顶点属性。GLSL有一个向量数据类型，它包含1到4个float分量，包含的数量可以从它的后缀数字看出来。由于每个顶点都有一个3D坐标，我们就创建一个vec3输入变量position。我们同样也通过layout (location = 0)设定了输入变量的位置值(Location)你后面会看到为什么我们会需要这个位置值。
 
-  为了设置顶点着色器的输出，我们必须把位置数据赋值给预定义的gl_Position变量，它在幕后是`vec4`类型的。在main函数的最后，我们将gl_Position设置的值会成为该顶点着色器的输出。由于我们的输入是一个3分量的向量，我们必须把它转换为4分量的。我们可以把`vec3`的数据作为`vec4`构造器的参数，同时把`w`分量设置为`1.0f`（我们会在后面解释为什么）来完成这一任务。
+  为了设置顶点着色器的输出，我们必须把位置数据赋值给预定义的gl_Position变量，它在幕后是vec4类型的。在main函数的最后，我们将gl_Position设置的值会成为该顶点着色器的输出。由于我们的输入是一个3分量的向量，我们必须把它转换为4分量的。我们可以把vec3的数据作为vec4构造器的参数，同时把w分量设置为1.0f（我们会在后面解释为什么）来完成这一任务。
 
 - 编译着色器
 
@@ -34,16 +34,13 @@ OpenGL ES的绘制需要有一下步骤:
 
   ```glsl
   #version 330 core
-  
   out vec4 color;
-  
-  void main()
-  {
+  void main() {
       color = vec4(1.0f, 0.5f, 0.2f, 1.0f);
   }
   ```
 
-  片段着色器只需要一个输出变量，这个变量是一个4分量向量，它表示的是最终的输出颜色，我们应该自己将其计算出来。我们可以用`out`关键字声明输出变量，这里我们命名为color。下面，我们将一个alpha值为1.0(1.0代表完全不透明)的橘黄色的`vec4`赋值给颜色输出。之后也是需要编译着色器。
+  片段着色器只需要一个输出变量，这个变量是一个4分量向量，它表示的是最终的输出颜色，我们应该自己将其计算出来。我们可以用out关键字声明输出变量，这里我们命名为color。下面，我们将一个alpha值为1.0(1.0代表完全不透明)的橘黄色的vec4赋值给颜色输出。之后也是需要编译着色器。
 
 - 着色器程序(Shader Program Object)
 
@@ -61,7 +58,7 @@ OpenGL ES的绘制需要有一下步骤:
 
 - 链接顶点属性
 
-  顶点着色器允许我们指定任何以顶点属性为形式的输入。这使其具有很强的灵活性的同时，它还的确意味着我们必须手动指定输入数据的哪一个部分对应顶点着色器的哪一个顶点属性。所以，我们必须在渲染前指定OpenGL该如何解释顶点数据。
+  顶点着色器允许我们指定任何以顶点属性为形式的输入。这使其具有很强的灵活性的同时，它还意味着我们必须手动指定输入数据的哪一个部分对应顶点着色器的哪一个顶点属性。所以，我们必须在渲染前指定OpenGL该如何解释顶点数据。
 
   我们的顶点缓冲数据会被解析成下面的样子:  
 

From 973889f433aec163654e36fa4b13f19c0d07112f Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 19 Mar 2020 21:37:25 +0800
Subject: [PATCH 007/213] update

---
 .../1.OpenGL\347\256\200\344\273\213.md"      | 13 +--
 ...55\346\224\276\350\247\206\351\242\221.md" |  2 +-
 .../11.OpenGL ES\346\273\244\351\225\234.md"  |  2 +-
 ...66\344\270\211\350\247\222\345\275\242.md" | 22 +++--
 ...42\345\217\212\345\234\206\345\275\242.md" |  2 +-
 ...45\231\250\350\257\255\350\250\200GLSL.md" | 61 +++++++-----
 ...\261\273\345\217\212Matrix\347\261\273.md" | 97 ++++++++++++++++++-
 .../9.OpenGL ES\347\272\271\347\220\206.md"   | 26 ++++-
 8 files changed, 178 insertions(+), 47 deletions(-)

diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
index bbd77b44..3dc28da4 100644
--- "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -53,7 +53,9 @@ OpenGL ES 3.0兼容了2.0，并丰富了更多功能。
 
 OpenGL渲染管线的流程为: 顶点数据 -> 顶点着色器 -> 图元装配 -> 几何着色器 -> 光栅化 -> 片段着色器 -> 逐片段处理 -> 帧缓冲   
 
-如下图，阴影的表示OpenGL ES 3.0管线中可编程阶段。
+OpenGL ES 3.0实现了具有可编程着色功能的图形管线，有两个规范组成:OpenGL ES3.0 API规范和OpenGL ES着色语言3.0规范(OpenGL ES SL)。
+
+如下图，展示了OpenGL ES 3.0的图形管线。阴影的表示OpenGL ES 3.0管线中可编程阶段。
 
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/oepngl_es_pip.jpg)
 
@@ -65,7 +67,6 @@ OpenGL渲染管线的流程为: 顶点数据 -> 顶点着色器 -> 图元装配
 
    着色器(shader)是在GPU上运行的小程序。从名称可以看出，可通过处理它们来处理顶点。此程序使用OpenGL ES SL语言来编写。它是一个描述顶点或像素特性的简单程序。OpenGL最本质的概念之一就是着色器，它是图形硬件设备所执行的一类特殊函数。理解着色器最好的办法就是把它看做是专为图形处理单元(即GPU)编译的一种小型程序。任何一种OpenGL程序本质上都可以被分为两部分：CPU端运行的部分，采用C++、Java之类的语言编写；以及GPU端运行的部分，使用GLSL语言编写。
 
-  顶点着色器可以操作的属性有: 位置、颜色、纹理坐标，但是不能创建新的顶点。最终产生纹理坐标、颜色、点位置等信息送往后续阶段。
 
 - 图元装配(Primitive Assembly)
 
@@ -170,6 +171,8 @@ OpenGL是一个仅仅关注图像渲染的图像接口库，在渲染过程中
 
 ### EGL
 
+OpenGL ES API没有提及如何创建渲染上下文，或者渲染上下文如何连接到原生窗口系统。EGL是Khronos渲染API(如OpenGL ES)和原生窗口系统之间的接口。
+
 在OpenGL的设计中，OpenGL是不负责管理窗口的，窗口的管理交由各个设备自己完成。具体的来说就是iOS平台上使用EAGL提供本地平台对OpenGL的实现，在Android平台上使用EGL提供本地平台对OpenGL的实现。OpenGL其实是通过GPU进行渲染。但是我们的程序是运行在CPU上，要与GPU关联，这就需要通过EGL，它相当于Android上层应用于GPU通讯的中间层。
 
 EGL为双缓冲工作模式，既有一个Back Frame Buffer和一个Front Frame Buffer，正常绘制的目标都是Back Frame Buffer，绘制完成后再调用eglSwapBuffer API，将绘制完毕的FrameBuffer交换到Front Frame Buffer并显示出来。   
@@ -200,9 +203,7 @@ EGL为双缓冲工作模式，既有一个Back Frame Buffer和一个Front Frame
 
    eglMakeCurrent(EGLDisplay display, EGLSurface draw, EGLSurface read, EGLContext context);该方法的参数意义很明确，该方法在异步线程中被调用，该线程也会被成为GL线程，一旦设定后，所有OpenGL渲染相关的操作都必须放在该线程中执行。
 
-   通过上述操作，就完成了EGL的初始化设置，便可以进行OpenGL的渲染操作。
-
-
+通过上述操作，就完成了EGL的初始化设置，便可以进行OpenGL的渲染操作。所有EGL命令都是以egl前缀开始，对组成命令名的每个单词使用首字母大写(如eglCreateWindowSurface)。
 
 #### OpenGL纹理
 
@@ -229,7 +230,7 @@ Android 框架中有如下两个基本类，用于通过 OpenGL ES API 来创建
 
 
 
-   
+
 [下一篇: 2.GLSurfaceView简介](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/2.GLSurfaceView%E7%AE%80%E4%BB%8B.md)
 
 ---
diff --git "a/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md" "b/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
index 2af47100..6c845636 100644
--- "a/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
+++ "b/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
@@ -114,7 +114,7 @@ public class VideoActivity extends Activity {
 
 
 
-[上一篇: 9.OpenGL ES纹理](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/9.OpenGL%20ES%E7%BA%B9%E7%90%86.md)
+[上一篇: 9.OpenGL ES纹理](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/9.OpenGL%20ES%E7%BA%B9%E7%90%86.md)        
 [下一篇: 11.OpenGL ES滤镜](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/11.OpenGL%20ES%E6%BB%A4%E9%95%9C.md)
 
 ---
diff --git "a/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md" "b/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"
index 4a959561..dc1cc40d 100644
--- "a/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"	
+++ "b/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"	
@@ -27,7 +27,7 @@ RGB三个通道的颜色取反，而alpha通道不变。
 
 
 
-[上一篇: 10.GLSurfaceView+MediaPlayer播放视频](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md)
+[上一篇: 10.GLSurfaceView+MediaPlayer播放视频](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md)   
 
 ---
 
diff --git "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md" "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"
index dc8c01dd..7b859d6d 100644
--- "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
@@ -9,7 +9,7 @@ OpenGL ES的绘制需要有以下步骤:
 - 顶点着色器
 
   ```glsl
-  #version 330 core
+  #version 300 core
   layout (location = 0) in vec3 position;
   
   void main()
@@ -22,7 +22,9 @@ OpenGL ES的绘制需要有以下步骤:
 
   下一步，使用in关键字，在顶点着色器中声明所有的输入顶点属性(Input Vertex Attribute)。现在我们只关心位置(Position)数据，所以我们只需要一个顶点属性。GLSL有一个向量数据类型，它包含1到4个float分量，包含的数量可以从它的后缀数字看出来。由于每个顶点都有一个3D坐标，我们就创建一个vec3输入变量position。我们同样也通过layout (location = 0)设定了输入变量的位置值(Location)你后面会看到为什么我们会需要这个位置值。
 
-  为了设置顶点着色器的输出，我们必须把位置数据赋值给预定义的gl_Position变量，它在幕后是vec4类型的。在main函数的最后，我们将gl_Position设置的值会成为该顶点着色器的输出。由于我们的输入是一个3分量的向量，我们必须把它转换为4分量的。我们可以把vec3的数据作为vec4构造器的参数，同时把w分量设置为1.0f（我们会在后面解释为什么）来完成这一任务。
+  为了设置顶点着色器的输出，我们必须把位置数据赋值给预定义的gl_Position变量，它在幕后是vec4类型的。在main函数中只是将position的值转换后赋值给gl_Position。由于我们的输入是一个3分量的向量，我们必须把它转换为4分量的。我们可以把vec3的数据作为vec4构造器的参数，同时把w分量设置为1.0f（我们会在后面解释为什么）来完成这一任务。
+
+  这个position的值是哪里进行赋值的呢？ 是通过后面java代码中的draw函数来进行赋值的。每个顶点着色器都必须在gl_Position变量中输出一个位置。这个变量定义传递给管线下一个阶段的位置。
 
 - 编译着色器
 
@@ -33,14 +35,14 @@ OpenGL ES的绘制需要有以下步骤:
   片断着色器全是关于计算你的像素最后的颜色输出。颜色使用RGBA。
 
   ```glsl
-  #version 330 core
+  #version 300 core
   out vec4 color;
   void main() {
       color = vec4(1.0f, 0.5f, 0.2f, 1.0f);
   }
   ```
 
-  片段着色器只需要一个输出变量，这个变量是一个4分量向量，它表示的是最终的输出颜色，我们应该自己将其计算出来。我们可以用out关键字声明输出变量，这里我们命名为color。下面，我们将一个alpha值为1.0(1.0代表完全不透明)的橘黄色的vec4赋值给颜色输出。之后也是需要编译着色器。
+  片段着色器只需要一个输出变量，这个变量是一个4分量向量，它表示的是最终的输出颜色，我们应该自己将其计算出来。我们可以用out关键字声明输出变量，这里我们命名为color。下面，我们将一个alpha值为1.0(1.0代表完全不透明)的橘黄色的vec4赋值给颜色输出。之后也是需要编译着色器。片段着色器声明的这个输出变量color的值会被输出到颜色缓冲区。，然后颜色缓冲区再通过EGL窗口显示。
 
 - 着色器程序(Shader Program Object)
 
@@ -54,7 +56,7 @@ OpenGL ES的绘制需要有以下步骤:
   glLinkProgram(shaderProgram);
   ```
 
-  链接完后需要使用glUseProgram方法，用刚创建的程序对象作为参数，以激活这个程序对象。
+  链接完后需要使用glUseProgram方法，用刚创建的程序对象作为参数，以激活这个程序对象。调用glUserProgram方法后，所有后续的渲染将用连接到这个程序对象的顶点和片段着色器进行。
 
 - 链接顶点属性
 
@@ -84,12 +86,13 @@ OpenGL ES的绘制需要有以下步骤:
 
 下面需要实现GLSurfaceView.Render接口，实现要绘制的部分:   
 
+- 用EGL创建屏幕上的渲染表面(GLSurfaceView内部实现)
 - 写顶点着色器和片段着色器文件。
 - 加载编译顶点着色器和片段着色器。
 - 确定需要绘制图形的坐标和颜色数据。
 - 创建program对象，连接顶点和片断着色器，将坐标数据、颜色数据传到OpenGL ES程序中。]
 - 设置视图窗口(viewport)。
-- 使颜色缓冲区的内容显示到屏幕上。
+- 使颜色缓冲区的内容显示到EGL窗口上。
 
 
 
@@ -252,7 +255,7 @@ class MyGLRenderer implements GLSurfaceView.Renderer {
     }
     public void onDrawFrame(GL10 unused) {
         /**********6.绘制************/
-        //把颜色缓冲区设置为我们预设的颜色
+        //把颜色缓冲区设置为我们预设的颜色，绘图设计到多种缓冲区类型:颜色、深度和模板。这里只是向颜色缓冲区中绘制图形
         GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT);
 
         //绑定vertex坐标数据，告诉OpenGL可以在缓冲区vertextBuffer中获取数据
@@ -262,7 +265,7 @@ class MyGLRenderer implements GLSurfaceView.Renderer {
 
         //准备颜色数据
         /**
-         * glVertexAttribPointer()方法的参数分别为: 
+         * glVertexAttribPointer()方法的参数上面的也说过了，这里再按照这个场景说一下分别为: 
          * index：顶点属性的索引.（这里我们的顶点位置和颜色向量在着色器中分别为0和1）layout (location = 0) in vec4 vPosition; layout (location = 1) in vec4 aColor;
          * size: 指定每个通用顶点属性的元素个数。必须是1、2、3、4。此外，glvertexattribpointer接受符号常量gl_bgra。初始值为4（也就是涉及颜色的时候必为4）。
          * type：属性的元素类型。（上面都是Float所以使用GLES30.GL_FLOAT）；
@@ -860,8 +863,7 @@ class TriangleRender implements GLSurfaceView.Renderer {
 
 
 
-
-[上一篇: 4.GLTextureView实现](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/4.GLTextureView%E5%AE%9E%E7%8E%B0.md)
+[上一篇: 4.GLTextureView实现](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/4.GLTextureView%E5%AE%9E%E7%8E%B0.md)        
 [下一篇: 6.OpenGL ES绘制矩形及圆形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/6.OpenGL%20ES%E7%BB%98%E5%88%B6%E7%9F%A9%E5%BD%A2%E5%8F%8A%E5%9C%86%E5%BD%A2.md)
 
 ---
diff --git "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md" "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"
index 3c40dc74..be35d31c 100644
--- "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"	
@@ -500,7 +500,7 @@ public class CircularRender implements GLSurfaceView.Renderer {
 ```
 
 
-[上一篇: 5.OpenGL ES绘制三角形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/5.OpenGL%20ES%E7%BB%98%E5%88%B6%E4%B8%89%E8%A7%92%E5%BD%A2.md
+[上一篇: 5.OpenGL ES绘制三角形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/5.OpenGL%20ES%E7%BB%98%E5%88%B6%E4%B8%89%E8%A7%92%E5%BD%A2.md)      
 [下一篇: 7.OpenGL ES着色器语言GLSL](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/7.OpenGL%20ES%E7%9D%80%E8%89%B2%E5%99%A8%E8%AF%AD%E8%A8%80GLSL.md)
 
 ---
diff --git "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md" "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
index 0dd05b65..45549a14 100644
--- "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
+++ "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
@@ -1,6 +1,6 @@
 ## 7.OpenGL ES着色器语言GLSL
 
-顶点着色器:  
+### 顶点着色器:  
 
 ```
 #version 330 core
@@ -15,7 +15,24 @@ void main()
 }
 ```
 
-片段着色器:  
+顶点着色器的输入包括:  
+
+- 属性:用顶点数组提供的逐顶点数据
+- 统一变量和统一变量缓冲区:顶点着色器使用的不变数据
+- 采样器:代表顶点着色器使用的纹理的特殊统一变量类型
+- 着色器程序:顶点着色器程序源代码或者描述在操作顶点的可执行文件
+
+顶点着色器的输出称作顶点着色器输出变量。在图元光栅化阶段，为每个生成的片段计算这些变量，并作为片段着色器的输入传入。
+
+内建变量包括:  
+
+- gl_VertexID: 一个输入变量，用于保存顶点的整数索引。
+- gl_InstanceID:一个输入变量，用于保存实例化绘图调用中图元的实例编号。
+- gl_Position:用于输出顶点位置的裁剪坐标。
+- gl_PointSize:用于写入以像素标示的点尺寸。
+- gl_FrontFacing:一个特殊变量，但不是由顶点着色器直接写入的，而是根据顶点着色器生成的位置值和渲染的图元类型生成的。
+
+### 片段着色器:  
 
 ```
 #version 330 core
@@ -29,7 +46,16 @@ void main()
 }
 ```
 
+片段着色器为片段操作提供了通用功能的可编程方法。片段着色器的输入由以下部分组成:    
 
+- 输入(或者可变值):顶点着色器生成的插值数据。顶点着色器输出跨图元进行插值，并作为输入传递给片段着色器。
+- 统一变量:片段着色器使用的状态，这些常量值在每个片段上不会变化。
+- 采样器:用于访问着色器中的纹理图像。
+- 代码:片段着色器源代码或者二进制代码，描述在片段上执行的操作。
+
+片段着色器的输出是一个或者多个片段颜色，传递到管线的逐片段操作部分。
+
+内建变量: gl_FragCoord:片段着色器中的一个只读变量。这个变量保存片段的窗口相对坐标。
 
 ### GLSL的特点
 
@@ -81,9 +107,9 @@ GLSL中的数据类型主要分为标量、向量、矩阵、采样器、结构
 ###  变量修饰符 
 
 - none：(默认的可省略)本地变量，可读可写，函数的输入参数既是这种类型
-- const：声明变量或函数的参数为只读类型
-- attribute：用于保存顶点或法线数据,它可以在数据缓冲区中读取数据，仅能用于顶点着色器
-- uniform：在运行时 shader 无法改变 uniform 变量，一般用来放置程序传递给 shader 的变换矩阵，材质，光照参数等等，可用于顶点着色器和片元着色器
+- const：常量
+- attribute：一般用于各个顶点各不相同的量。如顶点颜色、坐标等。用于保存顶点或法线数据,它可以在数据缓冲区中读取数据，仅能用于顶点着色器
+- uniform：统一变量。统一变量存储应用程序通过OpenGL ES API传入着色器的只读值。在运行时 shader 无法改变 uniform 变量，一般用来放置程序传递给 shader 的变换矩阵，材质，光照参数等等，可用于顶点着色器和片元着色器。如果统一变量在顶点着色器和片段着色器中均有声明，则声明的类型必须相同，且两个着色器中的值也需要相同。
 - varying：易变量，用于修饰从顶点着色器向片元着色器传递的变量。一般是在光栅化图元的过程中计算生成，记录在每个片段中(而不是从顶点着色器直接传递给片元着色器)
 
 
@@ -98,26 +124,17 @@ GLSL中的数据类型主要分为标量、向量、矩阵、采样器、结构
 
 GLSL的类型转换与C不同。在GLSL中类型不可以自动提升，比如float a=1;就是一种错误的写法，必须严格的写成float a=1.0，也不可以强制转换，即float a=(float)1;也是错误的写法，但是可以用内置函数来进行转换，如float a=float(1);还有float a=float(true);（true为1.0，false为0.0）等，值得注意的是，低精度的int不能转换为低精度的float
 
-### 限定符
-
-与Java中的限定符类似，放在变量类型前面，并且只能用于全局变量。
-
-- attritude：一般用于各个顶点各不相同的量。如顶点颜色、坐标等。
-- uniform：一般用于对于3D物体中所有顶点都相同的量。比如光源位置，统一变换矩阵等。
-- varying：表示易变量，一般用于顶点着色器传递到片元着色器的量。
-- const：常量。
-
-- 流程控制
+### 流程控制
 
-  常用的与java基本一样
+常用的与java基本一样
 
-- 函数
+### 函数
 
-  定义函数的方式也与C语言基本相同。函数的返回值可以是GLSL中的除了采样器的任意类型。对于GLSL中函数的参数，可以用参数用途修饰符来进行修饰，常用修饰符如下：
+定义函数的方式也与C语言基本相同。函数的返回值可以是GLSL中的除了采样器的任意类型。对于GLSL中函数的参数，可以用参数用途修饰符来进行修饰，常用修饰符如下：
 
-  - in：输入参数，无修饰符时默认为此修饰符。
-  - out：输出参数。
-  - inout：既可以作为输入参数，又可以作为输出参数。
+- in：输入参数，无修饰符时默认为此修饰符。
+- out：输出参数。
+- inout：既可以作为输入参数，又可以作为输出参数。
 
 - 浮点精度
 
@@ -205,7 +222,7 @@ GLSL的类型转换与C不同。在GLSL中类型不可以自动提升，比如fl
 
 
 
-[上一篇: 6.OpenGL ES绘制矩形及圆形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/6.OpenGL%20ES%E7%BB%98%E5%88%B6%E7%9F%A9%E5%BD%A2%E5%8F%8A%E5%9C%86%E5%BD%A2.md)
+[上一篇: 6.OpenGL ES绘制矩形及圆形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/6.OpenGL%20ES%E7%BB%98%E5%88%B6%E7%9F%A9%E5%BD%A2%E5%8F%8A%E5%9C%86%E5%BD%A2.md)      
 [下一篇: 8.GLES类及Matrix类](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/8.GLES%E7%B1%BB%E5%8F%8AMatrix%E7%B1%BB.md)
 
 ---
diff --git "a/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md" "b/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
index a8b903a6..84f3870c 100644
--- "a/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
+++ "b/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
@@ -7,12 +7,102 @@ GLES30作为我们与着色器连接的工具类提供了丰富的api。
 上一篇文章说到GLSL中的变量修饰符有以下部分:    
 
 - none：(默认的可省略)本地变量，可读可写，函数的输入参数既是这种类型
-- const：声明变量或函数的参数为只读类型
+- const：常量，声明变量或函数的参数为只读类型
 - attribute：用于保存顶点或法线数据,它可以在数据缓冲区中读取数据，仅能用于顶点着色器
-- uniform：在运行时 shader 无法改变 uniform 变量，一般用来放置程序传递给 shader 的变换矩阵，材质，光照参数等等，可用于顶点着色器和片元着色器
+- uniform：统一变量在运行时 shader 无法改变 uniform 变量，一般用来放置程序传递给 shader 的变换矩阵，材质，光照参数等等，可用于顶点着色器和片元着色器
 - varying：用于修饰从顶点着色器向片元着色器传递的变量
 
+了解一些常用API的意思能更方便后面的学习，这里就简单整理列了一些常用的部分: 
 
+- glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
+
+  为颜色缓冲区指定清除值
+
+- glClear(GLbitfileld mask)
+
+  清除预设值的缓冲区，参数分别为GL_COLOR_BUFFER_BIT(当前启用了颜色写入的缓冲区) GL_DEPTH_BUFFER_BIT(深度缓冲区) GL_STENCIL_BUFFER_BIT(模板缓冲区)
+
+- glActiveTexture(GLenum texture)
+
+  激活纹理单元。参数指定要激活的纹理单元，参数texture必须是GL_TEXTUREi之一，初始值为GL_TEXTURE0。
+
+- glBindTexture(GLenum target, GLunit texture)
+
+  将一个特定的纹理ID绑定到一个纹理目标上
+
+- glGenTextures(GLsizei n, GLunit * textures)
+
+  生成纹理ID，参数n是指定要生成的纹理ID的数量，textures是指定存储生成的纹理ID的数组
+
+- glCreateShader(GLenum shaderType)
+
+  创建一个空的着色器对象，类型分别为GL_VERTEX_SHADER和GL_FRAGMENT_SHADER
+
+- glCompileShader(GLunit shader)
+
+  编译一个着色器对象。创建后要先编译才能运行。
+
+- glAttachShader(GLunit program, GLunit shader)
+
+  将着色器对象附加到program对象
+
+- glCreateProgram()
+
+  创建一个空的program对象并返回一个可以被引用的program id。
+
+- glEnableVertexAttribArray(GLunit index)/glEnableVertexAttribArray(GLunit index)
+
+  启用或禁用通用定点属性数组。参数为指定要启用或禁用的通用顶点属性的索引。
+
+- glDrawArrays(GLenum mode, GLinit first, GLsizei count)
+
+  参数mode为指定要渲染的图元类型，如GL_POINTS,GL_LINE_STRIP,GL_LINE_LOOP。first为指定已启用阵列中的起始索引。count为指定要渲染的索引数。在调用该方法前，可以使用glVertexAttribPointer预先指定单独的顶点、位置和颜色数组等信息。
+
+- glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid * indices)
+
+  mode是指定要渲染的图元类型，可以为GL_POINTS,GL_LINE_STRIP,GL_LINES等，count指定要渲染的元素数，type指定indices中的类型，必须是GL_UNSIGNED_BYTE或GL_UNSIGNED_SHORT。indices指定指向存储索引的位置的指针。使用该方法前也是需要使用glVertexAttribPointer来预先指定单独的顶点位置和颜色数据等信息。
+
+- void glGetUniformfv(GLunit program, GLinit location, GLfloat *params)
+
+  通过params的形式返回指定统一变量的值，参数program指定要查询的program对象，location指定要查询的统一变量的位置，params返回指定的统一变量的值。
+
+- void glGetVertexAttribfv(GLunit index, GLenum pname, GLFloat *params)
+
+  以params形式返回通用顶点属性参数的值。参数index是指定要查询的通用顶点的属性参数，pname是指定要查询的顶点属性参数的符号名称。可接受的值为GL_VERTEX_ATTRIB_ARRAY_BFFER_BINGDING等。
+
+- void glGetVertexAttribPointerv(GLunit index, GLenum pname, GLvoid **pointer)
+
+  已**pointer返回指定的通用顶点属性的指针信息。参数index为要返回单额通用顶点属性采参数，pname是指定要返回的通用顶点属性参数的符号名称，必须是GL_VERTEX_ATTRIB_ARRAY_POINTER。
+
+- glLinkProgram(GLunit program)
+
+  链接program指定的program对象，指定要链接的program对象的句柄。
+
+- glTexImage2D(GLenum target, Glint level, GLinit internalformat, GLsizei width, GLsizei height, GLinit border, GLenum format, GLenum type, const GLvoid *data)
+
+  指定一个二维的纹理图片。纹理将指定纹理图像的一部分映射到纹理化为活动的每个图形基元。
+
+- void glUniform1f(GLinit location, GLfloat v0)
+
+- void glUniformxx(GLinit l n,b njiu[uyi77u777uocation, GLfloat v0)
+
+- void glUniformMatrix1fx(GLinit location, GLsizei countM, GLboolean transpose, const GLfloat *valueM)
+
+  修改统一变量或统一变量数组的值。参数location为指定要修改的统一变量的位置，可以由glGetUniformLocation返回，v就是用于指定统一变量的新值。
+
+  count是指定要修改的元素数，value是指定指向将用于更新指定统一变量的count值数组的指针。countM指定要修改的矩阵数。
+
+- glUseProgram(GLunit program)
+
+  使用程序对象program作为当前渲染状态的一部分。
+
+- glVertexAttrib（GLunit index, GLFloat vo ...)
+
+  指定通用顶点属性的值
+
+- glVertexAttribPointer(GLunit index, GLinit size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
+
+  指定索引index处的通用顶点属性数组的位置和数据格式，以便在渲染时使用。
 
 ### 获取着色器程序内成员变量的id(句柄、指针)
 
@@ -135,8 +225,7 @@ GLES20.glActiveTexture()确定了后续的纹理状态改变影响哪个纹理
 
 
 
-
-[上一篇: 7.OpenGL ES着色器语言GLSL](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/7.OpenGL%20ES%E7%9D%80%E8%89%B2%E5%99%A8%E8%AF%AD%E8%A8%80GLSL.md)
+[上一篇: 7.OpenGL ES着色器语言GLSL](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/7.OpenGL%20ES%E7%9D%80%E8%89%B2%E5%99%A8%E8%AF%AD%E8%A8%80GLSL.md)     
 [下一篇: 9.OpenGL ES纹理](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/9.OpenGL%20ES%E7%BA%B9%E7%90%86.md)
 
 ---
diff --git "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md" "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"
index c712f597..ac99a6db 100644
--- "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
+++ "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
@@ -44,6 +44,26 @@ OpenGL不能直接加载jpg或者png这类被编码的压缩格式，需要加
 
 当我们通过光栅化将图形处理成一个个小片段的时候，再讲纹理采样，渲染到指定位置上时，通常会遇到纹理元素和小片段并非一一对应。这时候，会出现纹理的压缩或者放大。那么在这两种情况下，就会有不同的处理方案，这就是纹理过滤了。
 
+### 纹理对象和纹理的加载
+
+纹理应用的第一步是创建一个纹理对象。纹理对象是一个容器对象，保存渲染所需的纹理数据，例如图像数据、过滤模式和包装模式。在OpenGL ES中，纹理对象用一个无符号整数表示，该整数是纹理对象的一个句柄，用于生成纹理对象的函数是glGenTextures。
+
+- glGenTextures(GLsizei n, GLunit *textures)
+
+  生成一个空的纹理对象，参数n是要生成的纹理对象的数量，textures是一个保存n个纹理对象ID的无符号整数数组。
+
+- glBindTexture(GLenum target, GLunit texture)
+
+  将纹理对象绑定纹理目标，绑定目标后的下一个步骤是真正的加载图像数据。参数target是GL_TEXTURE_2D GL_TEXTURE_3D GL_TEXTURE_2D_ARRAY GL_TEXTURE_CUBE_MAP等目标。texture是要绑定的纹理对象句柄。
+
+- glTexImage2D(GLenum target, GLinit level, GLenum internalFormat, GLsizei width, GLsizei height, GLinit boder,
+
+  GLenum format, GLenum type, const void* pixels)
+
+  加载2D和立方图纹理图像数据。
+
+
+
 ### 加载纹理
 
 下面是一个工具类方法，相对通用，能解决大部分需求，这个方法可以将内置的图片资源加载出对应的纹理ID。
@@ -186,11 +206,13 @@ public class TextureHelper {
   ```
   #version 300 es
   precision mediump float;
+  // 采样器(sampler)是用于从纹理贴图读取的特殊统一变量。采样器统一变量将加载一个指定纹理绑定的纹理单元额数据，java代码里面需要把它设置为0
   uniform sampler2D uTextureUnit;
   //接收刚才顶点着色器传入的纹理坐标(s,t)
   in vec2 vTexCoord;
   out vec4 vFragColor;
   void main() {
+  		// texture函数会从纹理贴图中读取
       vFragColor = texture(uTextureUnit,vTexCoord);
   }
   ```
@@ -336,7 +358,7 @@ public class TextureHelper {
           GLES30.glActiveTexture(GLES30.GL_TEXTURE0);
           //绑定纹理
           GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, textureId);
-          // 将纹理单元传递片段着色器的u_TextureUnit
+          // 把着色里面的采样器统一变量sample设置为0
           GLES20.glUniform1i(aTextureLocation, 0);
   
   
@@ -528,7 +550,7 @@ public class TextureHelper {
 
 
 
-[上一篇: 8.GLES类及Matrix类](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/8.GLES%E7%B1%BB%E5%8F%8AMatrix%E7%B1%BB.md)
+[上一篇: 8.GLES类及Matrix类](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/8.GLES%E7%B1%BB%E5%8F%8AMatrix%E7%B1%BB.md)      
 [下一篇: 10.GLSurfaceView+MediaPlayer播放视频](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md)
 
 ---

From 6521d4f088615938b2721ef473492cf6f18120d0 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 19 Mar 2020 23:25:48 +0800
Subject: [PATCH 008/213] add notes

---
 .../1.OpenGL\347\256\200\344\273\213.md"      |  4 +-
 ...55\346\224\276\350\247\206\351\242\221.md" | 50 +++++++++-
 .../11.OpenGL ES\346\273\244\351\225\234.md"  | 95 ++++++++++++++++++-
 ...66\344\270\211\350\247\222\345\275\242.md" | 21 ++--
 .../9.OpenGL ES\347\272\271\347\220\206.md"   | 15 +--
 5 files changed, 162 insertions(+), 23 deletions(-)

diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
index 3dc28da4..c611da9e 100644
--- "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -1,13 +1,13 @@
 ## 1.OpenGL简介
 
+最近想要在播放器上做一个效果，需要用到OpenGL，一直以来也没关注学习过，就想着学习学习。在网上已经有很多文章，这里为什么还要写？主要是因为在学的时候发现那些文章看完后还是雨里雾里的不明白。要不就是不连贯，要不就是各种错误，各种理解的不对，导致我稀里糊涂的，干脆我不看了，买了一本书，看了书之后再去看文章就彻底明白了，所以我想写一个简单的，能从入门开始一步步学习的，能简单的学会，文章里面有一些是从下面写的参考链接中拷贝过来的，也有一些是自己从书上看的。
+
 [OpenGL官网](https://www.opengl.org/)
 
 OpenGL(Open Graphics Library开放图形库)是用于渲染2D、3D矢量图形的跨语言、跨平台的应用程序编程接口。
 
 OpenGL的前身是硅谷图形功能(SGI)公司为其图形工作站开发的IRIS GL,后来因为IRIS GL的移植性不好，所以在其基础上，开发出了OpenGl。OpenGl一般用于在图形工作站，PC端使用，由于性能各方面原因，在移动端使用OpenGl基本带不动。为此，Khronos公司就为OpenGl提供了一个子集，OpenGl ES(OpenGl for Embedded System)。
 
-网上已经有很多文章，这里为什么还要写？主要是因为最近在学的时候发现那些文章看完后还是雨里雾里的不明白。我想写一个简单的，能从入门开始一步步学习的，能简单的学会，文章里面有一些是从下面写的参考链接中拷贝过来的，也有一些是自己从书上看的。
-
 
 ### OpenGL ES
 
diff --git "a/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md" "b/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
index 6c845636..e66638da 100644
--- "a/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
+++ "b/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
@@ -1,12 +1,58 @@
 ## 10.GLSurfaceView+MediaPlayer播放视频
 
+### 相机预览
 
+1. 在GLSurfaceView.Render中创建一个纹理，再使用该纹理创建一个SurfaceTexture。
+2. 使用该SurfaceTexture创建一个Surface传给相机，相机预览数据就会输出到这个纹理上了。
+3. 使用GLSurfaceView.Render将该纹理渲染到GLSurfaceView的窗口上。
+4. 使用SurfaceTexture的setOnFrameAvailableListener方法给SurfaceTexture添加一个数据帧可用的监听器，在监听器中调用GLSurfaceView的requestRender方法渲染该帧数据，这样相机每次输出一帧数据就可以渲染一次，在GLSurfaceView窗口中就可以看到相机的预览数据了。
 
-平时的视频播放都是使用mediaplayer+textureview或者mediaplayer+surfaceview，但是如果我们要对视频进行一些OpenGL的操作，打个比方说我要在视频播放的时候添加一个滤镜，这个时候就需要用都SurfaceTexture了。
+- 顶点着色器
+
+  ```xml
+  #version 300 es
+  
+  layout (location = 0) in vec4 a_Position;
+  layout (location = 1) in vec2 a_texCoord;
+  
+  out vec2 v_texCoord;
+  
+  void main()
+  {
+      gl_Position = a_Position;
+      v_texCoord = a_texCoord;
+  }
+  ```
+
+- 片段着色器
+
+  这里需要注意一下，就是做相机预览的话，纹理的类型需要使用samplerExternalOES，而不是之前渲染图片的sampler2D。
+
+  ```xml
+  #version 300 es
+  #extension GL_OES_EGL_image_external_essl3 : require
+  precision mediump float;
+  
+  in vec2 v_texCoord;
+  out vec4 outColor;
+  uniform samplerExternalOES s_texture;
+  
+  void main(){
+      outColor = texture(s_texture, v_texCoord);
+  }
+  ```
+
+  
 
 
 
-### TextureView+MediaPlayer播放视频
+
+
+
+
+### 视频播放
+
+平时的视频播放都是使用mediaplayer+textureview或者mediaplayer+surfaceview，但是如果我们要对视频进行一些OpenGL的操作，打个比方说我要在视频播放的时候添加一个滤镜，这个时候就需要用都SurfaceTexture了。
 
 ```java
 public class VideoActivity extends Activity {
diff --git "a/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md" "b/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"
index dc1cc40d..4110aa94 100644
--- "a/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"	
+++ "b/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"	
@@ -1,6 +1,46 @@
 ## 11.OpenGL ES滤镜
 
-滤镜其实就是利用纹理。
+给图像添加滤镜本质就是图片处理，也就是对图片的像素进行计算，简单来说，图像处理的方法可以分为三类:  
+
+- 点算:当前像素的处理只和自身的像素值有关，和其他像素无关，比如灰度处理。
+- 领域算:当前像素的处理需要和相邻的一定范围内的像素有关，比如高斯模糊。
+- 全局算:在全局上对所有像素进行统一变换，比如几何变换。
+
+### 灰色滤镜
+
+和前一篇文章基本一样，只是修改一下片段着色器的代码，原理就是在片段着色器中去处理颜色，让RGB三个通道的颜色取均值:   
+
+```
+#version 300 es
+#extension GL_OES_EGL_image_external_essl3 : require
+precision mediump float;
+
+in vec2 v_texCoord;
+out vec4 outColor;
+uniform samplerExternalOES s_texture;
+
+//灰度滤镜，具体去处理颜色
+void grey(inout vec4 color){
+    float weightMean = color.r * 0.3 + color.g * 0.59 + color.b * 0.11;
+    color.r = color.g = color.b = weightMean;
+}
+
+void main(){
+    //拿到颜色值
+    vec4 tmpColor = texture(s_texture, v_texCoord);
+    //对颜色值进行处理
+    grey(tmpColor);
+    //将处理后的颜色值输出到颜色缓冲区
+    outColor = tmpColor;
+}
+
+```
+
+
+
+
+
+
 
 滤镜的编写主要是靠基类。
 
@@ -16,14 +56,63 @@
 
 RGB三个通道的颜色取反，而alpha通道不变。
 
-### 灰色滤镜
+```gl
+//反向滤镜
+void reverse(inout vec4 color){
+    color.r = 1.0 - color.r;
+    color.g = 1.0 - color.g;
+    color.b = 1.0 - color.b;
+}
+
+```
+
+### 黑白滤镜
+
+```gals
+//黑白滤镜
+void blackAndWhite(inout vec4 color){
+    float threshold = 0.5;
+    float mean = (color.r + color.g + color.b) / 3.0;
+    color.r = color.g = color.b = mean >= threshold ? 1.0 : 0.0;
+}
+```
+
 
-让RGB三个通道的颜色取均值
 
 ### 位移滤镜
 
 纹理默认传入的读取范围是(0,0)到(1,1)内的颜色值。如果对读取的位置进行调整修改，那么就可以做出各种各样的效果，例如缩放动画就是让读取的范围改成(-1,-1)到(2,2)。
 
+## 看完了疯了是不是，要做个滤镜效果，各种计算我实在弄不明白
+
+最简单的方法就是通过LUT方法，通过设计师提供的LUT文件来实现预定的滤镜效果。基本思路如下：  
+
+- 准备LUT文件
+- 加载LUT文件到OpenGL纹理
+- 将纹理传递给片段着色器
+- 根据LUT，在片段着色器中对图像的颜色值进行映射，得到滤镜后的颜色进行输出
+
+
+
+### 离屏渲染
+
+之前已经将相机的预览数据输出到OpenGL的纹理上，渲染的时候OpenGL直接将纹理渲染到屏幕上。但是如果想要对纹理进行进一步的处理，就不能直接渲染到屏幕上，而是需要先渲染到屏幕外的缓冲区(FrameBuffer)处理完后再渲染到屏幕。渲染到缓冲区的操作就是离屏渲染。主要步骤如下:   
+
+- 准备离屏渲染所需要的FrameBuffer和纹理对象。
+- 切换渲染目标(屏幕->缓冲区)
+- 执行渲染
+- 重置渲染目标(缓冲区 -> 屏幕)
+
+
+
+
+
+
+
+
+
+
+
 
 
 
diff --git "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md" "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"
index 7b859d6d..335b56e0 100644
--- "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
@@ -113,9 +113,9 @@ Preferences -> Plugins -> 搜GLSL Support安装就可以了。
   ```glsl
   // 声明着色器的版本
   #version 300 es
-  // 顶点着色器的顶点位置，输入一个名为vPosition的4分量向量，layout (location = 0)表示这个变量的位置是顶点属性0。
+  // 顶点着色器的顶点位置，输入一个名为vPosition的4分量向量，layout (location = 0)表示这个变量的位置是顶点属性中的第0个属性。
   layout (location = 0) in vec4 vPosition;
-  // 顶点着色器的顶点颜色数据，输入一个名为aColor的4分量向量，layout (location = 1)表示这个变量的位置是顶点属性1。
+  // 顶点着色器的顶点颜色数据，输入一个名为aColor的4分量向量，layout (location = 1)表示这个变量的位置是顶点属性中的第1个属性。
   layout (location = 1) in vec4 aColor;
   // 输出一个名为vColor的4分量向量，后面输入到片段着色器中。
   out vec4 vColor;
@@ -129,6 +129,8 @@ Preferences -> Plugins -> 搜GLSL Support安装就可以了。
   }
   ```
 
+  大体意思：使用OpenGL ES3.0版本，将图形顶点数据采用4分向量的数据结构绑定到着色器的第0个属性上，属性的名字是vPosition，然后再有一个颜色的4分向量绑定到做色漆的第1个属性上，属性的名字是aColor，另外还会输出一个vColor，着色器执行的时候，会将vPosition的值传递给用来表示顶点最终位置的内建变量gl_Position，将顶点最终大小的gl_PointSize设置为10，并将aColor的值复制给要输出额vColor。
+
 - 片段着色器(fragment_simple_shade.glsl)
 
   ```glsl
@@ -211,12 +213,12 @@ class MyGLRenderer implements GLSurfaceView.Renderer {
     /*****************1.声明绘制图形的坐标和颜色数据 end**************/
     public MyGLRenderer() {
         /****************2.为顶点位置及颜色申请本地内存 start************/
-        //顶点位置相关
+        //将顶点数据拷贝映射到native内存中，以便OpenGL能够访问
         //分配本地内存空间,每个浮点型占4字节空间；将坐标数据转换为FloatBuffer，用以传入给OpenGL ES程序
-        vertexBuffer = ByteBuffer.allocateDirect(triangleCoords.length * BYTES_PER_FLOAT)
-                .order(ByteOrder.nativeOrder())
-                .asFloatBuffer();
-        vertexBuffer.put(triangleCoords);
+        vertexBuffer = ByteBuffer.allocateDirect(triangleCoords.length * BYTES_PER_FLOAT) // 直接分配native内存
+                .order(ByteOrder.nativeOrder()) // 和本地平台保持一致的字节序
+                .asFloatBuffer(); // 将底层字节映射到FloatBuffer实例，方便使用
+        vertexBuffer.put(triangleCoords); // 将顶点数据拷贝到native内存中
         // 将数组数据put进buffer之后，指针并不是在首位，所以一定要position到0，至关重要！否则会有很多奇妙的错误！将缓冲区的指针移动到头部，保证数据是从最开始处读取
         vertexBuffer.position(0);
 
@@ -258,9 +260,10 @@ class MyGLRenderer implements GLSurfaceView.Renderer {
         //把颜色缓冲区设置为我们预设的颜色，绘图设计到多种缓冲区类型:颜色、深度和模板。这里只是向颜色缓冲区中绘制图形
         GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT);
 
-        //绑定vertex坐标数据，告诉OpenGL可以在缓冲区vertextBuffer中获取数据
+        //0是上面着色器中写的vPosition的变量位置(location = 0)。意思就是绑定vertex坐标数据，然后将在vertextBuffer中的顶点数据传给vPosition变量。
+        // 你肯定会想，如果我在着色器中不写呢？int vposition = glGetAttribLocation(program, "vPosition");就可以获得他的属性位置了
         GLES30.glVertexAttribPointer(0, 3, GLES30.GL_FLOAT, false, 0, vertexBuffer);
-        //启用顶点位置句柄
+        //启用顶点变量，这个0也是vPosition在着色器变量中的位置，和上面一样，在着色器文件中的location=0声明的
         GLES30.glEnableVertexAttribArray(0);
 
         //准备颜色数据
diff --git "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md" "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"
index ac99a6db..25a09519 100644
--- "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
+++ "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
@@ -28,8 +28,6 @@ OpenGL中，2D纹理也有自己的坐标体系，取值范围在(0,0)到(1,1)
 
 纹理上的每个顶点与定点坐标上的顶点一一对应。如下图，左边是顶点坐标，右边是纹理坐标，只要两个坐标的ABCD定义顺序一致，就可以正常地映射出对应的图形。顶点坐标内光栅化后的每个片段，都会在纹理坐标内取得对应的颜色值。
 
-
-
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_texture_position.jpg)
 
 ### 纹理尺寸
@@ -38,7 +36,7 @@ OpenGL中，2D纹理也有自己的坐标体系，取值范围在(0,0)到(1,1)
 
 ### 文件读取
 
-OpenGL不能直接加载jpg或者png这类被编码的压缩格式，需要加载原始数据，也就是bitmpa。我们在内置图片到工程中，应该将图片放到drawable-nodpi中，避免读取时被压缩，通过BitmapFactory解码读取图片时，要设置为非缩放的方式，即options.isScaled=false。
+OpenGL不能直接加载jpg或者png这类被编码的压缩格式，需要加载原始数据，也就是bitmap。我们在内置图片到工程中，应该将图片放到drawable-nodpi中，避免读取时被压缩，通过BitmapFactory解码读取图片时，要设置为非缩放的方式，即options.isScaled=false。
 
 ### 纹理过滤
 
@@ -212,7 +210,7 @@ public class TextureHelper {
   in vec2 vTexCoord;
   out vec4 vFragColor;
   void main() {
-  		// texture函数会从纹理贴图中读取
+  		// texture函数会将传进来的纹理和坐标进行差值采样，输出到颜色缓冲区。
       vFragColor = texture(uTextureUnit,vTexCoord);
   }
   ```
@@ -262,6 +260,7 @@ public class TextureHelper {
        * 坐标占用的向量个数
        */
       private static final int POSITION_COMPONENT_COUNT = 2;
+      // 逆时针顺序排列
       private static final float[] POINT_DATA = {
               -0.5f, -0.5f,
               0.5f, -0.5f,
@@ -272,6 +271,7 @@ public class TextureHelper {
        * 颜色占用的向量个数
        */
       private static final int TEXTURE_COMPONENT_COUNT = 2;
+      // 纹理坐标(s, t)，t坐标方向和顶点y坐标反着
       private static final float[] TEXTURE_DATA = {
               0.0f, 1.0f,
               1.0f, 1.0f,
@@ -313,10 +313,11 @@ public class TextureHelper {
           //在OpenGLES环境中使用程序
           GLES30.glUseProgram(mProgram);
   
-  
+  				// 获取这三个属性在着色器中的属性位置
           uMatrixLocation = GLES30.glGetUniformLocation(mProgram, "u_Matrix");
           aPositionLocation = GLES30.glGetAttribLocation(mProgram, "vPosition");
           aTextureLocation = GLES30.glGetAttribLocation(mProgram, "aTextureCoord");
+          // 将图片加载进来生成位图
           textureId = TextureHelper.loadTexture(MyApplication.getInstance(), R.drawable.img).getTextureId();
       }
   
@@ -344,12 +345,12 @@ public class TextureHelper {
   
           //将变换矩阵传入顶点渲染器
           GLES20.glUniformMatrix4fv(uMatrixLocation, 1, false, mProjectionMatrix, 0);
-          //准备坐标数据
+          //传入坐标数据
           GLES30.glVertexAttribPointer(aPositionLocation, POSITION_COMPONENT_COUNT, GLES30.GL_FLOAT, false, 0, vertexBuffer);
           //启用顶点位置句柄
           GLES30.glEnableVertexAttribArray(aPositionLocation);
   
-          //准备颜色数据
+          //传入颜色数据
           GLES30.glVertexAttribPointer(aTextureLocation, TEXTURE_COMPONENT_COUNT, GLES30.GL_FLOAT, false, 0, textureBuffer);
           //启用顶点颜色句柄
           GLES30.glEnableVertexAttribArray(aTextureLocation);

From 429d21fe20670ebd1c124c8cc92c20d021b3706f Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Sat, 21 Mar 2020 20:13:09 +0800
Subject: [PATCH 009/213] update opengl notes

---
 .../1.OpenGL\347\256\200\344\273\213.md"      |  8 ++---
 ...55\346\224\276\350\247\206\351\242\221.md" |  4 ++-
 ...66\344\270\211\350\247\222\345\275\242.md" |  8 +++--
 ...42\345\217\212\345\234\206\345\275\242.md" |  9 +++---
 ...45\231\250\350\257\255\350\250\200GLSL.md" | 26 +++++++++++++----
 ...\261\273\345\217\212Matrix\347\261\273.md" |  8 ++---
 .../9.OpenGL ES\347\272\271\347\220\206.md"   | 29 ++++++++++---------
 ...72\347\241\200\347\237\245\350\257\206.md" |  2 +-
 8 files changed, 56 insertions(+), 38 deletions(-)

diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
index bbd77b44..3035317b 100644
--- "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -6,7 +6,7 @@ OpenGL(Open Graphics Library开放图形库)是用于渲染2D、3D矢量图形
 
 OpenGL的前身是硅谷图形功能(SGI)公司为其图形工作站开发的IRIS GL,后来因为IRIS GL的移植性不好，所以在其基础上，开发出了OpenGl。OpenGl一般用于在图形工作站，PC端使用，由于性能各方面原因，在移动端使用OpenGl基本带不动。为此，Khronos公司就为OpenGl提供了一个子集，OpenGl ES(OpenGl for Embedded System)。
 
-网上已经有很多文章，这里为什么还要写？主要是因为最近在学的时候发现那些文章看完后还是雨里雾里的不明白。我想写一个简单的，能从入门开始一步步学习的，能简单的学会，文章里面有一些是从下面写的参考链接中拷贝过来的，也有一些是自己从书上看的。
+网上已经有很多文章，这里为什么还要写？主要是因为最近在学的时候发现那些文章看完后还是雨里雾里的不明白。方法不明白，不知道为什么要那样用，而且版本不同，最开始看的3.0版本，后面我就都用3.0的来写，结果网上的例子都是2.0的，GLSL的语法不一样，搞的死活出不来效果，耽误时间，所以干脆我系统学一遍，顺便记录下来，写一个简单的，能从入门开始一步步学习的，文章里面有一些是从下面写的参考链接中拷贝过来的，也有一些是自己从书上看的。本书所有的例子都是用OpenGL ES3.0版本、GLSL ES 300版本来写。
 
 
 ### OpenGL ES
@@ -21,9 +21,7 @@ OpenGL ES是免费的跨平台的功能完善的2D/3D图形库接口的API,是Op
 
 ### OpenGL的作用
 
-
-
-手机上做图像处理用很多方法，但是目前为止最高效的方法就是有效的使用图形处理单元(GPU)，图像的处理和渲染就是在将要渲染到窗口上的像素上做很多的浮点匀速，而GPU可以并行的做浮点运算，所以用GPU来分担CPU的部分，可以提高效率。
+在手机上有两大元件，一个是CPU一个是GPU。显示图形界面也有两种方式，一个是使用CPU渲染，一个是使用GPU渲染，但是目前为止最高效的方法就是有效的使用图形处理单元(GPU)，图像的处理和渲染就是在将要渲染到窗口上的像素上做很多的浮点匀速，而GPU可以并行的做浮点运算，所以用GPU来分担CPU的部分，可以提高效率，可以说GPU渲染其实是一种硬件加速。
 
 - 图片处理:比如图片色调转换、美颜等。
 - 摄像头预览效果处理。比如美颜相机、恶搞相机等。
@@ -229,7 +227,7 @@ Android 框架中有如下两个基本类，用于通过 OpenGL ES API 来创建
 
 
 
-   
+
 [下一篇: 2.GLSurfaceView简介](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/2.GLSurfaceView%E7%AE%80%E4%BB%8B.md)
 
 ---
diff --git "a/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md" "b/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
index 2af47100..419edb37 100644
--- "a/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
+++ "b/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
@@ -1,8 +1,10 @@
 ## 10.GLSurfaceView+MediaPlayer播放视频
 
+平时的视频播放都是使用mediaplayer+textureview或者mediaplayer+surfaceview，但是如果我们要对视频进行一些OpenGL的操作，打个比方说我要在视频播放的时候添加一个滤镜，这个时候就需要用都SurfaceTexture了。
 
+大体步骤如下:  
 
-平时的视频播放都是使用mediaplayer+textureview或者mediaplayer+surfaceview，但是如果我们要对视频进行一些OpenGL的操作，打个比方说我要在视频播放的时候添加一个滤镜，这个时候就需要用都SurfaceTexture了。
+GLSurfaceView -> setRender -> onSurfaceCreated回调方法中构造一个SurfaceTexture对象，然后设置到Camera预览或者MediaPlayer中 -> SurfaceTexture中的回调方法onFrameAvailable来得知一帧的数据真好完成 -> requestRender通知Render来绘制数据 -> 在Render的回调方法onDrawFrame中调用SurfaceTexture的updateTexImage方法来获取一帧数据，然后开始使用GL进行绘制预览。
 
 
 
diff --git "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md" "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"
index dc8c01dd..ccc88ef9 100644
--- "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
@@ -8,8 +8,10 @@ OpenGL ES的绘制需要有以下步骤:
 
 - 顶点着色器
 
+  着色器都是使用GLSL语言来写的而GLSL版本之间有差异。
+
   ```glsl
-  #version 330 core
+  #version 300 es
   layout (location = 0) in vec3 position;
   
   void main()
@@ -18,7 +20,7 @@ OpenGL ES的绘制需要有以下步骤:
   }
   ```
 
-  每个着色器都起始于一个版本声明。OpenGL 3.3以及和更高版本中，GLSL版本号和OpenGL的版本是匹配的（比如说GLSL 420版本对应于OpenGL 4.2）。我们同样明确表示我们会使用核心模式。
+  每个着色器都起始于一个版本声明，这里声明的是GLSL ES 300版本，在Android中它对应的OpenGL ES版本为3.0，而GLSL ES 100版本则对应的是OpenGL ES 2.0版本。如果不写版本默认的就是100。
 
   下一步，使用in关键字，在顶点着色器中声明所有的输入顶点属性(Input Vertex Attribute)。现在我们只关心位置(Position)数据，所以我们只需要一个顶点属性。GLSL有一个向量数据类型，它包含1到4个float分量，包含的数量可以从它的后缀数字看出来。由于每个顶点都有一个3D坐标，我们就创建一个vec3输入变量position。我们同样也通过layout (location = 0)设定了输入变量的位置值(Location)你后面会看到为什么我们会需要这个位置值。
 
@@ -33,7 +35,7 @@ OpenGL ES的绘制需要有以下步骤:
   片断着色器全是关于计算你的像素最后的颜色输出。颜色使用RGBA。
 
   ```glsl
-  #version 330 core
+  #version 300 es
   out vec4 color;
   void main() {
       color = vec4(1.0f, 0.5f, 0.2f, 1.0f);
diff --git "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md" "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"
index 3c40dc74..48ac41e1 100644
--- "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"	
@@ -307,7 +307,8 @@
           GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT);
   
           //将变换矩阵传入顶点渲染器
-          GLES20.glUniformMatrix4fv(uMatrixLocation,1,false,mMVPMatrix,0);
+          GLES
+  0.glUniformMatrix4fv(uMatrixLocation,1,false,mMVPMatrix,0);
           //准备坐标数据
           GLES30.glVertexAttribPointer(aPositionLocation, 3, GLES30.GL_FLOAT, false, 0, vertexBuffer);
           //启用顶点位置句柄
@@ -423,7 +424,7 @@ public class CircularRender implements GLSurfaceView.Renderer {
     @Override
     public void onSurfaceCreated(GL10 gl, EGLConfig config) {
         //将背景设置为白色
-        GLES20.glClearColor(1.0f,1.0f,1.0f,1.0f);
+        GLES30.glClearColor(1.0f,1.0f,1.0f,1.0f);
 
         //编译顶点着色程序
         String vertexShaderStr = ResReadUtils.readResource(R.raw.vertex_simple_shade);
@@ -478,7 +479,7 @@ public class CircularRender implements GLSurfaceView.Renderer {
         GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT);
 
         //将变换矩阵传入顶点渲染器
-        GLES20.glUniformMatrix4fv(uMatrixLocation,1,false,mMVPMatrix,0);
+        GLES30.glUniformMatrix4fv(uMatrixLocation,1,false,mMVPMatrix,0);
         //准备坐标数据
         GLES30.glVertexAttribPointer(aPositionLocation, 3, GLES30.GL_FLOAT, false, 0, vertexBuffer);
         //启用顶点位置句柄
@@ -500,7 +501,7 @@ public class CircularRender implements GLSurfaceView.Renderer {
 ```
 
 
-[上一篇: 5.OpenGL ES绘制三角形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/5.OpenGL%20ES%E7%BB%98%E5%88%B6%E4%B8%89%E8%A7%92%E5%BD%A2.md
+[上一篇: 5.OpenGL ES绘制三角形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/5.OpenGL%20ES%E7%BB%98%E5%88%B6%E4%B8%89%E8%A7%92%E5%BD%A2.md)         
 [下一篇: 7.OpenGL ES着色器语言GLSL](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/7.OpenGL%20ES%E7%9D%80%E8%89%B2%E5%99%A8%E8%AF%AD%E8%A8%80GLSL.md)
 
 ---
diff --git "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md" "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
index 0dd05b65..c177999b 100644
--- "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
+++ "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
@@ -3,7 +3,7 @@
 顶点着色器:  
 
 ```
-#version 330 core
+#version 300 es
 layout (location = 0) in vec3 position; // position变量的属性位置值为0
 
 out vec4 vertexColor; // 为片段着色器指定一个颜色输出
@@ -18,7 +18,7 @@ void main()
 片段着色器:  
 
 ```
-#version 330 core
+#version 300 es
 in vec4 vertexColor; // 从顶点着色器传来的输入变量（名称相同、类型相同）
 
 out vec4 color; // 片段着色器输出的变量名可以任意命名，类型必须是vec4
@@ -31,6 +31,20 @@ void main()
 
 
 
+这里需要重点讲一下上面的版本:   OpenGL ES版本有自己的着色器语言，其中OpenGL ES的版本与GLSL的版本有对应的关联关心:  
+
+- OpenGL ES 2.0版本对应GLSL ES 100版本
+- OpenGL ES 3.0版本对应GLSL ES 300版本
+
+我们这里使用的都是GLSL ES 300版本。但是GLSL ES 100 和 300版本中间有一些差异，这就是为什么我们有时候网上的一些代码编译时却报错的原因:  
+
+- GLSL ES 300版本中in和out代替了之前的属性和变化(attribute和varying)
+- texture()方法代替了之前的texture2D()方法
+- 300版本中布局限定符可以声明顶点着色器输入和片段着色器输出的问题，例如layout(location = 2) in vec3 values[4];
+- 舍弃了gl_FragColor的内置属性，变成我们需要自己使用out关键字定义的属性，这就是为什么你从网还是哪个找到的代码换成GLSL ES 300版本后报错的原因。
+
+
+
 ### GLSL的特点
 
 OpenGLES的着色器语言GLSL是一种高级的图形化编程语言，其源自应用广泛的C语言。与传统的C语言不同的是，它提供了更加丰富的针对于图像处理的原生类型，诸如向量、矩阵之类。GLSL主要包含以下特性：
@@ -102,9 +116,9 @@ GLSL的类型转换与C不同。在GLSL中类型不可以自动提升，比如fl
 
 与Java中的限定符类似，放在变量类型前面，并且只能用于全局变量。
 
-- attritude：一般用于各个顶点各不相同的量。如顶点颜色、坐标等。
+- attritude：一般用于各个顶点各不相同的量。如顶点颜色、坐标等。(GLSL 200 es版本的使用方法，在GLSL 300 es中已经被in替代)
 - uniform：一般用于对于3D物体中所有顶点都相同的量。比如光源位置，统一变换矩阵等。
-- varying：表示易变量，一般用于顶点着色器传递到片元着色器的量。
+- varying：表示易变量，一般用于顶点着色器传递到片元着色器的量。(GLSL 200 es版本的使用方法，在GLSL 300 es中已经被out替代)
 - const：常量。
 
 - 流程控制
@@ -148,8 +162,8 @@ GLSL的类型转换与C不同。在GLSL中类型不可以自动提升，比如fl
   - gl_FragFacing:bool型，表示是否为属于光栅化生成此片元的对应图元的正面。
   - gl_PointCoord:经过插值计算后的纹理坐标，点的范围是0.0到1.0
 - 输出变量
-  - gl_FragColor:当前片元颜色
-  - gl_FragData:vec4类型的数据。设置当前片元的颜色，供渲染管线的后继过程使用。
+  - gl_FragColor:当前片元颜色(GLSL 200 es版本的内置属性，在GLSL 300 es中已经没有了，需要自己用out关键字定义)
+  - gl_FragData:vec4类型的数据。设置当前片元的颜色，供渲染管线的后继过程使用。(GLSL 200 es版本的内置属性，在GLSL 300 es中已经没有了，需要自己用out关键字定义)
 
 ### 内置函数
 
diff --git "a/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md" "b/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
index a8b903a6..1c6bb981 100644
--- "a/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
+++ "b/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
@@ -2,15 +2,15 @@
 
 
 
-GLES30作为我们与着色器连接的工具类提供了丰富的api。
+GLES作为我们与着色器连接的工具类提供了丰富的api。
 
 上一篇文章说到GLSL中的变量修饰符有以下部分:    
 
 - none：(默认的可省略)本地变量，可读可写，函数的输入参数既是这种类型
 - const：声明变量或函数的参数为只读类型
-- attribute：用于保存顶点或法线数据,它可以在数据缓冲区中读取数据，仅能用于顶点着色器
+- attribute：用于保存顶点或法线数据,它可以在数据缓冲区中读取数据，仅能用于顶点着色器(GLSL 200 es版本，在GLSL 300 es中已经被in替代)
 - uniform：在运行时 shader 无法改变 uniform 变量，一般用来放置程序传递给 shader 的变换矩阵，材质，光照参数等等，可用于顶点着色器和片元着色器
-- varying：用于修饰从顶点着色器向片元着色器传递的变量
+- varying：用于修饰从顶点着色器向片元着色器传递的变量(仅能用GLSL 200 es版本，在GLSL 300 es中已经被out替代)
 
 
 
@@ -52,7 +52,7 @@ GLES20.glVertexAttribPointer(maTextureHandle, 2, GLES20.GL_FLOAT, false, 20, mRe
 
 ### 启用或禁用顶点属性数组
 
-调用GLES20.glEnableVertexAttribArray和GLES20.glDisableVertexAttribArray传入参数index。如果启用，那么当GLES20.glDrawArrays或者GLES20.glDrawElements被调用时，顶点属性数组会被使用。
+调用GLES30.glEnableVertexAttribArray和GLES30.glDisableVertexAttribArray传入参数index。如果启用，那么当GLES30.glDrawArrays或者GLES30.glDrawElements被调用时，顶点属性数组会被使用。
 
 ### 选择活动纹理单元
 
diff --git "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md" "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"
index c712f597..83480210 100644
--- "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
+++ "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
@@ -4,11 +4,11 @@
 
 ### 纹理
 
-在OpenGL中简单理解就是一张图片。
+在OpenGL中简单理解就是一张图片，在学习之前需要明白这几个概念，不然很容易迷糊，不知道为什么要这样去调用api，到底是什么意思.
 
-- 纹理Id:纹理的直接饮用
+- 纹理Id:句柄，纹理的直接引用
 
-- 纹理单元:纹理的操作容器，有GL_TEXTURE0、GL_TEXTURE1、GL_TEXTURE2等，纹理单元的数量是有限的，最多16个。所以在最多只能同时操作16个纹理。在切换使用纹理单元的时候，使用glActiveTexture方法。
+- 纹理单元:纹理的操作容器，有GL_TEXTURE0、GL_TEXTURE1、GL_TEXTURE2等，纹理单元的数量是有限的，最多16个。所以在最多只能同时操作16个纹理。在切换使用纹理单元的时候，使用glActiveTexture方法。也就是说OpenGL ES中内置了很多个纹理单元，并且是连续的，我们在使用的时候要选择其中一个，一般默认选择第一个(GLES_TEXTURE0)，并且如果不选的话OpenGL默认激活的也就是第一个纹理单元。激活纹理单元后需要把它和纹理Id绑定，然后再通过GLES30.glUniform1i()方法传递给着色器中。
 
 - 纹理目标:一个纹理单元中包含了多个类型的纹理目标，有GL_TEXTURE_1D、GL_TEXTURE_2D、CUBE_MAP等。本章中，将纹理ID绑定到纹理单元0的GL_TEXTURE_2D纹理目标上，之后对纹理目标的操作都是对纹理Id对应的数据进行操作。
 
@@ -83,15 +83,15 @@ public class TextureHelper {
                 Log.w(TAG, "Resource ID " + resourceId + " could not be decoded.");
             }
             // 加载Bitmap资源失败，删除纹理Id
-            GLES20.glDeleteTextures(1, textureObjectIds, 0);
+            GLES30.glDeleteTextures(1, textureObjectIds, 0);
             return bean;
         }
         // 2. 将纹理绑定到OpenGL对象上
-        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, textureObjectIds[0]);
+        GLES30.glBindTexture(GLES20.GL_TEXTURE_2D, textureObjectIds[0]);
 
         // 3. 设置纹理过滤参数:解决纹理缩放过程中的锯齿问题。若不设置，则会导致纹理为黑色
-        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR_MIPMAP_LINEAR);
-        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
+        GLES30.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR_MIPMAP_LINEAR);
+        GLES30.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
         // 4. 通过OpenGL对象读取Bitmap数据，并且绑定到纹理对象上，之后就可以回收Bitmap对象
         GLUtils.texImage2D(GLES20.GL_TEXTURE_2D, 0, bitmap, 0);
 
@@ -191,6 +191,7 @@ public class TextureHelper {
   in vec2 vTexCoord;
   out vec4 vFragColor;
   void main() {
+  	// 100 es版本中是texture2D
       vFragColor = texture(uTextureUnit,vTexCoord);
   }
   ```
@@ -278,7 +279,7 @@ public class TextureHelper {
       @Override
       public void onSurfaceCreated(GL10 gl, EGLConfig config) {
           //将背景设置为白色
-          GLES20.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
+          GLES30.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
   
           //编译顶点着色程序
           String vertexShaderStr = ResReadUtils.readResource(R.raw.texture_vertex_simple_shade);
@@ -321,7 +322,7 @@ public class TextureHelper {
           GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT);
   
           //将变换矩阵传入顶点渲染器
-          GLES20.glUniformMatrix4fv(uMatrixLocation, 1, false, mProjectionMatrix, 0);
+          GLES30.glUniformMatrix4fv(uMatrixLocation, 1, false, mProjectionMatrix, 0);
           //准备坐标数据
           GLES30.glVertexAttribPointer(aPositionLocation, POSITION_COMPONENT_COUNT, GLES30.GL_FLOAT, false, 0, vertexBuffer);
           //启用顶点位置句柄
@@ -341,7 +342,7 @@ public class TextureHelper {
   
   
           // 开始绘制
-          GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, POINT_DATA.length / POSITION_COMPONENT_COUNT);
+          GLES30.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, POINT_DATA.length / POSITION_COMPONENT_COUNT);
           //禁止顶点数组的句柄
           GLES30.glDisableVertexAttribArray(aPositionLocation);
           GLES30.glDisableVertexAttribArray(aTextureLocation);
@@ -437,7 +438,7 @@ public class TextureHelper {
       @Override
       public void onSurfaceCreated(GL10 gl, EGLConfig config) {
           //将背景设置为白色
-          GLES20.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
+          GLES30.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
   
           //编译顶点着色程序
           String vertexShaderStr = ResReadUtils.readResource(R.raw.texture_vertex_simple_shade);
@@ -480,7 +481,7 @@ public class TextureHelper {
           GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT);
   
           //将变换矩阵传入顶点渲染器
-          GLES20.glUniformMatrix4fv(uMatrixLocation, 1, false, mProjectionMatrix, 0);
+          GLES30.glUniformMatrix4fv(uMatrixLocation, 1, false, mProjectionMatrix, 0);
           //准备坐标数据
           GLES30.glVertexAttribPointer(aPositionLocation, POSITION_COMPONENT_COUNT, GLES30.GL_FLOAT,
                   false, 0, vertexBuffer);
@@ -498,9 +499,9 @@ public class TextureHelper {
           //绑定纹理
           GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, textureId);
           // 将纹理单元传递片段着色器的u_TextureUnit
-          GLES20.glUniform1i(aTextureLocation, 0);
+          GLES30.glUniform1i(aTextureLocation, 0);
           // 开始绘制
-          GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, POINT_DATA.length / POSITION_COMPONENT_COUNT);
+          GLES30.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, POINT_DATA.length / POSITION_COMPONENT_COUNT);
   
   
           //准备第二个纹理的坐标数据
diff --git "a/VideoDevelopment/\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md" "b/VideoDevelopment/\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
index 398deaa6..a3329194 100644
--- "a/VideoDevelopment/\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
+++ "b/VideoDevelopment/\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
@@ -168,7 +168,7 @@
 YUV
 ---
 
-YUV(也成YCbCr)是电视系统所采用的一种颜色编码方法。其中Y表示明亮度也就是灰阶值，它是基础信号。U和V表示的则是色度，UV的作用是描述影像色彩及饱和度，它们用于指定像素的颜色。U和V不是基础信号，他俩都是被正交调制的。
+YUV(也成YCbCr)是电视系统所采用的一种颜色编码方法，他是一种亮度与色度分离的色彩格式。其中Y表示明亮度也就是灰阶值，它是基础信号。U和V表示的则是色度，UV的作用是描述影像色彩及饱和度，它们用于指定像素的颜色。U和V不是基础信号，他俩都是被正交调制的。早期的电视都是黑白的，即只有亮度值(Y)，有了彩色电视之后，加入了UV两种色度，形成现在的YUV，也叫YCbCr。人眼对亮度敏感，对色度不敏感，因此减少部分UV的数据量，人眼也无法感知出来，这样就可以通过压缩UV的分辨率，在不影响观感的前提下，减少视频的体积。
 
 YUV和RGB视频信号相比，最大的优点在于只需要占用极少的带宽，YUV只需要占用RGB一般的带宽。
 

From a4e7ce71c81917e313c4d28860a8215ff1aafe9e Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 23 Mar 2020 21:39:10 +0800
Subject: [PATCH 010/213] update notes

---
 .../1.OpenGL\347\256\200\344\273\213.md"      |   6 +-
 ...55\346\224\276\350\247\206\351\242\221.md" | 132 ++--
 ...66\344\270\211\350\247\222\345\275\242.md" | 129 ++--
 ...42\345\217\212\345\234\206\345\275\242.md" | 566 ++++++++----------
 ...45\231\250\350\257\255\350\250\200GLSL.md" |  50 +-
 ...\261\273\345\217\212Matrix\347\261\273.md" |  17 +-
 .../9.OpenGL ES\347\272\271\347\220\206.md"   | 404 +++++--------
 7 files changed, 609 insertions(+), 695 deletions(-)

diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
index 12fb97af..30041c0d 100644
--- "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -11,6 +11,10 @@ OpenGL的前身是硅谷图形功能(SGI)公司为其图形工作站开发的IRI
 网上已经有很多文章，这里为什么还要写？主要是因为最近在学的时候发现那些文章看完后还是雨里雾里的不明白。方法不明白，不知道为什么要那样用，而且版本不同，最开始看的3.0版本，后面我就都用3.0的来写，结果网上的例子都是2.0的，GLSL的语法不一样，搞的死活出不来效果，耽误时间，所以干脆我系统学一遍，顺便记录下来，写一个简单的，能从入门开始一步步学习的，文章里面有一些是从下面写的参考链接中拷贝过来的，也有一些是自己从书上看的。本书所有的例子都是用OpenGL ES3.0版本、GLSL ES 300版本来写。
 
 
+
+[后面文章所有的源码都在Github上](https://github.com/CharonChui/OpenGLES3.0StudyDemo)
+
+
 ### OpenGL ES
 
 [OpenGL ES 官网](https://www.khronos.org/opengles/)
@@ -140,7 +144,7 @@ OpenGL ES 3.0实现了具有可编程着色功能的图形管线，有两个规
 
 - 坐标系
 
-  OpenGL ES采用虚拟坐标系
+  OpenGL ES是一个3D的世界，由x、y、z坐标组成顶点坐标。采用虚拟的右手坐标。
 
   ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_xy.png)
 
diff --git "a/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md" "b/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
index b27b0da2..a9ab7d17 100644
--- "a/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
+++ "b/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
@@ -1,6 +1,14 @@
 ## 10.GLSurfaceView+MediaPlayer播放视频
 
-### 相机预览
+### 视频播放
+
+平时的视频播放都是使用mediaplayer+textureview或者mediaplayer+surfaceview，但是如果我们要对视频进行一些OpenGL的操作，打个比方说我要在视频播放的时候添加一个滤镜，这个时候就需要用都SurfaceTexture了。
+
+大体步骤如下:
+
+GLSurfaceView -> setRender -> onSurfaceCreated回调方法中构造一个SurfaceTexture对象，然后设置到Camera预览或者MediaPlayer中 -> SurfaceTexture中的回调方法onFrameAvailable来得知一帧的数据真好完成 -> requestRender通知Render来绘制数据 -> 在Render的回调方法onDrawFrame中调用SurfaceTexture的updateTexImage方法来获取一帧数据，然后开始使用GL进行绘制预览。
+
+​	具体步骤:  
 
 1. 在GLSurfaceView.Render中创建一个纹理，再使用该纹理创建一个SurfaceTexture。
 2. 使用该SurfaceTexture创建一个Surface传给相机，相机预览数据就会输出到这个纹理上了。
@@ -11,116 +19,84 @@
 
   ```xml
   #version 300 es
+  in vec4 vPosition;
+  in vec2 vCoordPosition;
+  out vec2 aCoordPosition;
   
-  layout (location = 0) in vec4 a_Position;
-  layout (location = 1) in vec2 a_texCoord;
-  
-  out vec2 v_texCoord;
-  
-  void main()
-  {
-      gl_Position = a_Position;
-      v_texCoord = a_texCoord;
+  void main() {
+      gl_Position = vPosition;
+      aCoordPosition = vCoordPosition;
   }
   ```
-
+  
 - 片段着色器
 
-  这里需要注意一下，就是做相机预览的话，纹理的类型需要使用samplerExternalOES，而不是之前渲染图片的sampler2D。
+  这里需要注意一下，就是做相机预览和视频播放的话，纹理的类型需要使用samplerExternalOES，而不是之前渲染图片的sampler2D。这是因为相机和视频的数据是YUV的，而OpenGL ES是RGB的，samplerExternalOES内部会进行处理。#extension用于启用和设置扩展的行为。格式为#extension all : behavior。behavior的可选值有: require、enable、warn、disable。
 
   ```xml
   #version 300 es
   #extension GL_OES_EGL_image_external_essl3 : require
   precision mediump float;
-  
-  in vec2 v_texCoord;
-  out vec4 outColor;
-  uniform samplerExternalOES s_texture;
-  
-  void main(){
-      outColor = texture(s_texture, v_texCoord);
+  in vec2 aCoordPosition;
+  uniform samplerExternalOES uSamplerTexture;
+  out vec4 vFragColor;
+  void main() {
+      vFragColor = texture(uSamplerTexture, aCoordPosition);
   }
   ```
 
 
 
-
-
-
-
-
-
-### 视频播放
-
-平时的视频播放都是使用mediaplayer+textureview或者mediaplayer+surfaceview，但是如果我们要对视频进行一些OpenGL的操作，打个比方说我要在视频播放的时候添加一个滤镜，这个时候就需要用都SurfaceTexture了。
-
-大体步骤如下:
-
-GLSurfaceView -> setRender -> onSurfaceCreated回调方法中构造一个SurfaceTexture对象，然后设置到Camera预览或者MediaPlayer中 -> SurfaceTexture中的回调方法onFrameAvailable来得知一帧的数据真好完成 -> requestRender通知Render来绘制数据 -> 在Render的回调方法onDrawFrame中调用SurfaceTexture的updateTexImage方法来获取一帧数据，然后开始使用GL进行绘制预览。
-
-
-
-### TextureView+MediaPlayer播放视频
+### GLSurfaceView+MediaPlayer播放视频
 
 ```java
-public class VideoActivity extends Activity {
-    private static final String VIDEO_PATH = "http://60.28.125.129/video19.ifeng.com/video06/2012/04/11/629da9ec-60d4-4814-a940-997e6487804a.mp4";
+public class VideoPlayerActivity extends Activity {
+    private GLSurfaceView mGLSurfaceView;
     private Surface mSurface;
-    private TextureView mTextureView;
     private MediaPlayer mMediaPlayer;
 
     @Override
     protected void onCreate(@Nullable Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
-        setContentView(R.layout.activity_video);
-        mTextureView = findViewById(R.id.textureview);
-        mTextureView.setSurfaceTextureListener(new TextureView.SurfaceTextureListener() {
+        mGLSurfaceView = new GLSurfaceView(this);
+        Display display = getWindowManager().getDefaultDisplay();
+        int width = display.getWidth();
+        int height = (int) ((width) * (9 / 16f));
+        ViewGroup.LayoutParams layoutParams = new ViewGroup.LayoutParams(width, height);
+        mGLSurfaceView.setLayoutParams(layoutParams);
+        setContentView(mGLSurfaceView);
+        mGLSurfaceView.setEGLContextClientVersion(3);
+        VideoPlayerRender videoPlayerRender = new VideoPlayerRender(mGLSurfaceView);
+        videoPlayerRender.setIVideoTextureRenderListener(new VideoPlayerRender.IVideoTextureRenderListener() {
             @Override
-            public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
-                // 创建surface对象，让其从surfacetexture中获取数据
-                mSurface = new Surface(surface);
+            public void onCreate(SurfaceTexture surfaceTexture) {
+                mSurface = new Surface(surfaceTexture);
                 startPlay();
             }
-
-            @Override
-            public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
-
-            }
-
-            @Override
-            public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
-                mSurface = null;
-                if (mMediaPlayer != null) {
-                    mMediaPlayer.stop();
-                    mMediaPlayer.release();
-                    mMediaPlayer = null;
-                }
-                return true;
-            }
-
-            @Override
-            public void onSurfaceTextureUpdated(SurfaceTexture surface) {
-
-            }
         });
+        mGLSurfaceView.setRenderer(videoPlayerRender);
     }
 
     @Override
     protected void onResume() {
         super.onResume();
-        if (mTextureView.isAvailable()) {
+        if (mSurface != null && mSurface.isValid()) {
             startPlay();
         }
+        if (mGLSurfaceView != null) {
+            mGLSurfaceView.onResume();
+        }
     }
 
     private void startPlay() {
-        if (mMediaPlayer != null) {
+        if (mMediaPlayer != null && mSurface != null && mSurface.isValid()) {
+            mMediaPlayer.setSurface(mSurface);
+            mMediaPlayer.start();
             return;
         }
         mMediaPlayer = new MediaPlayer();
         try {
-            mMediaPlayer.setAudioStreamType(AudioManager.STREAM_MUSIC);
-            mMediaPlayer.setDataSource(this, Uri.parse(VIDEO_PATH));
+            mMediaPlayer = MediaPlayer.create(this, R.raw.beauty);
             mMediaPlayer.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
                 @Override
                 public void onPrepared(MediaPlayer mp) {
@@ -137,6 +113,7 @@ public class VideoActivity extends Activity {
             });
             // 将surface设置给mediaplayer
             mMediaPlayer.setSurface(mSurface);
+            mSurface.release();
             mMediaPlayer.setScreenOnWhilePlaying(true);
             mMediaPlayer.setLooping(true);
             mMediaPlayer.prepareAsync();
@@ -148,6 +125,17 @@ public class VideoActivity extends Activity {
     @Override
     protected void onPause() {
         super.onPause();
+        if (mGLSurfaceView != null) {
+            mGLSurfaceView.onPause();
+        }
+        if (mMediaPlayer != null && mMediaPlayer.isPlaying()) {
+            mMediaPlayer.pause();
+        }
+    }
+
+    @Override
+    protected void onDestroy() {
+        super.onDestroy();
         if (mMediaPlayer != null) {
             mMediaPlayer.reset();
             mMediaPlayer.release();
@@ -157,9 +145,9 @@ public class VideoActivity extends Activity {
 }
 ```
 
+视频是能播起来了，但是变形了
 
-
-### 增加OpenGL ES
+### 修复变形
 
 
 
diff --git "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md" "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"
index 09b102df..624f5d0a 100644
--- "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
@@ -110,7 +110,7 @@ Preferences -> Plugins -> 搜GLSL Support安装就可以了。
 
 安装完GLSL插件后，就可以开始了。一般将GLSL文件放到raw或assets目录，我们这里在raw目录上右键New，然后选择GLSL Shader创建就可以了，创建后默认会生成一个main()函数。
 
-- 顶点着色器(vertex_simple_shade.glsl)
+- 顶点着色器(triangle_vertex_shader.glsl)
 
   ```glsl
   // 声明着色器的版本
@@ -133,7 +133,7 @@ Preferences -> Plugins -> 搜GLSL Support安装就可以了。
 
   大体意思：使用OpenGL ES3.0版本，将图形顶点数据采用4分向量的数据结构绑定到着色器的第0个属性上，属性的名字是vPosition，然后再有一个颜色的4分向量绑定到做色漆的第1个属性上，属性的名字是aColor，另外还会输出一个vColor，着色器执行的时候，会将vPosition的值传递给用来表示顶点最终位置的内建变量gl_Position，将顶点最终大小的gl_PointSize设置为10，并将aColor的值复制给要输出额vColor。
 
-- 片段着色器(fragment_simple_shade.glsl)
+- 片段着色器(triangle_fragment_shader.glsl)
 
   ```glsl
   // 声明着色器的版本
@@ -164,29 +164,40 @@ Preferences -> Plugins -> 搜GLSL Support安装就可以了。
 6. 完成绘制
 
 ```java
-public class MainActivity extends AppCompatActivity {
+public class TriangleActivity extends Activity {
     private GLSurfaceView mGlSurfaceView;
+    private TriangleRender mTriangleRender;
 
     @Override
-    protected void onCreate(Bundle savedInstanceState) {
+    protected void onCreate(@Nullable Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
-        mGlSurfaceView = new MyGLSurfaceView(this);
-        setContentView(mGlSurfaceView);
+        setContentView(R.layout.activity_triangle);
+        mGlSurfaceView = findViewById(R.id.mGLSurfaceView);
+        // OpenGL ES 3.0版本
+        mGlSurfaceView.setEGLContextClientVersion(3);
+        mTriangleRender = new TriangleRender();
+        mGlSurfaceView.setRenderer(mTriangleRender);
+        mGlSurfaceView.setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
     }
-}
 
-class MyGLSurfaceView extends GLSurfaceView {
-    private final MyGLRenderer renderer;
+    @Override
+    protected void onPause() {
+        super.onPause();
+        mGlSurfaceView.onPause();
+    }
 
-    public MyGLSurfaceView(Context context) {
-        super(context);
-        setEGLContextClientVersion(3);
-        renderer = new MyGLRenderer();
-        setRenderer(renderer);
+    @Override
+    protected void onResume() {
+        super.onResume();
+        mGlSurfaceView.onResume();
     }
 }
+```
+
+TriangleRender的实现如下:  
 
-class MyGLRenderer implements GLSurfaceView.Renderer {
+```java
+public class TriangleRender implements GLSurfaceView.Renderer {
     //一个Float占用4Byte
     private static final int BYTES_PER_FLOAT = 4;
     //三个顶点
@@ -212,8 +223,9 @@ class MyGLRenderer implements GLSurfaceView.Renderer {
             0.0f, 1.0f, 0.0f, 1.0f,// bottom left
             0.0f, 0.0f, 1.0f, 1.0f// bottom right
     };
+
     /*****************1.声明绘制图形的坐标和颜色数据 end**************/
-    public MyGLRenderer() {
+    public TriangleRender() {
         /****************2.为顶点位置及颜色申请本地内存 start************/
         //将顶点数据拷贝映射到native内存中，以便OpenGL能够访问
         //分配本地内存空间,每个浮点型占4字节空间；将坐标数据转换为FloatBuffer，用以传入给OpenGL ES程序
@@ -240,10 +252,10 @@ class MyGLRenderer implements GLSurfaceView.Renderer {
 
         /******************3.加载编译顶点着色器和片段着色器 start**********/
         //编译顶点着色程序
-        String vertexShaderStr = readResource(MyApplication.getInstance(), R.raw.vertex_simple_shade);
+        String vertexShaderStr = readResource(MyApplication.getInstance(), R.raw.triangle_vertex_shader);
         int vertexShaderId = compileVertexShader(vertexShaderStr);
         //编译片段着色程序
-        String fragmentShaderStr = readResource(MyApplication.getInstance(), R.raw.fragment_simple_shade);
+        String fragmentShaderStr = readResource(MyApplication.getInstance(), R.raw.triangle_fragment_shader);
         int fragmentShaderId = compileFragmentShader(fragmentShaderStr);
         /******************3.加载编译顶点着色器和片段着色器 end**********/
         /******************4.创建program，连接顶点和片段着色器并链接program start***********/
@@ -253,24 +265,27 @@ class MyGLRenderer implements GLSurfaceView.Renderer {
         //在OpenGLES环境中使用程序
         GLES30.glUseProgram(mProgram);
     }
+
     public void onSurfaceChanged(GL10 unused, int width, int height) {
         /*********5.设置绘制窗口********/
         GLES30.glViewport(0, 0, width, height);
     }
+
     public void onDrawFrame(GL10 unused) {
         /**********6.绘制************/
         //把颜色缓冲区设置为我们预设的颜色，绘图设计到多种缓冲区类型:颜色、深度和模板。这里只是向颜色缓冲区中绘制图形
         GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT);
-
+        // glVertexAttribPointer是把顶点位置属性赋值给着色器程序
         //0是上面着色器中写的vPosition的变量位置(location = 0)。意思就是绑定vertex坐标数据，然后将在vertextBuffer中的顶点数据传给vPosition变量。
         // 你肯定会想，如果我在着色器中不写呢？int vposition = glGetAttribLocation(program, "vPosition");就可以获得他的属性位置了
+        // 第二个size是3，是因为上面我们triangleCoords声明的属性就是3位，xyz
         GLES30.glVertexAttribPointer(0, 3, GLES30.GL_FLOAT, false, 0, vertexBuffer);
         //启用顶点变量，这个0也是vPosition在着色器变量中的位置，和上面一样，在着色器文件中的location=0声明的
         GLES30.glEnableVertexAttribArray(0);
 
         //准备颜色数据
         /**
-         * glVertexAttribPointer()方法的参数上面的也说过了，这里再按照这个场景说一下分别为: 
+         * glVertexAttribPointer()方法的参数上面的也说过了，这里再按照这个场景说一下分别为:
          * index：顶点属性的索引.（这里我们的顶点位置和颜色向量在着色器中分别为0和1）layout (location = 0) in vec4 vPosition; layout (location = 1) in vec4 aColor;
          * size: 指定每个通用顶点属性的元素个数。必须是1、2、3、4。此外，glvertexattribpointer接受符号常量gl_bgra。初始值为4（也就是涉及颜色的时候必为4）。
          * type：属性的元素类型。（上面都是Float所以使用GLES30.GL_FLOAT）；
@@ -278,6 +293,7 @@ class MyGLRenderer implements GLSurfaceView.Renderer {
          * stride：跨距，默认是0。（由于我们将顶点位置和颜色数据分别存放没写在一个数组中，所以使用默认值0）
          * ptr： 本地数据缓存（这里我们的是顶点的位置和颜色数据）。
          */
+        // 1是aColor在属性的位置，4是因为我们声明的颜色是4位，r、g、b、a。
         GLES30.glVertexAttribPointer(1, 4, GLES30.GL_FLOAT, false, 0, colorBuffer);
         //启用顶点颜色句柄
         GLES30.glEnableVertexAttribArray(1);
@@ -296,6 +312,7 @@ class MyGLRenderer implements GLSurfaceView.Renderer {
         GLES30.glDisableVertexAttribArray(0);
         GLES30.glDisableVertexAttribArray(1);
     }
+
     /**
      * 编译顶点着色器
      *
@@ -417,6 +434,8 @@ class MyGLRenderer implements GLSurfaceView.Renderer {
 }
 ```
 
+
+
 效果如下:   
 
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_tri.jpg)
@@ -688,15 +707,14 @@ public class ShaderUtils {
 
 ```java
 public class ResReadUtils {
-
     /**
      * 读取资源
      * @param resourceId
      */
-    public static String readResource(int resourceId) {
+    public static String readResource(@NonNull Context context, @RawRes int resourceId) {
         StringBuilder builder = new StringBuilder();
         try {
-            InputStream inputStream = MyApplication.getInstance().getResources().openRawResource(resourceId);
+            InputStream inputStream = context.getResources().openRawResource(resourceId);
             InputStreamReader streamReader = new InputStreamReader(inputStream);
 
             BufferedReader bufferedReader = new BufferedReader(streamReader);
@@ -717,19 +735,19 @@ public class ResReadUtils {
 
 
 
-- 修改顶点着色器，增加矩阵变换(修改vertex_simple_shade.glsl)
+- 修改顶点着色器，增加矩阵变换(修改iso_triangle_vertex_shader.glsl)，片段着色器不用修改
 
   ```glsl
+  // 声明着色器的版本，OpenGL ES 3.0版本对应的着色器语言版本是 GLSL 300 ES
   #version 300 es
-  // 输入一个名为vPosition的4分量向量，layout (location = 0)表示这个变量的位置是顶点属性0。
+  // 顶点着色器的顶点位置，输入一个名为vPosition的4分量向量，layout (location = 0)表示这个变量的位置是顶点属性中的第0个属性。
   layout (location = 0) in vec4 vPosition;
-  // 输入一个名为aColor的4分量向量，layout (location = 1)表示这个变量的位置是顶点属性1。
+  // 顶点着色器的顶点颜色数据，输入一个名为aColor的4分量向量，layout (location = 1)表示这个变量的位置是顶点属性中的第1个属性。
   layout (location = 1) in vec4 aColor;
   // 输出一个名为vColor的4分量向量，后面输入到片段着色器中。
   out vec4 vColor;
   // 变换矩阵4*4
   uniform mat4 u_Matrix;
-  
   void main() {
       // gl_Position为Shader内置变量，为顶点位置，将其赋值为vPosition
       gl_Position  = u_Matrix * vPosition;
@@ -744,10 +762,41 @@ public class ResReadUtils {
 
 - 把变换矩阵设置给顶点渲染器
 
-其他所有代码都和上面的一样，只是在Renderer的实现类中增加对转换矩阵的部分
+其他所有代码都和上面的一样，只是在Renderer的实现类中增加对转换矩阵的部分，这里我们使用GLTextureView来实现: 
+
+```java
+public class IsoTriangleActivity extends Activity {
+    private GLTextureView mGLTextureView;
+
+    @Override
+    protected void onCreate(@Nullable Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_iso_triangle);
+        mGLTextureView = findViewById(R.id.mGLTextureView);
+        IsoTriangleRender render = new IsoTriangleRender();
+        mGLTextureView.setEGLContextClientVersion(3);
+        mGLTextureView.setRenderer(render);
+        mGLTextureView.setRenderMode(GLTextureView.RENDERMODE_WHEN_DIRTY);
+    }
+
+    @Override
+    protected void onPause() {
+        super.onPause();
+        mGLTextureView.onPause();
+    }
+
+    @Override
+    protected void onResume() {
+        super.onResume();
+        mGLTextureView.onResume();
+    }
+}
+```
+
+IsoTriangleRender的实现如下:  
 
 ```java
-class TriangleRender implements GLSurfaceView.Renderer {
+public class IsoTriangleRender implements GLTextureView.Renderer {
     //一个Float占用4Byte
     private static final int BYTES_PER_FLOAT = 4;
     //三个顶点
@@ -780,7 +829,7 @@ class TriangleRender implements GLSurfaceView.Renderer {
             0.0f, 0.0f, 1.0f, 1.0f// bottom right
     };
 
-    public TriangleRender() {
+    public IsoTriangleRender() {
         //顶点位置相关
         //分配本地内存空间,每个浮点型占4字节空间；将坐标数据转换为FloatBuffer，用以传入给OpenGL ES程序
         vertexBuffer = ByteBuffer.allocateDirect(triangleCoords.length * BYTES_PER_FLOAT)
@@ -802,13 +851,13 @@ class TriangleRender implements GLSurfaceView.Renderer {
         //将背景设置为白色
         GLES30.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
         //编译顶点着色程序
-        String vertexShaderStr = readResource(R.raw.vertex_simple_shade);
-        int vertexShaderId = compileVertexShader(vertexShaderStr);
+        String vertexShaderStr = ResReadUtils.readResource(MyApplication.getInstance(), R.raw.iso_triangle_vertex_shader);
+        int vertexShaderId = ShaderUtils.compileVertexShader(vertexShaderStr);
         //编译片段着色程序
-        String fragmentShaderStr = readResource(R.raw.fragment_simple_shade);
-        int fragmentShaderId = compileFragmentShader(fragmentShaderStr);
+        String fragmentShaderStr = ResReadUtils.readResource(MyApplication.getInstance(), R.raw.iso_triangle_fragment_shader);
+        int fragmentShaderId = ShaderUtils.compileFragmentShader(fragmentShaderStr);
         //连接程序
-        mProgram = linkProgram(vertexShaderId, fragmentShaderId);
+        mProgram = ShaderUtils.linkProgram(vertexShaderId, fragmentShaderId);
         //在OpenGLES环境中使用程序
         GLES30.glUseProgram(mProgram);
 
@@ -846,7 +895,7 @@ class TriangleRender implements GLSurfaceView.Renderer {
     }
 
     @Override
-    public void onDrawFrame(GL10 gl) {
+    public boolean onDrawFrame(GL10 gl) {
         //把颜色缓冲区设置为我们预设的颜色
         GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT);
         //绑定vertex坐标数据，告诉OpenGL可以在缓冲区vertexBuffer中获取vPosition的护具
@@ -862,12 +911,20 @@ class TriangleRender implements GLSurfaceView.Renderer {
         //禁止顶点数组的句柄
         GLES30.glDisableVertexAttribArray(0);
         GLES30.glDisableVertexAttribArray(1);
+        return true;
+    }
+
+    @Override
+    public void onSurfaceDestroyed() {
+
     }
 }
 ```
 
 
 
+
+
 [上一篇: 4.GLTextureView实现](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/4.GLTextureView%E5%AE%9E%E7%8E%B0.md)  
 [下一篇: 6.OpenGL ES绘制矩形及圆形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/6.OpenGL%20ES%E7%BB%98%E5%88%B6%E7%9F%A9%E5%BD%A2%E5%8F%8A%E5%9C%86%E5%BD%A2.md)
 
diff --git "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md" "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"
index 8e079b88..a9ed80f0 100644
--- "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"	
@@ -1,5 +1,145 @@
 ## 6.OpenGL ES绘制矩形及圆形
 
+写完上面的绘制三角形的部分，手快抽筋了，为啥？ 一个就是每个方法都要调用GLES30.还有一个就是我们完全可以把公共的代码再封装到一个Base类里面啊，所以我这里就抽了一个BaseGLSurfaceViewRenderer类，然后把GLES30中一些常用的方法写了一遍。为什么要这样做呢？ 我们也可以通过import static来省去GLES30的写法，但我不喜欢那样。另外还弄了BufferUtil、ProjectionMatrixUtil的类:  
+
+```java
+public class BufferUtil {
+    private static final int BYTES_PER_FLOAT = 4;
+
+    public static FloatBuffer getFloatBuffer(float[] array) {
+        FloatBuffer floatBuffer = ByteBuffer.allocateDirect(array.length * BYTES_PER_FLOAT)
+                .order(ByteOrder.nativeOrder())
+                .asFloatBuffer();
+        floatBuffer.put(array);
+        floatBuffer.position(0);
+        return floatBuffer;
+    }
+}
+```
+
+```java
+public class ProjectionMatrixUtil {
+    // 矩阵数组
+    private static final float[] mProjectionMatrix = new float[]{
+            1, 0, 0, 0,
+            0, 1, 0, 0,
+            0, 0, 1, 0,
+            0, 0, 0, 1,
+    };
+
+    public static void orthoM(int program, int width, int height, String name) {
+        int uMatrixLocation = GLES30.glGetUniformLocation(program, name);
+        //计算宽高比 边长比(>=1)，非宽高比
+        float aspectRatio = width > height ?
+                (float) width / (float) height :
+                (float) height / (float) width;
+        if (width > height) {
+            // 横屏
+            Matrix.orthoM(mProjectionMatrix, 0, -aspectRatio, aspectRatio, -1f, 1f, -1f, 1f);
+        } else {
+            // 竖屏or正方形
+            Matrix.orthoM(mProjectionMatrix, 0, -1f, 1f, -aspectRatio, aspectRatio, -1f, 1f);
+        }
+        GLES30.glUniformMatrix4fv(uMatrixLocation, 1, false, mProjectionMatrix, 0);
+    }
+}
+```
+
+
+
+```java
+public abstract class BaseGLSurfaceViewRenderer implements GLSurfaceView.Renderer {
+    protected int mProgram;
+
+    /**
+     * readResource -> compileShader -> linkProgram -> useProgram
+     *
+     * @param context
+     * @param vertexShader
+     * @param fragmentShader
+     */
+    protected void handleProgram(@NonNull Context context, @RawRes int vertexShader, @RawRes int fragmentShader) {
+        String vertexShaderStr = ResReadUtils.readResource(context, vertexShader);
+        int vertexShaderId = ShaderUtils.compileVertexShader(vertexShaderStr);
+        //编译片段着色程序
+        String fragmentShaderStr = ResReadUtils.readResource(context, fragmentShader);
+        int fragmentShaderId = ShaderUtils.compileFragmentShader(fragmentShaderStr);
+        //连接程序
+        mProgram = ShaderUtils.linkProgram(vertexShaderId, fragmentShaderId);
+        //在OpenGLES环境中使用程序
+        GLES30.glUseProgram(mProgram);
+    }
+
+    protected void glViewport(int x, int y, int width, int height) {
+        GLES30.glViewport(x, y, width, height);
+    }
+
+    protected void glClearColor(float red, float green, float blue, float alpha) {
+        GLES30.glClearColor(red, green, blue, alpha);
+    }
+
+    protected void glClear(int mask) {
+        GLES30.glClear(mask);
+    }
+
+    protected static void glEnableVertexAttribArray(int index) {
+        GLES30.glEnableVertexAttribArray(index);
+    }
+
+    protected void glDisableVertexAttribArray(int index) {
+        GLES30.glDisableVertexAttribArray(index);
+    }
+
+    protected int glGetAttribLocation(String name) {
+        return GLES30.glGetAttribLocation(mProgram, name);
+    }
+
+    protected int glGetUniformLocation(String name) {
+        return GLES30.glGetUniformLocation(mProgram, name);
+    }
+
+    protected void glUniformMatrix4fv(int location, int count, boolean transpose, float[] value, int offset) {
+        GLES30.glUniformMatrix4fv(location, count, transpose, value, offset);
+    }
+
+    protected void glDrawArrays(int mode, int first, int count) {
+        GLES30.glDrawArrays(mode, first, count);
+    }
+
+    protected void glDrawElements(int mode, int count, int type, int offset) {
+        GLES30.glDrawElements(mode, count, type, offset);
+    }
+
+    protected void orthoM(String name, int width, int height) {
+        ProjectionMatrixUtil.orthoM(mProgram, width, height, name);
+    }
+
+    protected void glVertexAttribPointer(
+            int indx,
+            int size,
+            int type,
+            boolean normalized,
+            int stride,
+            java.nio.Buffer ptr) {
+        GLES30.glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
+    }
+}
+```
+
+
+
+前面绘制点、线、三角形的时候在用GLES30.glDrawArrays(GL_TRIANGLE_STRIP)方法时选择的mode是GL_TRIANGLE_STRIP，这个mode还有其他的类型，假设我现在想要绘制一个6边形呢，这里以A、B、C、D、E、F六个点来说一下mode的区别:  
+
+- GL_POINTS : 绘制独立的点。
+- GL_LINES : 绘制每两个点的一条线。AB、CD、EF
+- GL_LINE_LOOP : 按顺序将所有的点都连接起来，包括收尾相连。AB、BC、CD、DE、EF、FA
+- GL_LINE_STRIP：按顺序将所有的点连接起来，不包括收尾相连。AB、BC、CD、DE、EF
+- GL_TRIANGLES：每3个点构成一个三角形。 ABC、DEF
+- GL_TRIANGLES_STRIP:相邻3个点构成一个三角形，不包括收尾两个点。ABC、BCD、CDE、DEF
+- GL_TRIANGLE_FAN：第一个点和之后所有相邻的两个点构成一个三角形。ABC、ACD、ADE、AEF
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_gl_triangle.jpg)
+
 
 
 ### 顶点法和索引法
@@ -29,38 +169,11 @@
   顶点法:   
   
   ```java
-  package com.charon.opengldemo.rectangle;
-  
-  import android.opengl.GLES20;
-  import android.opengl.GLES30;
-  import android.opengl.GLSurfaceView;
-  import android.opengl.Matrix;
-  
-  import com.charon.opengldemo.R;
-  import com.charon.opengldemo.util.ResReadUtils;
-  import com.charon.opengldemo.util.ShaderUtils;
-  
-  import java.nio.ByteBuffer;
-  import java.nio.ByteOrder;
-  import java.nio.FloatBuffer;
-  import java.nio.ShortBuffer;
-  
-  import javax.microedition.khronos.egl.EGLConfig;
-  import javax.microedition.khronos.opengles.GL10;
-  
-  public class RectangleRender implements GLSurfaceView.Renderer {
-      //一个Float占用4Byte
-      private static final int BYTES_PER_FLOAT = 4;
+  public class SquareRender extends BaseGLSurfaceViewRenderer {
       //顶点位置缓存
       private final FloatBuffer vertexBuffer;
       //顶点颜色缓存
       private final FloatBuffer colorBuffer;
-      //渲染程序
-      private int mProgram;
-  
-      //返回属性变量的位置
-      //变换矩阵
-      private int uMatrixLocation;
       //位置
       private int aPositionLocation;
       //颜色
@@ -76,6 +189,7 @@
               -0.5f, 0.5f,
               0.5f, 0.5f,
       };
+  
       /**
        * 颜色占用的向量个数
        */
@@ -87,244 +201,126 @@
               0f, 1f, 1f, 0f,
               1f, 1f, 0f, 0f
       };
-      private final float[] mProjectionMatrix = new float[16];
-  
-      public RectangleRender() {
-          //顶点位置相关
-          //分配本地内存空间,每个浮点型占4字节空间；将坐标数据转换为FloatBuffer，用以传入给OpenGL ES程序
-          vertexBuffer = ByteBuffer.allocateDirect(POINT_DATA.length * BYTES_PER_FLOAT)
-                  .order(ByteOrder.nativeOrder())
-                  .asFloatBuffer();
-          vertexBuffer.put(POINT_DATA);
-          vertexBuffer.position(0);
   
-          //顶点颜色相关
-          colorBuffer = ByteBuffer.allocateDirect(COLOR_DATA.length * BYTES_PER_FLOAT)
-                  .order(ByteOrder.nativeOrder())
-                  .asFloatBuffer();
-          colorBuffer.put(COLOR_DATA);
-          colorBuffer.position(0);
+      public SquareRender() {
+          vertexBuffer = BufferUtil.getFloatBuffer(POINT_DATA);
+          colorBuffer = BufferUtil.getFloatBuffer(COLOR_DATA);
       }
   
       @Override
       public void onSurfaceCreated(GL10 gl, EGLConfig config) {
-          //将背景设置为白色
-          GLES20.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
-  
-          //编译顶点着色程序
-          String vertexShaderStr = ResReadUtils.readResource(R.raw.vertex_simple_shade);
-          int vertexShaderId = ShaderUtils.compileVertexShader(vertexShaderStr);
-          //编译片段着色程序
-          String fragmentShaderStr = ResReadUtils.readResource(R.raw.fragment_simple_shade);
-          int fragmentShaderId = ShaderUtils.compileFragmentShader(fragmentShaderStr);
-          //连接程序
-          mProgram = ShaderUtils.linkProgram(vertexShaderId, fragmentShaderId);
-          //在OpenGLES环境中使用程序
-          GLES30.glUseProgram(mProgram);
-  
-  
-          uMatrixLocation = GLES30.glGetUniformLocation(mProgram, "u_Matrix");
-          aPositionLocation = GLES30.glGetAttribLocation(mProgram, "vPosition");
-          aColorLocation = GLES30.glGetAttribLocation(mProgram, "aColor");
+          glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
+          handleProgram(MyApplication.getInstance(), R.raw.iso_triangle_vertex_shader, R.raw.iso_triangle_fragment_shader);
+          aPositionLocation = glGetAttribLocation("vPosition");
+          aColorLocation = glGetAttribLocation("aColor");
+          glVertexAttribPointer(aPositionLocation, POSITION_COMPONENT_COUNT, GLES30.GL_FLOAT, false, 0, vertexBuffer);
+          glVertexAttribPointer(aColorLocation, COLOR_COMPONENT_COUNT, GLES30.GL_FLOAT, false, 0, colorBuffer);
       }
   
       @Override
       public void onSurfaceChanged(GL10 gl, int width, int height) {
-          //设置绘制窗口
-          GLES30.glViewport(0, 0, width, height);
-          //正交投影方式
-          final float aspectRatio = width > height ?
-                  (float) width / (float) height :
-                  (float) height / (float) width;
-          if (width > height) {
-              //横屏
-              Matrix.orthoM(mProjectionMatrix, 0, -aspectRatio, aspectRatio, -1f, 1f, -1f, 1f);
-          } else {
-              //竖屏
-              Matrix.orthoM(mProjectionMatrix, 0, -1f, 1f, -aspectRatio, aspectRatio, -1f, 1f);
-          }
+          glViewport(0, 0, width, height);
+          orthoM("u_Matrix", width, height);
       }
   
       @Override
       public void onDrawFrame(GL10 gl) {
-          //把颜色缓冲区设置为我们预设的颜色
-          GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT);
-  
-          //将变换矩阵传入顶点渲染器
-          GLES20.glUniformMatrix4fv(uMatrixLocation, 1, false, mProjectionMatrix, 0);
-          //准备坐标数据
-          GLES30.glVertexAttribPointer(aPositionLocation, POSITION_COMPONENT_COUNT, GLES30.GL_FLOAT, false, 0, vertexBuffer);
-          //启用顶点位置句柄
-          GLES30.glEnableVertexAttribArray(aPositionLocation);
-  
-          //准备颜色数据
-          GLES30.glVertexAttribPointer(aColorLocation, COLOR_COMPONENT_COUNT, GLES30.GL_FLOAT, false, 0, colorBuffer);
-          //启用顶点颜色句柄
-          GLES30.glEnableVertexAttribArray(aColorLocation);
-          // 开始绘制
-          GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, POINT_DATA.length / POSITION_COMPONENT_COUNT);
-          //禁止顶点数组的句柄
-          GLES30.glDisableVertexAttribArray(aPositionLocation);
-          GLES30.glDisableVertexAttribArray(aColorLocation);
+          glClear(GLES30.GL_COLOR_BUFFER_BIT);
+          glEnableVertexAttribArray(aPositionLocation);
+          glEnableVertexAttribArray(aColorLocation);
+          // 正方形、四个点(POINT_DATA.length / POSITION_COMPONENT_COUNT)
+          glDrawArrays(GLES30.GL_TRIANGLE_STRIP, 0, POINT_DATA.length / POSITION_COMPONENT_COUNT);
+          glDisableVertexAttribArray(aPositionLocation);
+          glDisableVertexAttribArray(aColorLocation);
       }
   }
   ```
   
-  索引法:
+  上面是一个正方形，那如果我画一个六边形，就需要多定义好几个顶点数据，来让其能组成对应的三角形拼接，下面是用索引法来画一个六边形，索引法相对于顶点法来说可以更高效，能节省很多顶点的数据:
   
   ```java
-  public class RectangleRender implements GLSurfaceView.Renderer {
-      //一个Float占用4Byte
-      private static final int BYTES_PER_FLOAT = 4;
-      //顶点个数
-      private static final int POSITION_COMPONENT_COUNT = 4;
+  public class HexagonRender extends BaseGLSurfaceViewRenderer {
       //顶点位置缓存
       private final FloatBuffer vertexBuffer;
       //顶点颜色缓存
-    private final FloatBuffer colorBuffer;
-      //顶点索引缓存
-      private final ShortBuffer indicesBuffer;
-      //渲染程序
-      private int mProgram;
-  
-      //相机矩阵
-      private final float[] mViewMatrix = new float[16];
-      //投影矩阵
-      private final float[] mProjectMatrix = new float[16];
-      //最终变换矩阵
-      private final float[] mMVPMatrix = new float[16];
-  
-      //返回属性变量的位置
-      //变换矩阵
-      private int uMatrixLocation;
+      private final FloatBuffer colorBuffer;
+      // 顶点索引缓存
+      private final ShortBuffer indexBuffer;
       //位置
       private int aPositionLocation;
       //颜色
       private int aColorLocation;
   
-      //四个顶点的位置参数
-      private float rectangleCoords[] = {
-              -0.5f, 0.5f, 0.0f,//top left
-              -0.5f, -0.5f, 0.0f, // bottom left
-              0.5f, -0.5f, 0.0f, // bottom right
-              0.5f, 0.5f, 0.0f // top right
+      /**
+       * 坐标占用的向量个数
+       */
+      private static final int POSITION_COMPONENT_COUNT = 2;
+      private static final float[] POINT_DATA = {
+              -0.5f, -0.5f,
+              0.5f, -0.5f,
+              0.5f, 0.5f,
+              -0.5f, 0.5f,
+              0f, -1.0f,
+              0f, 1.0f
       };
   
       /**
-       * 顶点索引
+       * 数组绘制的索引:当前是绘制三角形，所以是3个元素构成一个绘制顺序
        */
-      private short[] indices = {
-              0, 1, 2, 0, 2, 3
+      private static final short[] INDEX_DATA = {
+              0, 1, 2,
+              0, 2, 3,
+              0, 4, 1,
+              3, 2, 5
       };
   
-      //四个顶点的颜色参数
-      private float color[] = {
-              0.0f, 0.0f, 1.0f, 1.0f,//top left
-              0.0f, 1.0f, 0.0f, 1.0f,// bottom left
-              0.0f, 0.0f, 1.0f, 1.0f,// bottom right
-              1.0f, 0.0f, 0.0f, 1.0f// top right
+      /**
+       * 颜色占用的向量个数
+       */
+      private static final int COLOR_COMPONENT_COUNT = 4;
+      private static final float[] COLOR_DATA = {
+              // 一个顶点有3个向量数据：r、g、b、a
+              1f, 0.5f, 0.5f, 0f,
+              1f, 0f, 1f, 0f,
+              0f, 1f, 1f, 0f,
+              1f, 1f, 0f, 0f
       };
   
-      public RectangleRender() {
-          //顶点位置相关
-          //分配本地内存空间,每个浮点型占4字节空间；将坐标数据转换为FloatBuffer，用以传入给OpenGL ES程序
-          vertexBuffer = ByteBuffer.allocateDirect(rectangleCoords.length * BYTES_PER_FLOAT)
-                  .order(ByteOrder.nativeOrder())
-                  .asFloatBuffer();
-          vertexBuffer.put(rectangleCoords);
-          vertexBuffer.position(0);
-  
-          //顶点颜色相关
-          colorBuffer = ByteBuffer.allocateDirect(color.length * BYTES_PER_FLOAT)
-                  .order(ByteOrder.nativeOrder())
-                  .asFloatBuffer();
-          colorBuffer.put(color);
-          colorBuffer.position(0);
-  
-          //顶点索引相关
-          indicesBuffer = ByteBuffer.allocateDirect(indices.length * 4)
-                  .order(ByteOrder.nativeOrder())
-                  .asShortBuffer();
-          indicesBuffer.put(indices);
-          indicesBuffer.position(0);
+      public HexagonRender() {
+          vertexBuffer = BufferUtil.getFloatBuffer(POINT_DATA);
+          colorBuffer = BufferUtil.getFloatBuffer(COLOR_DATA);
+          indexBuffer = BufferUtil.getShortBuffer(INDEX_DATA);
       }
   
       @Override
       public void onSurfaceCreated(GL10 gl, EGLConfig config) {
-          //将背景设置为白色
-          GLES20.glClearColor(1.0f,1.0f,1.0f,1.0f);
-  
-          //编译顶点着色程序
-          String vertexShaderStr = ResReadUtils.readResource(R.raw.vertex_simple_shade);
-          int vertexShaderId = ShaderUtils.compileVertexShader(vertexShaderStr);
-          //编译片段着色程序
-          String fragmentShaderStr = ResReadUtils.readResource(R.raw.fragment_simple_shade);
-          int fragmentShaderId = ShaderUtils.compileFragmentShader(fragmentShaderStr);
-          //连接程序
-          mProgram = ShaderUtils.linkProgram(vertexShaderId, fragmentShaderId);
-          //在OpenGLES环境中使用程序
-          GLES30.glUseProgram(mProgram);
-  
-  
-          uMatrixLocation = GLES30.glGetUniformLocation(mProgram, "u_Matrix");
-          aPositionLocation = GLES30.glGetAttribLocation(mProgram, "vPosition");
-          aColorLocation = GLES30.glGetAttribLocation(mProgram, "aColor");
+          glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
+          handleProgram(MyApplication.getInstance(), R.raw.iso_triangle_vertex_shader, R.raw.iso_triangle_fragment_shader);
+          aPositionLocation = glGetAttribLocation("vPosition");
+          aColorLocation = glGetAttribLocation("aColor");
+          glVertexAttribPointer(aPositionLocation, POSITION_COMPONENT_COUNT, GLES30.GL_FLOAT, false, 0, vertexBuffer);
+          glVertexAttribPointer(aColorLocation, COLOR_COMPONENT_COUNT, GLES30.GL_FLOAT, false, 0, colorBuffer);
       }
   
       @Override
       public void onSurfaceChanged(GL10 gl, int width, int height) {
-          //设置绘制窗口
-          GLES30.glViewport(0, 0, width, height);
-  
-  
-          //相机和透视投影方式
-          //计算宽高比
-          float ratio=(float)width/height;
-          //设置透视投影
-          Matrix.frustumM(mProjectMatrix, 0, -ratio, ratio, -1, 1, 3, 7);
-          //设置相机位置
-          Matrix.setLookAtM(mViewMatrix, 0, 0, 0, 7.0f, 0f, 0f, 0f, 0f, 1.0f, 0.0f);
-          //计算变换矩阵
-          Matrix.multiplyMM(mMVPMatrix,0,mProjectMatrix,0,mViewMatrix,0);
-  
-  
-          /*//正交投影方式
-          final float aspectRatio = width > height ?
-                  (float) width / (float) height :
-                  (float) height / (float) width;
-          if (width > height) {
-              //横屏
-              Matrix.orthoM(mMVPMatrix, 0, -aspectRatio, aspectRatio, -1f, 1f, -1f, 1f);
-          } else {
-              //竖屏
-              Matrix.orthoM(mMVPMatrix, 0, -1f, 1f, -aspectRatio, aspectRatio, -1f, 1f);
-          }*/
+          glViewport(0, 0, width, height);
+          orthoM("u_Matrix", width, height);
       }
   
       @Override
       public void onDrawFrame(GL10 gl) {
-          //把颜色缓冲区设置为我们预设的颜色
-          GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT);
-  
-          //将变换矩阵传入顶点渲染器
-          GLES
-  0.glUniformMatrix4fv(uMatrixLocation,1,false,mMVPMatrix,0);
-          //准备坐标数据
-          GLES30.glVertexAttribPointer(aPositionLocation, 3, GLES30.GL_FLOAT, false, 0, vertexBuffer);
-          //启用顶点位置句柄
-          GLES30.glEnableVertexAttribArray(aPositionLocation);
-  
-          //准备颜色数据
-          GLES30.glVertexAttribPointer(aColorLocation, 4, GLES30.GL_FLOAT, false, 0, colorBuffer);
-          //启用顶点颜色句柄
-          GLES30.glEnableVertexAttribArray(aColorLocation);
-  
-          //绘制三角形
-          GLES30.glDrawElements(GL10.GL_TRIANGLES, indices.length, GL10.GL_UNSIGNED_SHORT, indicesBuffer);
-  
-          //禁止顶点数组的句柄
-          GLES30.glDisableVertexAttribArray(aPositionLocation);
-          GLES30.glDisableVertexAttribArray(aColorLocation);
+          glClear(GLES30.GL_COLOR_BUFFER_BIT);
+          glEnableVertexAttribArray(aPositionLocation);
+          glEnableVertexAttribArray(aColorLocation);
+          // 绘制相对复杂的图形时，若顶点有较多重复时，对比数据占用空间而言，glDrawElements会比glDrawArrays小很多，也会更高效
+          // 因为在有重复顶点的情况下，glDrawArrays方式需要的3个顶点位置是用Float型的，占3*4的Byte值；
+          // 而glDrawElements需要3个Short型的，占3*2Byte值
+          // 1. 图形绘制方式； 2. 绘制的顶点数； 3. 索引的数据格式； 4. 索引的数据Buffer
+          glDrawElements(GLES30.GL_TRIANGLES, INDEX_DATA.length,
+                  GLES30.GL_UNSIGNED_SHORT, indexBuffer);
+          glDisableVertexAttribArray(aPositionLocation);
+          glDisableVertexAttribArray(aColorLocation);
       }
   }
   ```
@@ -336,54 +332,31 @@
 其他也都和上面的一样，只有Render不同，如下:  
 
 ```java
-public class CircularRender implements GLSurfaceView.Renderer {
-    //一个Float占用4Byte
-    private static final int BYTES_PER_FLOAT = 4;
+public class CircleRender extends BaseGLSurfaceViewRenderer {
     //顶点位置缓存
     private final FloatBuffer vertexBuffer;
     //顶点颜色缓存
     private final FloatBuffer colorBuffer;
-    //渲染程序
-    private int mProgram;
-
-    //相机矩阵
-    private final float[] mViewMatrix = new float[16];
-    //投影矩阵
-    private final float[] mProjectMatrix = new float[16];
-    //最终变换矩阵
-    private final float[] mMVPMatrix = new float[16];
-
-    //返回属性变量的位置
-    //变换矩阵
-    private int uMatrixLocation;
     //位置
     private int aPositionLocation;
     //颜色
     private int aColorLocation;
 
-    //圆形顶点位置
-    private float circularCoords[];
-    //顶点的颜色
+    /**
+     * 坐标占用的向量个数
+     */
+    private static final int POSITION_COMPONENT_COUNT = 3;
+    private float circlePosition[];
+    /**
+     * 颜色占用的向量个数
+     */
+    private static final int COLOR_COMPONENT_COUNT = 4;
     private float color[];
 
-
-    public CircularRender() {
-        createPositions(1,60);
-
-        //顶点位置相关
-        //分配本地内存空间,每个浮点型占4字节空间；将坐标数据转换为FloatBuffer，用以传入给OpenGL ES程序
-        vertexBuffer = ByteBuffer.allocateDirect(circularCoords.length * BYTES_PER_FLOAT)
-                .order(ByteOrder.nativeOrder())
-                .asFloatBuffer();
-        vertexBuffer.put(circularCoords);
-        vertexBuffer.position(0);
-
-        //顶点颜色相关
-        colorBuffer = ByteBuffer.allocateDirect(color.length * BYTES_PER_FLOAT)
-                .order(ByteOrder.nativeOrder())
-                .asFloatBuffer();
-        colorBuffer.put(color);
-        colorBuffer.position(0);
+    public CircleRender() {
+        createPositions(1, 60);
+        vertexBuffer = BufferUtil.getFloatBuffer(circlePosition);
+        colorBuffer = BufferUtil.getFloatBuffer(color);
     }
 
     private void createPositions(int radius, int n){
@@ -402,7 +375,7 @@ public class CircularRender implements GLSurfaceView.Renderer {
             f[i]=data.get(i);
         }
 
-        circularCoords = f;
+        circlePosition = f;
 
         //处理各个顶点的颜色
         color = new float[f.length*4/3];
@@ -423,79 +396,28 @@ public class CircularRender implements GLSurfaceView.Renderer {
 
     @Override
     public void onSurfaceCreated(GL10 gl, EGLConfig config) {
-        //将背景设置为白色
-        GLES30.glClearColor(1.0f,1.0f,1.0f,1.0f);
-
-        //编译顶点着色程序
-        String vertexShaderStr = ResReadUtils.readResource(R.raw.vertex_simple_shade);
-        int vertexShaderId = ShaderUtils.compileVertexShader(vertexShaderStr);
-        //编译片段着色程序
-        String fragmentShaderStr = ResReadUtils.readResource(R.raw.fragment_simple_shade);
-        int fragmentShaderId = ShaderUtils.compileFragmentShader(fragmentShaderStr);
-        //连接程序
-        mProgram = ShaderUtils.linkProgram(vertexShaderId, fragmentShaderId);
-        //在OpenGLES环境中使用程序
-        GLES30.glUseProgram(mProgram);
-
-
-        uMatrixLocation = GLES30.glGetUniformLocation(mProgram, "u_Matrix");
-        aPositionLocation = GLES30.glGetAttribLocation(mProgram, "vPosition");
-        aColorLocation = GLES30.glGetAttribLocation(mProgram, "aColor");
+        glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
+        handleProgram(MyApplication.getInstance(), R.raw.iso_triangle_vertex_shader, R.raw.iso_triangle_fragment_shader);
+        aPositionLocation = glGetAttribLocation("vPosition");
+        aColorLocation = glGetAttribLocation("aColor");
+        glVertexAttribPointer(aPositionLocation, POSITION_COMPONENT_COUNT, GLES30.GL_FLOAT, false, 0, vertexBuffer);
+        glVertexAttribPointer(aColorLocation, COLOR_COMPONENT_COUNT, GLES30.GL_FLOAT, false, 0, colorBuffer);
     }
 
     @Override
     public void onSurfaceChanged(GL10 gl, int width, int height) {
-        //设置绘制窗口
-        GLES30.glViewport(0, 0, width, height);
-
-
-        //相机和透视投影方式
-        //计算宽高比
-        float ratio=(float)width/height;
-        //设置透视投影
-        Matrix.frustumM(mProjectMatrix, 0, -ratio, ratio, -1, 1, 3, 7);
-        //设置相机位置
-        Matrix.setLookAtM(mViewMatrix, 0, 0, 0, 7.0f, 0f, 0f, 0f, 0f, 1.0f, 0.0f);
-        //计算变换矩阵
-        Matrix.multiplyMM(mMVPMatrix,0,mProjectMatrix,0,mViewMatrix,0);
-
-
-        /*//正交投影方式
-        final float aspectRatio = width > height ?
-                (float) width / (float) height :
-                (float) height / (float) width;
-        if (width > height) {
-            //横屏
-            Matrix.orthoM(mMVPMatrix, 0, -aspectRatio, aspectRatio, -1f, 1f, -1f, 1f);
-        } else {
-            //竖屏
-            Matrix.orthoM(mMVPMatrix, 0, -1f, 1f, -aspectRatio, aspectRatio, -1f, 1f);
-        }*/
+        glViewport(0, 0, width, height);
+        orthoM("u_Matrix", width, height);
     }
 
     @Override
     public void onDrawFrame(GL10 gl) {
-        //把颜色缓冲区设置为我们预设的颜色
-        GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT);
-
-        //将变换矩阵传入顶点渲染器
-        GLES30.glUniformMatrix4fv(uMatrixLocation,1,false,mMVPMatrix,0);
-        //准备坐标数据
-        GLES30.glVertexAttribPointer(aPositionLocation, 3, GLES30.GL_FLOAT, false, 0, vertexBuffer);
-        //启用顶点位置句柄
-        GLES30.glEnableVertexAttribArray(aPositionLocation);
-
-        //准备颜色数据
-        GLES30.glVertexAttribPointer(aColorLocation, 4, GLES30.GL_FLOAT, false, 0, colorBuffer);
-        //启用顶点颜色句柄
-        GLES30.glEnableVertexAttribArray(aColorLocation);
-
-        //绘制圆形
-        GLES30.glDrawArrays(GLES30.GL_TRIANGLE_FAN, 0, circularCoords.length/3);
-
-        //禁止顶点数组的句柄
-        GLES30.glDisableVertexAttribArray(aPositionLocation);
-        GLES30.glDisableVertexAttribArray(aColorLocation);
+        glClear(GLES30.GL_COLOR_BUFFER_BIT);
+        glEnableVertexAttribArray(aPositionLocation);
+        glEnableVertexAttribArray(aColorLocation);
+        glDrawArrays(GLES30.GL_TRIANGLE_FAN, 0, circlePosition.length / POSITION_COMPONENT_COUNT);
+        glDisableVertexAttribArray(aPositionLocation);
+        glDisableVertexAttribArray(aColorLocation);
     }
 }
 ```
diff --git "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md" "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
index 008dc509..82df2b94 100644
--- "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
+++ "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
@@ -15,22 +15,23 @@ void main()
 }
 ```
 
+#version 300 es是表示GLSL语言的版本为300，对应的是OpenGL ES 3.0版本。
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_vertex_shader.jpg" style="zoom:80%;" />
+
 顶点着色器的输入包括:
 
-- 属性:用顶点数组提供的逐顶点数据
-- 统一变量和统一变量缓冲区:顶点着色器使用的不变数据
-- 采样器:代表顶点着色器使用的纹理的特殊统一变量类型
-- 着色器程序:顶点着色器程序源代码或者描述在操作顶点的可执行文件
+- 顶点着色器输入(或者属性):用顶点数组提供的每个顶点的数据。
+- 统一变量(uniform):顶点或片段着色器使用的不变的数据。
+- 采样器:代表顶点着色器使用纹理的特殊统一变量类型。
+- 着色器程序:描述顶点上执行操作的顶点着色器的程序源代码或可执行文件。
 
-顶点着色器的输出称作顶点着色器输出变量。在图元光栅化阶段，为每个生成的片段计算这些变量，并作为片段着色器的输入传入。
+顶点着色器的输出在OpenGL ES 2.0中称作可变(varying)变量，但在OpenGL ES 3.0中改名为顶点着色器输出(out)变量。在图元光栅化阶段，为每个生成的片段计算顶点着色器输出值，并作为输入传递给片段着色器。
 
 内建变量包括:
 
-- gl_VertexID: 一个输入变量，用于保存顶点的整数索引。
-- gl_InstanceID:一个输入变量，用于保存实例化绘图调用中图元的实例编号。
 - gl_Position:用于输出顶点位置的裁剪坐标。
 - gl_PointSize:用于写入以像素标示的点尺寸。
-- gl_FrontFacing:一个特殊变量，但不是由顶点着色器直接写入的，而是根据顶点着色器生成的位置值和渲染的图元类型生成的。
 
 ### 片段着色器:
 
@@ -46,28 +47,41 @@ void main()
 }
 ```
 
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_fragment_shader.jpg" style="zoom:80%;" />
+
 片段着色器为片段操作提供了通用功能的可编程方法。片段着色器的输入由以下部分组成:
 
-- 输入(或者可变值):顶点着色器生成的插值数据。顶点着色器输出跨图元进行插值，并作为输入传递给片段着色器。
-- 统一变量:片段着色器使用的状态，这些常量值在每个片段上不会变化。
-- 采样器:用于访问着色器中的纹理图像。
-- 代码:片段着色器源代码或者二进制代码，描述在片段上执行的操作。
+- 输入变量:光栅化单元用插值为每个片段生成的顶点着色器输出。
+- 统一变量:片段(或者顶点)着色器使用的不变的数据。
+- 采样器:代表顶点着色器使用纹理的特殊统一变量类型。
+- 着色器程序:描述顶点上执行操作的顶点着色器的程序源代码或可执行文件。
 
 片段着色器的输出是一个或者多个片段颜色，传递到管线的逐片段操作部分。
 
 内建变量: gl_FragCoord:片段着色器中的一个只读变量。这个变量保存片段的窗口相对坐标。
 
-这里需要重点讲一下上面的版本:   OpenGL ES版本有自己的着色器语言，其中OpenGL ES的版本与GLSL的版本有对应的关联关心:
+这里需要重点讲一下上面的版本:   OpenGL ES版本有自己的着色器语言，其中OpenGL ES的版本与GLSL的版本有对应的关联关系，如果没有在着色器文件中用#version标明使用版本的时候默认使用的是OpenGL ES 2.0版本（GLSL ES 100）:
 
 - OpenGL ES 2.0版本对应GLSL ES 100版本
 - OpenGL ES 3.0版本对应GLSL ES 300版本
 
 我们这里使用的都是GLSL ES 300版本。但是GLSL ES 100 和 300版本中间有一些差异，这就是为什么我们有时候网上的一些代码编译时却报错的原因:
 
-- GLSL ES 300版本中in和out代替了之前的属性和变化(attribute和varying)
-- texture()方法代替了之前的texture2D()方法
+- GLSL ES 300版本中in和out代替了之前的属性和变化(attribute和varying)，
+
+    OpenGL ES 3.0中将2.0的attribute改成了in，顶点着色器的varying改成out，片段着色器的varying改成了in，也就是说顶点着色器的输出就是片段着色器的输入，另外uniform跟2.0用法一样。
+
+- OpenGL ES 3.0的shader中没有texture2D()和texture3D等了，全部使用texture()方法替换。
+
 - 300版本中布局限定符可以声明顶点着色器输入和片段着色器输出的问题，例如layout(location = 2) in vec3 values[4];
-- 舍弃了gl_FragColor的内置属性，变成我们需要自己使用out关键字定义的属性，这就是为什么你从网还是哪个找到的代码换成GLSL ES 300版本后报错的原因。
+
+- 舍弃了gl_FragColor和gl_FragData内置属性，变成我们需要自己使用out关键字定义的属性，例如out vec4 fragColor，这就是为什么你从网还是哪个找到的代码换成GLSL ES 300版本后报错的原因。
+
+- GL_OES_EGL_image_external被废弃
+
+    当使用samplerExternalOES是，如果在\#extension GL_OES_EGL_image_external : require会报错，需要变成#extension GL_OES_EGL_image_external_essl3 : require
+
+- #version 300 es这种声明版本的语句，必须放到第一行，并且shader中不能有Tab键，只能用空格替换。
 
 
 
@@ -122,9 +136,9 @@ GLSL中的数据类型主要分为标量、向量、矩阵、采样器、结构
 
 - none：(默认的可省略)本地变量，可读可写，函数的输入参数既是这种类型
 - const：常量
-- attribute：一般用于各个顶点各不相同的量。如顶点颜色、坐标等。用于保存顶点或法线数据,它可以在数据缓冲区中读取数据，仅能用于顶点着色器
+- in：输入变量，一般用于各个顶点各不相同的量。如顶点颜色、坐标等。用于保存顶点或法线数据,它可以在数据缓冲区中读取数据，仅能用于顶点着色器。(GLSL 100 es版本中是attribute)
 - uniform：统一变量。统一变量存储应用程序通过OpenGL ES API传入着色器的只读值。在运行时 shader 无法改变 uniform 变量，一般用来放置程序传递给 shader 的变换矩阵，材质，光照参数等等，可用于顶点着色器和片元着色器。如果统一变量在顶点着色器和片段着色器中均有声明，则声明的类型必须相同，且两个着色器中的值也需要相同。
-- varying：易变量，用于修饰从顶点着色器向片元着色器传递的变量。一般是在光栅化图元的过程中计算生成，记录在每个片段中(而不是从顶点着色器直接传递给片元着色器)
+- out：输出变量，易变量，用于修饰从顶点着色器向片元着色器传递的变量。一般是在光栅化图元的过程中计算生成，记录在每个片段中(而不是从顶点着色器直接传递给片元着色器),(GLSL 100 es版本中是varying)
 
 
 
diff --git "a/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md" "b/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
index a820cc76..561cec8e 100644
--- "a/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
+++ "b/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
@@ -7,10 +7,11 @@ GLES作为我们与着色器连接的工具类提供了丰富的api。
 上一篇文章说到GLSL中的变量修饰符有以下部分:    
 
 - none：(默认的可省略)本地变量，可读可写，函数的输入参数既是这种类型
-- const：声明变量或函数的参数为只读类型
-- attribute：用于保存顶点或法线数据,它可以在数据缓冲区中读取数据，仅能用于顶点着色器(GLSL 200 es版本，在GLSL 300 es中已经被in替代)
-- uniform：在运行时 shader 无法改变 uniform 变量，一般用来放置程序传递给 shader 的变换矩阵，材质，光照参数等等，可用于顶点着色器和片元着色器
-- varying：用于修饰从顶点着色器向片元着色器传递的变量(仅能用GLSL 200 es版本，在GLSL 300 es中已经被out替代)
+- const：常量
+- in：输入变量，一般用于各个顶点各不相同的量。如顶点颜色、坐标等。用于保存顶点或法线数据,它可以在数据缓冲区中读取数据，仅能用于顶点着色器。
+- uniform：统一变量。统一变量存储应用程序通过OpenGL ES API传入着色器的只读值。在运行时 shader 无法改变 uniform 变量，一般用来放置程序传递给 shader 的变换矩阵，材质，光照参数等等，可用于顶点着色器和片元着色器。如果统一变量在顶点着色器和片段着色器中均有声明，则声明的类型必须相同，且两个着色器中的值也需要相同。
+- out：输出变量，易变量，用于修饰从顶点着色器向片元着色器传递的变量。一般是在光栅化图元的过程中计算生成，记录在每个片段中(而不是从顶点着色器直接传递给片元着色器)
+- OpenGL ES 2.0(GLSL 100 es)版本中是属性和变量分别是attribute，varying，在OpenGL ES 3.0中已经被in和out替代。
 
 了解一些常用API的意思能更方便后面的学习，这里就简单整理列了一些常用的部分:
 
@@ -115,13 +116,13 @@ GLES作为我们与着色器连接的工具类提供了丰富的api。
 
 ```
 // 将最终变换矩阵传入shader程序
-GLES20.glUniformMatrix4fv(muMVPMatrixHandle, 1, false, MatrixState.getFinalMatrix(), 0);
+GLES30.glUniformMatrix4fv(muMVPMatrixHandle, 1, false, MatrixState.getFinalMatrix(), 0);
 // 顶点位置数据传入着色器
-GLES20.glVertexAttribPointer(maPositionHandle, 3, GLES20.GL_FLOAT, false, 20, mRectBuffer);
+GLES30.glVertexAttribPointer(maPositionHandle, 3, GLES20.GL_FLOAT, false, 20, mRectBuffer);
 // 顶点颜色数据传入着色器中
-GLES20.glVertexAttribPointer(maColorHandle, 4, GLES20.GL_FLOAT, false, 4*4, mColorBuffer);
+GLES30.glVertexAttribPointer(maColorHandle, 4, GLES20.GL_FLOAT, false, 4*4, mColorBuffer);
 // 顶点坐标传递到顶点着色器
-GLES20.glVertexAttribPointer(maTextureHandle, 2, GLES20.GL_FLOAT, false, 20, mRectBuffer);
+GLES30.glVertexAttribPointer(maTextureHandle, 2, GLES20.GL_FLOAT, false, 20, mRectBuffer);
 ```
 
 ### 定义顶点属性数组
diff --git "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md" "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"
index efae153f..ce046283 100644
--- "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
+++ "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
@@ -8,7 +8,7 @@
 
 - 纹理Id:句柄，纹理的直接引用
 
-- 纹理单元:纹理的操作容器，有GL_TEXTURE0、GL_TEXTURE1、GL_TEXTURE2等，纹理单元的数量是有限的，最多16个。所以在最多只能同时操作16个纹理。在切换使用纹理单元的时候，使用glActiveTexture方法。也就是说OpenGL ES中内置了很多个纹理单元，并且是连续的，我们在使用的时候要选择其中一个，一般默认选择第一个(GLES_TEXTURE0)，并且如果不选的话OpenGL默认激活的也就是第一个纹理单元。激活纹理单元后需要把它和纹理Id绑定，然后再通过GLES30.glUniform1i()方法传递给着色器中。
+- 纹理单元:纹理的操作容器，有GL_TEXTURE0、GL_TEXTURE1、GL_TEXTURE2等，纹理单元的数量是有限的，最多16个。所以在最多只能同时操作16个纹理。在切换使用纹理单元的时候，使用glActiveTexture方法。也就是说OpenGL ES中内置了很多个纹理单元，并且是连续的，我们在使用的时候要选择其中一个，一般默认选择第一个(GLES_TEXTURE0)，并且如果不选的话OpenGL默认激活的也就是第一个纹理单元。采样器统一变量将加载一个指定纹理绑定的纹理单元的数值，例如，用数值0指定采样器表示从单元GL_TEXTURE0读取，指定数值1表示从GL_TEXTURE1读取，以此类推。激活纹理单元后需要把它和纹理Id绑定，然后再通过GLES30.glUniform1i()方法传递给着色器中的采样器。
 
 - 纹理目标:一个纹理单元中包含了多个类型的纹理目标，有GL_TEXTURE_1D、GL_TEXTURE_2D、CUBE_MAP等。本章中，将纹理ID绑定到纹理单元0的GL_TEXTURE_2D纹理目标上，之后对纹理目标的操作都是对纹理Id对应的数据进行操作。
 
@@ -30,10 +30,6 @@ OpenGL中，2D纹理也有自己的坐标体系，取值范围在(0,0)到(1,1)
 
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_texture_position.jpg)
 
-### 纹理尺寸
-
-在OpenGL ES 2.0中规定，纹理的每个维度必须是2次幂，也就是2、4、8....等等，纹理的最大值上限通常比较大，例如2048*2048。
-
 ### 文件读取
 
 OpenGL不能直接加载jpg或者png这类被编码的压缩格式，需要加载原始数据，也就是bitmap。我们在内置图片到工程中，应该将图片放到drawable-nodpi中，避免读取时被压缩，通过BitmapFactory解码读取图片时，要设置为非缩放的方式，即options.isScaled=false。
@@ -67,12 +63,37 @@ OpenGL不能直接加载jpg或者png这类被编码的压缩格式，需要加
 下面是一个工具类方法，相对通用，能解决大部分需求，这个方法可以将内置的图片资源加载出对应的纹理ID。
 
  ```java
-/**
- * 纹理加载助手类
- */
-public class TextureHelper {
+public class TextureUtil {
     private static final String TAG = "TextureHelper";
 
+    public static int createOESTextureId(){
+        int[] textures = new int[1];
+        GLES20.glGenTextures(1, textures, 0);
+        GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, textures[0]);
+
+        GLES20.glTexParameterf(
+                GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
+                GLES20.GL_TEXTURE_MIN_FILTER,
+                GLES20.GL_LINEAR
+        );
+        GLES20.glTexParameterf(
+                GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
+                GLES20.GL_TEXTURE_MAG_FILTER,
+                GLES20.GL_LINEAR
+        );
+        GLES20.glTexParameteri(
+                GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
+                GLES20.GL_TEXTURE_WRAP_S,
+                GLES20.GL_CLAMP_TO_EDGE
+        );
+        GLES20.glTexParameteri(
+                GLES11Ext.GL_TEXTURE_EXTERNAL_OES,
+                GLES20.GL_TEXTURE_WRAP_T,
+                GLES20.GL_CLAMP_TO_EDGE
+        );
+
+        return textures[0];
+    }
     /**
      * 根据资源ID获取相应的OpenGL纹理ID，若加载失败则返回0
      * <br>必须在GL线程中调用
@@ -84,9 +105,7 @@ public class TextureHelper {
         GLES20.glGenTextures(1, textureObjectIds, 0);
 
         if (textureObjectIds[0] == 0) {
-            if (LoggerConfig.ON) {
-                Log.w(TAG, "Could not generate a new OpenGL texture object.");
-            }
+            Log.w(TAG, "Could not generate a new OpenGL texture object.");
             return bean;
         }
 
@@ -97,19 +116,17 @@ public class TextureHelper {
                 context.getResources(), resourceId, options);
 
         if (bitmap == null) {
-            if (LoggerConfig.ON) {
-                Log.w(TAG, "Resource ID " + resourceId + " could not be decoded.");
-            }
+            Log.w(TAG, "Resource ID " + resourceId + " could not be decoded.");
             // 加载Bitmap资源失败，删除纹理Id
-            GLES30.glDeleteTextures(1, textureObjectIds, 0);
+            GLES20.glDeleteTextures(1, textureObjectIds, 0);
             return bean;
         }
         // 2. 将纹理绑定到OpenGL对象上
-        GLES30.glBindTexture(GLES20.GL_TEXTURE_2D, textureObjectIds[0]);
+        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, textureObjectIds[0]);
 
         // 3. 设置纹理过滤参数:解决纹理缩放过程中的锯齿问题。若不设置，则会导致纹理为黑色
-        GLES30.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR_MIPMAP_LINEAR);
-        GLES30.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
+        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR_MIPMAP_LINEAR);
+        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
         // 4. 通过OpenGL对象读取Bitmap数据，并且绑定到纹理对象上，之后就可以回收Bitmap对象
         GLUtils.texImage2D(GLES20.GL_TEXTURE_2D, 0, bitmap, 0);
 
@@ -128,7 +145,7 @@ public class TextureHelper {
         bean.setHeight(bitmap.getHeight());
         bitmap.recycle();
 
-        // 7. 将纹理从OpenGL对象上解绑
+        // 7. 将纹理从OpenGL对象上解绑，现在OpenGL已经完成了纹理的加载，不需要再绑定此纹理了，后面使用此纹理时通过纹理对象的ID即可
         GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, 0);
 
         // 所以整个流程中，OpenGL对象类似一个容器或者中间者的方式，将Bitmap数据转移到OpenGL纹理上
@@ -210,7 +227,7 @@ public class TextureHelper {
   in vec2 vTexCoord;
   out vec4 vFragColor;
   void main() {
-  		// 100 es版本中是texture2D，texture函数会将传进来的纹理和坐标进行差值采样，输出到颜色缓冲区。
+      // 100 es版本中是texture2D，texture函数会将传进来的纹理和坐标进行差值采样，输出到颜色缓冲区。
       vFragColor = texture(uTextureUnit,vTexCoord);
   }
   ```
@@ -224,37 +241,27 @@ public class TextureHelper {
   纹理的绘制:  
 
   ```
-          //激活纹理，设置当前活动的纹理单元为单元0
-          GLES30.glActiveTexture(GLES30.GL_TEXTURE0);
-          //绑定纹理，将纹理id绑定到当前活动的纹理单元上
-          GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, textureId);
-          // 将纹理单元传递片段着色器的u_TextureUnit
-          GLES20.glUniform1i(aTextureLocation, 0);
+  //激活纹理，设置当前活动的纹理单元为单元0
+  GLES30.glActiveTexture(GLES30.GL_TEXTURE0);
+  //绑定纹理，将纹理id绑定到当前活动的纹理单元上
+  GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, textureId);
+  // 将纹理单元传递片段着色器的采样器u_TextureUnit，0就代表GL_TEXTURE0， 1代表GL_TEXTURE1，以此类推
+  GLES20.glUniform1i(aTextureLocation, 0);
   ```
 
-  
+  这里有没有很奇怪，sampler2D的变量是uniform的，但是我们并不是用glUniform()方法给他赋值，而是使用glUniform1i()。这事因为可以给纹理采样器分配一个位置值，这样我们就能够在一个片段着色器中设置多个纹理单元。一个纹理的话，纹理单元是默认为0，它是默认激活的，纹理单元的主要目的就是给着色器多一个使用的纹理。通过纹理单元赋值给采样器，我们可以一次绑定多个纹理，只要我们在使用的时候激活纹理。
 
   
 
   ```java
-  public class TextureRender implements GLSurfaceView.Renderer {
-      //一个Float占用4Byte
-      private static final int BYTES_PER_FLOAT = 4;
-      //顶点位置缓存
-      private final FloatBuffer vertexBuffer;
-      //顶点颜色缓存
+  public class TextureRender extends BaseGLSurfaceViewRenderer {
+      private final FloatBuffer vertextBuffer;
       private final FloatBuffer textureBuffer;
-      //渲染程序
-      private int mProgram;
   
-      //返回属性变量的位置
-      //变换矩阵
-      private int uMatrixLocation;
-      //位置
+      private int textureId;
       private int aPositionLocation;
-      //颜色
       private int aTextureLocation;
-      private int textureId;
+      private int uSamplerTextureLocation;
   
       /**
        * 坐标占用的向量个数
@@ -263,9 +270,9 @@ public class TextureHelper {
       // 逆时针顺序排列
       private static final float[] POINT_DATA = {
               -0.5f, -0.5f,
-              0.5f, -0.5f,
               -0.5f, 0.5f,
               0.5f, 0.5f,
+              0.5f, -0.5f,
       };
       /**
        * 颜色占用的向量个数
@@ -274,100 +281,54 @@ public class TextureHelper {
       // 纹理坐标(s, t)，t坐标方向和顶点y坐标反着
       private static final float[] TEXTURE_DATA = {
               0.0f, 1.0f,
-              1.0f, 1.0f,
               0.0f, 0.0f,
-              1.0f, 0.0f
+              1.0f, 0.0f,
+              1.0f, 1.0f
       };
-      private final float[] mProjectionMatrix = new float[16];
   
       public TextureRender() {
-          //顶点位置相关
-          //分配本地内存空间,每个浮点型占4字节空间；将坐标数据转换为FloatBuffer，用以传入给OpenGL ES程序
-          vertexBuffer = ByteBuffer.allocateDirect(POINT_DATA.length * BYTES_PER_FLOAT)
-                  .order(ByteOrder.nativeOrder())
-                  .asFloatBuffer();
-          vertexBuffer.put(POINT_DATA);
-          vertexBuffer.position(0);
-  
-          //顶点颜色相关
-          textureBuffer = ByteBuffer.allocateDirect(TEXTURE_DATA.length * BYTES_PER_FLOAT)
-                  .order(ByteOrder.nativeOrder())
-                  .asFloatBuffer();
-          textureBuffer.put(TEXTURE_DATA);
-          textureBuffer.position(0);
+          vertextBuffer = BufferUtil.getFloatBuffer(POINT_DATA);
+          textureBuffer = BufferUtil.getFloatBuffer(TEXTURE_DATA);
       }
   
       @Override
       public void onSurfaceCreated(GL10 gl, EGLConfig config) {
-          //将背景设置为白色
-          GLES30.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
-  
-          //编译顶点着色程序
-          String vertexShaderStr = ResReadUtils.readResource(R.raw.texture_vertex_simple_shade);
-          int vertexShaderId = ShaderUtils.compileVertexShader(vertexShaderStr);
-          //编译片段着色程序
-          String fragmentShaderStr = ResReadUtils.readResource(R.raw.texture_fragment_simple_shade);
-          int fragmentShaderId = ShaderUtils.compileFragmentShader(fragmentShaderStr);
-          //连接程序
-          mProgram = ShaderUtils.linkProgram(vertexShaderId, fragmentShaderId);
-          //在OpenGLES环境中使用程序
-          GLES30.glUseProgram(mProgram);
-  
-  				// 获取这三个属性在着色器中的属性位置
-          uMatrixLocation = GLES30.glGetUniformLocation(mProgram, "u_Matrix");
-          aPositionLocation = GLES30.glGetAttribLocation(mProgram, "vPosition");
-          aTextureLocation = GLES30.glGetAttribLocation(mProgram, "aTextureCoord");
-          // 将图片加载进来生成位图
-          textureId = TextureHelper.loadTexture(MyApplication.getInstance(), R.drawable.img).getTextureId();
+          glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
+          handleProgram(MyApplication.getInstance(), R.raw.texture_vertex_shader, R.raw.texture_fragment_shader);
+          aPositionLocation = glGetAttribLocation("vPosition");
+          aTextureLocation = glGetAttribLocation("aTextureCoord");
+          uSamplerTextureLocation = glGetUniformLocation("uTextureUnit");
+          textureId = TextureUtil.loadTexture(MyApplication.getInstance(), R.drawable.img).getTextureId();
+          glVertexAttribPointer(aPositionLocation, POSITION_COMPONENT_COUNT, GLES30.GL_FLOAT, false, 0, vertextBuffer);
+          glVertexAttribPointer(aTextureLocation, TEXTURE_COMPONENT_COUNT, GLES30.GL_FLOAT, false, 0, textureBuffer);
       }
   
       @Override
       public void onSurfaceChanged(GL10 gl, int width, int height) {
-          //设置绘制窗口
-          GLES30.glViewport(0, 0, width, height);
-          //正交投影方式
-          final float aspectRatio = width > height ?
-                  (float) width / (float) height :
-                  (float) height / (float) width;
-          if (width > height) {
-              //横屏
-              Matrix.orthoM(mProjectionMatrix, 0, -aspectRatio, aspectRatio, -1f, 1f, -1f, 1f);
-          } else {
-              //竖屏
-              Matrix.orthoM(mProjectionMatrix, 0, -1f, 1f, -aspectRatio, aspectRatio, -1f, 1f);
-          }
+          glViewport(0, 0, width, height);
+          orthoM("u_Matrix", width, height);
       }
   
       @Override
       public void onDrawFrame(GL10 gl) {
-          //把颜色缓冲区设置为我们预设的颜色
-          GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT);
-  
-          //将变换矩阵传入顶点渲染器
-          GLES30.glUniformMatrix4fv(uMatrixLocation, 1, false, mProjectionMatrix, 0);
-          //传入坐标数据
-          GLES30.glVertexAttribPointer(aPositionLocation, POSITION_COMPONENT_COUNT, GLES30.GL_FLOAT, false, 0, vertexBuffer);
-          //启用顶点位置句柄
-          GLES30.glEnableVertexAttribArray(aPositionLocation);
-  
-          //传入颜色数据
-          GLES30.glVertexAttribPointer(aTextureLocation, TEXTURE_COMPONENT_COUNT, GLES30.GL_FLOAT, false, 0, textureBuffer);
-          //启用顶点颜色句柄
-          GLES30.glEnableVertexAttribArray(aTextureLocation);
-  
-          //激活纹理
-          GLES30.glActiveTexture(GLES30.GL_TEXTURE0);
-          //绑定纹理
-          GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, textureId);
-          // 把着色里面的采样器统一变量sample设置为0
-          GLES20.glUniform1i(aTextureLocation, 0);
-  
-  
-          // 开始绘制
-          GLES30.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, POINT_DATA.length / POSITION_COMPONENT_COUNT);
-          //禁止顶点数组的句柄
-          GLES30.glDisableVertexAttribArray(aPositionLocation);
-          GLES30.glDisableVertexAttribArray(aTextureLocation);
+          glClear(GLES30.GL_COLOR_BUFFER_BIT);
+          /****************/
+          // 中间这一部分代码的意思: 采样器统一变量将加载一个指定纹理绑定的纹理单元的数值，
+          // 例如，用数值0指定采样器表示从单元GL_TEXTURE0读取，指定数值1表示从GL_TEXTURE1读取，以此类推。
+          // 激活纹理单元后需要把它和纹理Id绑定，然后再通过GLES30.glUniform1i()方法传递给着色器中。
+  
+  
+          // 下面这两句表示纹理如何绑定到纹理单元。设置当前活动的纹理单元为纹理单元0，并将纹理ID绑定到当前活动的纹理单元上
+          glActiveTexture(GLES30.GL_TEXTURE0);
+          glBindTexture(GLES30.GL_TEXTURE_2D, textureId);
+          // 将采样器绑定到纹理单元，0就表示GLES30.GL_TEXTURE0
+          glUniform1i(uSamplerTextureLocation, 0);
+          /****************/
+          glEnableVertexAttribArray(aPositionLocation);
+          glEnableVertexAttribArray(aTextureLocation);
+          glDrawArrays(GLES30.GL_TRIANGLE_FAN, 0, POINT_DATA.length / POSITION_COMPONENT_COUNT);
+          glDisableVertexAttribArray(aPositionLocation);
+          glDisableVertexAttribArray(aTextureLocation);
       }
   }
   ```
@@ -380,173 +341,140 @@ public class TextureHelper {
 
 - 单纹理单元，多次绘制
 
-  多次调用glDrawArrays绘制纹理顶点的方式来实现，这样就是一张一张的按先后顺序，一层一层的绘制到当前的一帧画面。着色器与上面的完全一致，唯一不同的是要提供两个顶点位置的坐标，然后分别用这两个坐标调用两次glDrawArrays进行绘制
+  多次调用glDrawArrays绘制纹理顶点的方式来实现，这样就是一张一张的按先后顺序，一层一层的绘制到当前的一帧画面。着色器与上面的完全一致，唯一不同的是要提供两个顶点位置的坐标，然后分别设置这两个坐标，并绑定两次纹理，然后调用两次glDrawArrays进行绘制。
 
-  ```
-  public class TextureRender implements GLSurfaceView.Renderer {
-      //一个Float占用4Byte
-      private static final int BYTES_PER_FLOAT = 4;
-      //顶点位置缓存
-      private final FloatBuffer vertexBuffer;
-      private final FloatBuffer vertexBuffer2;
-      //顶点颜色缓存
+  ```java
+  public class MultiTextureRender extends BaseGLSurfaceViewRenderer {
+      private final FloatBuffer vertextBuffer;
+      private final FloatBuffer vertextBuffer2;
       private final FloatBuffer textureBuffer;
-      //渲染程序
-      private int mProgram;
   
-      //返回属性变量的位置
-      //变换矩阵
-      private int uMatrixLocation;
-      //位置
-      private int aPositionLocation;
-      //颜色
-      private int aTextureLocation;
       private int textureId;
       private int textureId2;
+      private int aPositionLocation;
+      private int aTextureLocation;
+      private int uSamplerTextureLocation;
   
       /**
        * 坐标占用的向量个数
        */
       private static final int POSITION_COMPONENT_COUNT = 2;
+      // 逆时针顺序排列
       private static final float[] POINT_DATA = {
               -1f, -1f,
-              1f, -1f,
               -1f, 1f,
               1f, 1f,
+              1f, -1f,
       };
   
       private static final float[] POINT_DATA2 = {
               -0.5f, -0.5f,
-              0.5f, -0.5f,
               -0.5f, 0.5f,
               0.5f, 0.5f,
+              0.5f, -0.5f,
       };
-  
       /**
        * 颜色占用的向量个数
        */
       private static final int TEXTURE_COMPONENT_COUNT = 2;
+      // 纹理坐标(s, t)，t坐标方向和顶点y坐标反着
       private static final float[] TEXTURE_DATA = {
               0.0f, 1.0f,
-              1.0f, 1.0f,
               0.0f, 0.0f,
-              1.0f, 0.0f
+              1.0f, 0.0f,
+              1.0f, 1.0f
       };
-      private final float[] mProjectionMatrix = new float[16];
   
-      public TextureRender() {
-          //顶点位置相关
-          //分配本地内存空间,每个浮点型占4字节空间；将坐标数据转换为FloatBuffer，用以传入给OpenGL ES程序
-          vertexBuffer = ByteBuffer.allocateDirect(POINT_DATA.length * BYTES_PER_FLOAT)
-                  .order(ByteOrder.nativeOrder())
-                  .asFloatBuffer();
-          vertexBuffer.put(POINT_DATA);
-          vertexBuffer.position(0);
-  
-          vertexBuffer2 = ByteBuffer.allocateDirect(POINT_DATA2.length * BYTES_PER_FLOAT)
-                  .order(ByteOrder.nativeOrder())
-                  .asFloatBuffer();
-          vertexBuffer2.put(POINT_DATA2);
-          vertexBuffer2.position(0);
-  
-          //顶点颜色相关
-          textureBuffer = ByteBuffer.allocateDirect(TEXTURE_DATA.length * BYTES_PER_FLOAT)
-                  .order(ByteOrder.nativeOrder())
-                  .asFloatBuffer();
-          textureBuffer.put(TEXTURE_DATA);
-          textureBuffer.position(0);
+      public MultiTextureRender() {
+          vertextBuffer = BufferUtil.getFloatBuffer(POINT_DATA);
+          vertextBuffer2 = BufferUtil.getFloatBuffer(POINT_DATA2);
+          textureBuffer = BufferUtil.getFloatBuffer(TEXTURE_DATA);
       }
   
       @Override
       public void onSurfaceCreated(GL10 gl, EGLConfig config) {
-          //将背景设置为白色
-          GLES30.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
-  
-          //编译顶点着色程序
-          String vertexShaderStr = ResReadUtils.readResource(R.raw.texture_vertex_simple_shade);
-          int vertexShaderId = ShaderUtils.compileVertexShader(vertexShaderStr);
-          //编译片段着色程序
-          String fragmentShaderStr = ResReadUtils.readResource(R.raw.texture_fragment_simple_shade);
-          int fragmentShaderId = ShaderUtils.compileFragmentShader(fragmentShaderStr);
-          //连接程序
-          mProgram = ShaderUtils.linkProgram(vertexShaderId, fragmentShaderId);
-          //在OpenGLES环境中使用程序
-          GLES30.glUseProgram(mProgram);
-  
-          uMatrixLocation = GLES30.glGetUniformLocation(mProgram, "u_Matrix");
-          aPositionLocation = GLES30.glGetAttribLocation(mProgram, "vPosition");
-          aTextureLocation = GLES30.glGetAttribLocation(mProgram, "aTextureCoord");
-          textureId = TextureHelper.loadTexture(MyApplication.getInstance(), R.drawable.img).getTextureId();
-          textureId2 = TextureHelper.loadTexture(MyApplication.getInstance(), R.drawable.img).getTextureId();
+          glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
+          handleProgram(MyApplication.getInstance(), R.raw.texture_vertex_shader, R.raw.texture_fragment_shader);
+          aPositionLocation = glGetAttribLocation("vPosition");
+          aTextureLocation = glGetAttribLocation("aTextureCoord");
+          uSamplerTextureLocation = glGetUniformLocation("uTextureUnit");
+          textureId = TextureUtil.loadTexture(MyApplication.getInstance(), R.drawable.img).getTextureId();
+          textureId2 = TextureUtil.loadTexture(MyApplication.getInstance(), R.drawable.img).getTextureId();
       }
   
       @Override
       public void onSurfaceChanged(GL10 gl, int width, int height) {
-          //设置绘制窗口
-          GLES30.glViewport(0, 0, width, height);
-          //正交投影方式
-          final float aspectRatio = width > height ?
-                  (float) width / (float) height :
-                  (float) height / (float) width;
-          if (width > height) {
-              //横屏
-              Matrix.orthoM(mProjectionMatrix, 0, -aspectRatio, aspectRatio, -1f, 1f, -1f, 1f);
-          } else {
-              //竖屏
-              Matrix.orthoM(mProjectionMatrix, 0, -1f, 1f, -aspectRatio, aspectRatio, -1f, 1f);
-          }
+          glViewport(0, 0, width, height);
+          orthoM("u_Matrix", width, height);
       }
   
       @Override
       public void onDrawFrame(GL10 gl) {
-          //把颜色缓冲区设置为我们预设的颜色
-          GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT);
-  
-          //将变换矩阵传入顶点渲染器
-          GLES30.glUniformMatrix4fv(uMatrixLocation, 1, false, mProjectionMatrix, 0);
-          //准备坐标数据
-          GLES30.glVertexAttribPointer(aPositionLocation, POSITION_COMPONENT_COUNT, GLES30.GL_FLOAT,
-                  false, 0, vertexBuffer);
-          //启用顶点位置句柄
-          GLES30.glEnableVertexAttribArray(aPositionLocation);
-  
-          //准备颜色数据
-          GLES30.glVertexAttribPointer(aTextureLocation, TEXTURE_COMPONENT_COUNT, GLES30.GL_FLOAT,
-                  false, 0, textureBuffer);
-          //启用顶点颜色句柄
-          GLES30.glEnableVertexAttribArray(aTextureLocation);
-  
-          //激活纹理
-          GLES30.glActiveTexture(GLES30.GL_TEXTURE0);
-          //绑定纹理
-          GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, textureId);
-          // 将纹理单元传递片段着色器的u_TextureUnit
-          GLES30.glUniform1i(aTextureLocation, 0);
-          // 开始绘制
-          GLES30.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, POINT_DATA.length / POSITION_COMPONENT_COUNT);
-  
-  
-          //准备第二个纹理的坐标数据
+          glClear(GLES30.GL_COLOR_BUFFER_BIT);
+          glVertexAttribPointer(aPositionLocation, POSITION_COMPONENT_COUNT, GLES30.GL_FLOAT, false, 0, vertextBuffer);
+          glVertexAttribPointer(aTextureLocation, TEXTURE_COMPONENT_COUNT, GLES30.GL_FLOAT, false, 0, textureBuffer);
+          /****************/
+          // 中间这一部分代码的意思: 采样器统一变量将加载一个指定纹理绑定的纹理单元的数值，
+          // 例如，用数值0指定采样器表示从单元GL_TEXTURE0读取，指定数值1表示从GL_TEXTURE1读取，以此类推。
+          // 激活纹理单元后需要把它和纹理Id绑定，然后再通过GLES30.glUniform1i()方法传递给着色器中。
+  
+  
+          // 下面这两句表示纹理如何绑定到纹理单元。设置当前活动的纹理单元为纹理单元0，并将纹理ID绑定到当前活动的纹理单元上
+          glActiveTexture(GLES30.GL_TEXTURE0);
+          glBindTexture(GLES30.GL_TEXTURE_2D, textureId);
+          // 将采样器绑定到纹理单元，0就表示GLES30.GL_TEXTURE0
+          glUniform1i(uSamplerTextureLocation, 0);
+          /****************/
+          glEnableVertexAttribArray(aPositionLocation);
+          glEnableVertexAttribArray(aTextureLocation);
+          // 画第一次
+          glDrawArrays(GLES30.GL_TRIANGLE_FAN, 0, POINT_DATA.length / POSITION_COMPONENT_COUNT);
+  
+          //设置第二个纹理的坐标数据
           GLES30.glVertexAttribPointer(aPositionLocation, POSITION_COMPONENT_COUNT, GLES30.GL_FLOAT,
-                  false, 0, vertexBuffer2);
-          //启用顶点位置句柄
-          GLES30.glEnableVertexAttribArray(aPositionLocation);
+                  false, 0, vertextBuffer2);
           //绑定纹理，前面已经激活了，就不用再调了
           GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, textureId2);
-          GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, POINT_DATA.length / POSITION_COMPONENT_COUNT);
-  
-          //禁止顶点数组的句柄
-          GLES30.glDisableVertexAttribArray(aPositionLocation);
-          GLES30.glDisableVertexAttribArray(aTextureLocation);
+          // 画第二次
+          glDrawArrays(GLES30.GL_TRIANGLE_FAN, 0, POINT_DATA2.length / POSITION_COMPONENT_COUNT);
+          glDisableVertexAttribArray(aPositionLocation);
+          glDisableVertexAttribArray(aTextureLocation);
       }
-  }
   ```
-
   
-
+  
+  
 - 多纹理单元，单词绘制
 
-  OpenGL可以同时操作的纹理单元是16个，那么我们可以利用多个纹理单元来进行绘制同一个图层，从而达到目的。
+  OpenGL可以同时操作的纹理单元是16个，那么我们可以利用多个纹理单元来进行绘制同一个图层，从而达到目的。多纹理单元需要修改片段着色器的代码，顶点着色器不用改变，这种方式的优点是可以控制多个纹理的关系，做出复杂的效果。缺点是多个纹理单元的顶点坐标必须是一样的。
+  
+  片段着色器代码增加一个纹理采样器(multi2_texture_fragment_shader.glsl):
+  
+  ```glsl
+  #version 300 es
+  precision mediump float;
+  // 采样器(sampler)是用于从纹理贴图读取的特殊统一变量。采样器统一变量将加载一个指定纹理绑定的纹理单元额数据，java代码里面需要把它设置为0
+  uniform sampler2D uTextureUnit;
+  uniform sampler2D uTextureUnit2;
+  // 接受刚才顶点着色器传入的纹理坐标(s, t)
+  in vec2 vTexCoord;
+  out vec4 vFragColor;
+  
+  void main() {
+      // 100 es版本中是texture2D，texture函数会将传进来的纹理和坐标进行差值采样，输出到颜色缓冲区。
+      vec4 texture1 = texture(uTextureUnit, vTexCoord);
+      vec4 texture2 = texture(uTextureUnit2, vTexCoord);
+      if (texture1.a != 0.0) {
+          vFragColor = texture1;
+      } else {
+          vFragColor = texture2;
+      }
+  }
+  ```
+  
+  
+  
+  
 
 
 

From 31a2ee357e15cfa29d7b853668a95db35a24ae39 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Tue, 24 Mar 2020 20:40:58 +0800
Subject: [PATCH 011/213] update

---
 .../1.OpenGL\347\256\200\344\273\213.md"      |  2 +-
 ...55\346\224\276\350\247\206\351\242\221.md" |  4 +-
 .../11.OpenGL ES\346\273\244\351\225\234.md"  | 29 ++++++-----
 ...20\347\240\201\350\247\243\346\236\220.md" | 35 +++++++------
 ....GLTextureView\345\256\236\347\216\260.md" | 14 +++---
 ...66\344\270\211\350\247\222\345\275\242.md" | 20 ++------
 ...42\345\217\212\345\234\206\345\275\242.md" |  3 +-
 ...45\231\250\350\257\255\350\250\200GLSL.md" |  2 +-
 ...\261\273\345\217\212Matrix\347\261\273.md" | 49 +++++++------------
 .../9.OpenGL ES\347\272\271\347\220\206.md"   |  4 +-
 10 files changed, 66 insertions(+), 96 deletions(-)

diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
index 30041c0d..ad360a9c 100644
--- "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -224,7 +224,7 @@ Android 框架中有如下两个基本类，用于通过 OpenGL ES API 来创建
 
 
 
-参考
+### 参考
 
 ---
 
diff --git "a/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md" "b/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
index a9ab7d17..da220e6f 100644
--- "a/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
+++ "b/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
@@ -17,7 +17,7 @@ GLSurfaceView -> setRender -> onSurfaceCreated回调方法中构造一个Surface
 
 - 顶点着色器
 
-  ```xml
+  ```glsl
   #version 300 es
   in vec4 vPosition;
   in vec2 vCoordPosition;
@@ -33,7 +33,7 @@ GLSurfaceView -> setRender -> onSurfaceCreated回调方法中构造一个Surface
 
   这里需要注意一下，就是做相机预览和视频播放的话，纹理的类型需要使用samplerExternalOES，而不是之前渲染图片的sampler2D。这是因为相机和视频的数据是YUV的，而OpenGL ES是RGB的，samplerExternalOES内部会进行处理。#extension用于启用和设置扩展的行为。格式为#extension all : behavior。behavior的可选值有: require、enable、warn、disable。
 
-  ```xml
+  ```glsl
   #version 300 es
   #extension GL_OES_EGL_image_external_essl3 : require
   precision mediump float;
diff --git "a/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md" "b/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"
index 6f2c3839..4d0adb8f 100644
--- "a/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"	
+++ "b/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"	
@@ -38,20 +38,6 @@ void main(){
 
 
 
-
-
-
-
-滤镜的编写主要是靠基类。
-
-- 先抽取BaseFilter类，封装好每个滤镜的着色器及onDraw等方法
-- 不同的滤镜集成该BaseFilter类
-- 在Renderder接口的实现类中去创建不同的Filter类，然后在onDrawFrame方法中去调用该filter.onDraw方法
-
-滤镜的不同大部分只需要修改片元着色器就可以了。
-
-
-
 ### 反色滤镜
 
 RGB三个通道的颜色取反，而alpha通道不变。
@@ -64,7 +50,7 @@ RGB三个通道的颜色取反，而alpha通道不变。
 
 纹理默认传入的读取范围是(0,0)到(1,1)内的颜色值。如果对读取的位置进行调整修改，那么就可以做出各种各样的效果，例如缩放动画就是让读取的范围改成(-1,-1)到(2,2)。
 
-## 看完了疯了是不是，要做个滤镜效果，各种计算我实在弄不明白
+### 看完了疯了是不是，要做个滤镜效果，各种计算我实在弄不明白
 
 最简单的方法就是通过LUT方法，通过设计师提供的LUT文件来实现预定的滤镜效果。基本思路如下：
 
@@ -86,9 +72,22 @@ RGB三个通道的颜色取反，而alpha通道不变。
 
 
 
+## 视频播放滤镜实现
 
+滤镜的编写主要是靠基类。
+
+- 先抽取BaseFilter类，封装好每个滤镜的着色器及onDraw等方法。
+- 不同的滤镜都继承该BaseFilter类，然后实现有区别的部分。其实每个不同滤镜的区别就是着色器的不同。
+- 在Renderder接口的实现类中去创建不同的Filter类，然后在onDrawFrame方法中去调用该filter.onDraw方法。
+
+滤镜的不同大部分只需要修改片元着色器就可以了。
 
+### 滤镜的基类
 
+- onCreate()：创建
+- onSizeChange()：滤镜尺寸改变
+- onDraw()：绘制每一帧
+- onDestroy()：销毁，用于资源回收。
 
 
 
diff --git "a/VideoDevelopment/OpenGL/3.GLSurfaceView\346\272\220\347\240\201\350\247\243\346\236\220.md" "b/VideoDevelopment/OpenGL/3.GLSurfaceView\346\272\220\347\240\201\350\247\243\346\236\220.md"
index d9cbc25a..d5c9e8ab 100644
--- "a/VideoDevelopment/OpenGL/3.GLSurfaceView\346\272\220\347\240\201\350\247\243\346\236\220.md"
+++ "b/VideoDevelopment/OpenGL/3.GLSurfaceView\346\272\220\347\240\201\350\247\243\346\236\220.md"
@@ -2,7 +2,7 @@
 
 我感觉还是先看一下源码，了解一下内部的流程，再接着学习其他的OpenGL部分会更合适。
 
-从上一篇文章中GLSurfaceView的使用中可以看到入口是setRenderer()方法，这里就卡一下setRenderder(Renderer renderer)方法的实现:  
+从上一篇文章中GLSurfaceView的使用中可以看到入口是setRenderer()方法，这里就看一下setRenderder(Renderer renderer)方法的实现:  
 
 - Renderer接口
 
@@ -50,7 +50,7 @@ public void setRenderer(Renderer renderer) {
               super();
               mWidth = 0;
               mHeight = 0;
-            	// 连续渲染模式下是true，如果是按需渲染模式就为false，然后通过requesetRender()方法来修改它的值
+              // 连续渲染模式下是true，如果是按需渲染模式就为false，然后通过requesetRender()方法来修改它的值
               mRequestRender = true;
               // 默认的渲染模式
               mRenderMode = RENDERMODE_CONTINUOUSLY;
@@ -74,7 +74,7 @@ public void setRenderer(Renderer renderer) {
                   sGLThreadManager.threadExiting(this);
               }
           }
-    				// GLSurfaceView的onPause方法会调用到这里
+            // GLSurfaceView的onPause方法会调用到这里
             public void onPause() {
               synchronized (sGLThreadManager) {
                   if (LOG_PAUSE_RESUME) {
@@ -97,7 +97,7 @@ public void setRenderer(Renderer renderer) {
                   }
               }
           }
-  				 // GLSurfaceView的onResume方法会调用到这里
+          // GLSurfaceView的onResume方法会调用到这里
           public void onResume() {
               synchronized (sGLThreadManager) {
                   if (LOG_PAUSE_RESUME) {
@@ -135,7 +135,7 @@ public void setRenderer(Renderer renderer) {
 
   ```java
   private void guardedRun() throws InterruptedException {
-  						//GL帮助类，内部建立GL环境
+              //GL帮助类，内部建立GL环境
               mEglHelper = new EglHelper(mGLSurfaceViewWeakRef);
               mHaveEglContext = false;
               mHaveEglSurface = false;
@@ -159,16 +159,15 @@ public void setRenderer(Renderer renderer) {
                   while (true) {
                       synchronized (sGLThreadManager) {
                           while (true) {
-                          		// 外部请求退出
+                              // 外部请求退出
                               if (mShouldExit) {
                                   return;
-                              }
-  														// 如果还有GL线程中要处理的事件没处理完，就先处理事件
+                              // 如果还有GL线程中要处理的事件没处理完，就先处理事件
                               if (! mEventQueue.isEmpty()) {
                                   event = mEventQueue.remove(0);
                                   break;
                               }
-  														// 更新onResume和onPause时的状态变化
+                              // 更新onResume和onPause时的状态变化
                               // Update the pause state.
                               boolean pausing = false;
                               if (mPaused != mRequestPaused) {
@@ -180,7 +179,7 @@ public void setRenderer(Renderer renderer) {
                                       Log.i("GLThread", "mPaused is now " + mPaused + " tid=" + getId());
                                   }
                               }
-  														// 需要释放EGLContext
+                              // 需要释放EGLContext
                               // Do we need to give up the EGL context?
                               if (mShouldReleaseEglContext) {
                                   if (LOG_SURFACE) {
@@ -191,14 +190,14 @@ public void setRenderer(Renderer renderer) {
                                   mShouldReleaseEglContext = false;
                                   askedToReleaseEglContext = true;
                               }
-  		                        // 如果EGLContext丢失，需要销毁EGLSurface和EGLContext
+  		                    // 如果EGLContext丢失，需要销毁EGLSurface和EGLContext
                               // Have we lost the EGL context?
                               if (lostEglContext) {
                                   stopEglSurfaceLocked();
                                   stopEglContextLocked();
                                   lostEglContext = false;
                               }
-  														// 如果onPause了并且当前GLSurface已经存在了，就销毁EGLSurface
+                              // 如果onPause了并且当前GLSurface已经存在了，就销毁EGLSurface
                               // When pausing, release the EGL surface:
                               if (pausing && mHaveEglSurface) {
                                   if (LOG_SURFACE) {
@@ -206,7 +205,7 @@ public void setRenderer(Renderer renderer) {
                                   }
                                   stopEglSurfaceLocked();
                               }
-  														// 接受了onPuase信号，并且当前EGLContext存在时，需要根据用户的设置来决定是否销毁EGLContext
+                              // 接受了onPuase信号，并且当前EGLContext存在时，需要根据用户的设置来决定是否销毁EGLContext
                               // When pausing, optionally release the EGL Context:
                               if (pausing && mHaveEglContext) {
                                   GLSurfaceView view = mGLSurfaceViewWeakRef.get();
@@ -256,10 +255,10 @@ public void setRenderer(Renderer renderer) {
                                   finishDrawingRunnable = mFinishDrawingRunnable;
                                   mFinishDrawingRunnable = null;
                               }
-  														// readyToDraw()方法内部会判断是否已经pause或者mRequestRender是否是true以及是否是主动渲染模式。如果是被动渲染的模式mRequestRender就会是false，只有调用requestRender()方法后才会是true，如果是主动渲染模式readyToDraw()就不用根据mRequestRender来判断。
+                              // readyToDraw()方法内部会判断是否已经pause或者mRequestRender是否是true以及是否是主动渲染模式。如果是被动渲染的模式mRequestRender就会是false，只有调用requestRender()方法后才会是true，如果是主动渲染模式readyToDraw()就不用根据mRequestRender来判断。
                               // Ready to draw?
                               if (readyToDraw()) {
-  																// 没有EGLContext就去调用EGLHelper来创建，第一次会走到这里先创建EGLContext
+                                  // 没有EGLContext就去调用EGLHelper来创建，第一次会走到这里先创建EGLContext
                                   // If we don't have an EGL context, try to acquire one.
                                   if (! mHaveEglContext) {
                                       if (askedToReleaseEglContext) {
@@ -332,7 +331,7 @@ public void setRenderer(Renderer renderer) {
                       }
   
                       if (createEglSurface) {
-  												// EglHelper创建EglSurface                      
+                          // EglHelper创建EglSurface                      
                           if (mEglHelper.createSurface()) {
                               synchronized(sGLThreadManager) {
                                   mFinishedCreatingEglSurface = true;
@@ -554,7 +553,7 @@ public void setRenderer(Renderer renderer) {
              */
             GLSurfaceView view = mGLSurfaceViewWeakRef.get();
             if (view != null) {
-            		// 也是通过EGLWindowSurfaceFactory来创建EGLSurface，如果没有设置就会调用默认的DefaultWindowSurfaceFactory。后面说一下这里
+            	// 也是通过EGLWindowSurfaceFactory来创建EGLSurface，如果没有设置就会调用默认的DefaultWindowSurfaceFactory。后面说一下这里
                 mEglSurface = view.mEGLWindowSurfaceFactory.createWindowSurface(mEgl,
                         mEglDisplay, mEglConfig, view.getHolder());
             } else {
@@ -619,7 +618,7 @@ public void setRenderer(Renderer renderer) {
                         EGL10.EGL_NO_CONTEXT);
                 GLSurfaceView view = mGLSurfaceViewWeakRef.get();
                 if (view != null) {
-                		// EGLWindowSurfaceFactory除了创建EGLSurface还有销毁的功能
+                	// EGLWindowSurfaceFactory除了创建EGLSurface还有销毁的功能
                     view.mEGLWindowSurfaceFactory.destroySurface(mEgl, mEglDisplay, mEglSurface);
                 }
                 mEglSurface = null;
diff --git "a/VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md" "b/VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md"
index 195b9e83..86affc03 100644
--- "a/VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md"
+++ "b/VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md"
@@ -12,14 +12,14 @@
   ```
 
 - ```java
-      @Override
-      public void setSurfaceTextureListener(SurfaceTextureListener listener) {
-          if (mRenderer == null) {
-              // 与普通TextureView一样
-              super.setSurfaceTextureListener(listener);
-          }
-          Log.e(TAG, "setSurfaceTextureListener preserved, setRenderer() instead?");
+  @Override
+  public void setSurfaceTextureListener(SurfaceTextureListener listener) {
+      if (mRenderer == null) {
+          // 与普通TextureView一样
+          super.setSurfaceTextureListener(listener);
       }
+      Log.e(TAG, "setSurfaceTextureListener preserved, setRenderer() instead?");
+  }
   ```
 
 ```java
diff --git "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md" "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"
index 624f5d0a..6e9adc89 100644
--- "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
@@ -152,17 +152,6 @@ Preferences -> Plugins -> 搜GLSL Support安装就可以了。
 
 
 
-### 编写GLSurfaceView.Render类
-
-主要有以下功能:  
-
-1. 声明绘制图形的坐标和颜色数据
-2. 为顶点位置及颜色申请本地内存
-3. 加载编译顶点着色器和片段着色器
-4. 创建program，连接顶点和片段着色器并链接program
-5. 设置窗口大小
-6. 完成绘制
-
 ```java
 public class TriangleActivity extends Activity {
     private GLSurfaceView mGlSurfaceView;
@@ -438,7 +427,7 @@ public class TriangleRender implements GLSurfaceView.Renderer {
 
 效果如下:   
 
-![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_tri.jpg)
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_tri.jpg" style="zoom:20%;" />
 
 我们设置的是数据来看，应该是等腰三角形，但是实际效果并不是，这是因为前面说到的OpenGL ES使用的是虚拟坐标导致的。如果想让绘制一个等腰三角形该怎么做呢？ 
 
@@ -499,8 +488,7 @@ int rmOffset, //变换矩阵的起始位置（偏移量）
 float eyeX,float eyeY, float eyeZ, //相机位置
 float centerX,float centerY,float centerZ,  //观测点位置
 float upX,float upY,float upZ)  //up向量在xyz上的分量) {
-
-------------省略代码-------------
+	...
 }
 ```
 
@@ -537,7 +525,7 @@ Android OpenGL ES的投影分为两种:
                   float top,//相对观察点近面的上边距
                   float near,//相对观察点近面距离
                   float far) //相对观察点远面距离{
-  		---------------省略代码--------------
+  		...
   	}
   ```
 
@@ -569,7 +557,7 @@ Android OpenGL ES的投影分为两种:
   				                float top, //相对观察点近面的上边距
   				                float near, //相对观察点近面距离
   				                float far) //相对观察点远面距离 {
-  			---------------省略代码--------------
+  			...
   	}
   ```
 
diff --git "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md" "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"
index a9ed80f0..37e1661c 100644
--- "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"	
@@ -422,8 +422,7 @@ public class CircleRender extends BaseGLSurfaceViewRenderer {
 }
 ```
 
-
-[上一篇: 5.OpenGL ES绘制三角形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/5.OpenGL%20ES%E7%BB%98%E5%88%B6%E4%B8%89%E8%A7%92%E5%BD%A2.md)
+[上一篇: 5.OpenGL ES绘制三角形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/5.OpenGL%20ES%E7%BB%98%E5%88%B6%E4%B8%89%E8%A7%92%E5%BD%A2.md)       
 [下一篇: 7.OpenGL ES着色器语言GLSL](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/7.OpenGL%20ES%E7%9D%80%E8%89%B2%E5%99%A8%E8%AF%AD%E8%A8%80GLSL.md)
 
 ---
diff --git "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md" "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
index 82df2b94..7e935fbd 100644
--- "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
+++ "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
@@ -203,7 +203,7 @@ GLSL的类型转换与C不同。在GLSL中类型不可以自动提升，比如fl
 - radians(x)：角度转弧度
 - degrees(x)：弧度转角度
 - sin(x)：正弦函数，传入值为弧度。相同的还有cos余弦函数、tan正切函数、asin反正弦、acos反余弦
-- atan反正切
+- atan()：反正切
 - pow(x,y)：xy
 - exp(x)：ex
 - exp2(x)：2x
diff --git "a/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md" "b/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
index 561cec8e..2eb24927 100644
--- "a/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
+++ "b/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
@@ -2,18 +2,7 @@
 
 
 
-GLES作为我们与着色器连接的工具类提供了丰富的api。
-
-上一篇文章说到GLSL中的变量修饰符有以下部分:    
-
-- none：(默认的可省略)本地变量，可读可写，函数的输入参数既是这种类型
-- const：常量
-- in：输入变量，一般用于各个顶点各不相同的量。如顶点颜色、坐标等。用于保存顶点或法线数据,它可以在数据缓冲区中读取数据，仅能用于顶点着色器。
-- uniform：统一变量。统一变量存储应用程序通过OpenGL ES API传入着色器的只读值。在运行时 shader 无法改变 uniform 变量，一般用来放置程序传递给 shader 的变换矩阵，材质，光照参数等等，可用于顶点着色器和片元着色器。如果统一变量在顶点着色器和片段着色器中均有声明，则声明的类型必须相同，且两个着色器中的值也需要相同。
-- out：输出变量，易变量，用于修饰从顶点着色器向片元着色器传递的变量。一般是在光栅化图元的过程中计算生成，记录在每个片段中(而不是从顶点着色器直接传递给片元着色器)
-- OpenGL ES 2.0(GLSL 100 es)版本中是属性和变量分别是attribute，varying，在OpenGL ES 3.0中已经被in和out替代。
-
-了解一些常用API的意思能更方便后面的学习，这里就简单整理列了一些常用的部分:
+GLES作为我们与着色器连接的工具类提供了丰富的api。了解一些常用API的意思能更方便后面的学习，这里就简单整理列了一些常用的部分:
 
 - glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
 
@@ -73,7 +62,7 @@ GLES作为我们与着色器连接的工具类提供了丰富的api。
 
 - void glGetVertexAttribPointerv(GLunit index, GLenum pname, GLvoid **pointer)
 
-  已**pointer返回指定的通用顶点属性的指针信息。参数index为要返回单额通用顶点属性采参数，pname是指定要返回的通用顶点属性参数的符号名称，必须是GL_VERTEX_ATTRIB_ARRAY_POINTER。
+  以**pointer返回指定的通用顶点属性的指针信息。参数index为要返回单额通用顶点属性采参数，pname是指定要返回的通用顶点属性参数的符号名称，必须是GL_VERTEX_ATTRIB_ARRAY_POINTER。
 
 - glLinkProgram(GLunit program)
 
@@ -145,21 +134,11 @@ GLES30.glVertexAttribPointer(maTextureHandle, 2, GLES20.GL_FLOAT, false, 20, mRe
 
 调用GLES30.glEnableVertexAttribArray和GLES30.glDisableVertexAttribArray传入参数index。如果启用，那么当GLES30.glDrawArrays或者GLES30.glDrawElements被调用时，顶点属性数组会被使用。
 
-### 选择活动纹理单元
-
-```
-void glActiveTexture(int texture)
-```
-
-texture指定哪一个纹理单元被置为活动状态。texture必须是GL_TEXTUREi之一，其中0 <= i < GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS，初始值为GL_TEXTURE0。
-GLES20.glActiveTexture()确定了后续的纹理状态改变影响哪个纹理，纹理单元的数量是依据该纹理单元所被支持的具体实现。
-
 ## Matrix
 
-而`Matrix就是专门设计出来帮助我们简化矩阵和向量运算操作的，里面所有的实现原理都是线性代数中的运算`。
+Matrix就是专门设计出来帮助我们简化矩阵和向量运算操作的，里面所有的实现原理都是线性代数中的运算。
 
-我们知道OpenGl中实现图形的操作大量使用了矩阵，在OpenGL中使用的向量为列向量，我们通过利用矩阵与列向量（颜色、坐标都可看做列向量）相乘，得到一个新的列向量。利用这点，我们构建一个的矩阵，与图形所有的顶点坐标坐标相乘，得到新的顶点坐标集合，当这个矩阵构造恰当的话，新得到的顶点坐标集合形成的图形相对原图形就会出现平移、旋转、缩放或拉伸、抑或扭曲的效果。
-`Matrix：专门为处理4*4矩阵和4元素向量设计的，其中的方法都是static的，不需要初始化Matrix实例`。
+我们知道OpenGl中实现图形的操作大量使用了矩阵，在OpenGL中使用的向量为列向量，我们通过利用矩阵与列向量（颜色、坐标都可看做列向量）相乘，得到一个新的列向量。利用这点，我们构建一个的矩阵，与图形所有的顶点坐标坐标相乘，得到新的顶点坐标集合，当这个矩阵构造恰当的话，新得到的顶点坐标集合形成的图形相对原图形就会出现平移、旋转、缩放或拉伸、抑或扭曲的效果。Matrix是专门为处理4*4矩阵和4元素向量设计的，其中的方法都是static的，不需要初始化Matrix实例。
 
 - multiplyMM
 
@@ -204,19 +183,25 @@ GLES20.glActiveTexture()确定了后续的纹理状态改变影响哪个纹理
 
   计算向量长度
 
-- setldentityM
+- setIdentityM(float[] sm, int smOffset)
+
+  用来创建一个单位矩阵。其中第一个参数是创建出来的单位矩阵存储的地方，是一个float类型的一维数组。第二个参数是存储的数据位置的偏移量，也就是说从哪里开始存储。生成的结果先按照列优先存储的，也就是说先存放第一列的数据，再存放第二列的数据，以此类推。前面理论部分已经提到，所有变换都是基于单位矩阵的基础上进行的，所以第一步创建单位矩阵是必须的。
 
-  创建单位矩阵
+- scaleM(float[] m, int mOffset,
+            float x, float y, float z)
 
-- scaleM
+    用来进行图像的缩放，第一个参数是需要变换的矩阵；第三、四、五个参数分别对应x,y,z 方向的缩放比例，当x方向缩放为0.5时，相当于向x方向缩放为原来的0.5倍，其他类似。
 
-- translateM
+- translateM(
+            float[] m, int mOffset,
+            float x, float y, float z)
 
-- rotateM
+    用来进行图像的位移，第一个参数是需要变换的矩阵；第二个参数是偏移量；第三、四、五个参数分别对应x,y,z 方向的位移量。其以图像自身x，y，z方向为单位，也就是说当x方向位移量为0.5时，相当于向右移动0.5个身位，其他类似。
 
-- setRotateM
+- rotateM(float[] m, int mOffset,
+            float a, float x, float y, float z)
 
-- setRotateEulerM
+    用来进行旋转变换的。第一个参数是需要变换的矩阵；第二参数是偏移量；第三个参数是旋转角度，这边是以角度制，也就是说是0-360这个范围；第四、五、六个参数分别代表旋转轴向量的x，y，z值。如果x=0，y=0,z = 1 就相当于以z轴为旋转轴进行旋转，其他类似。
 
 - setLookAtm
 
diff --git "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md" "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"
index ce046283..962345b9 100644
--- "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
+++ "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
@@ -8,7 +8,7 @@
 
 - 纹理Id:句柄，纹理的直接引用
 
-- 纹理单元:纹理的操作容器，有GL_TEXTURE0、GL_TEXTURE1、GL_TEXTURE2等，纹理单元的数量是有限的，最多16个。所以在最多只能同时操作16个纹理。在切换使用纹理单元的时候，使用glActiveTexture方法。也就是说OpenGL ES中内置了很多个纹理单元，并且是连续的，我们在使用的时候要选择其中一个，一般默认选择第一个(GLES_TEXTURE0)，并且如果不选的话OpenGL默认激活的也就是第一个纹理单元。采样器统一变量将加载一个指定纹理绑定的纹理单元的数值，例如，用数值0指定采样器表示从单元GL_TEXTURE0读取，指定数值1表示从GL_TEXTURE1读取，以此类推。激活纹理单元后需要把它和纹理Id绑定，然后再通过GLES30.glUniform1i()方法传递给着色器中的采样器。
+- 纹理单元:纹理的操作容器，有GL_TEXTURE0、GL_TEXTURE1、GL_TEXTURE2等，纹理单元的数量是有限的，最多16个。所以在最多只能同时操作16个纹理。在切换使用纹理单元的时候，使用glActiveTexture方法。也就是说OpenGL ES中内置了很多个纹理单元，并且是连续的，我们在使用的时候要选择其中一个，一般默认选择第一个(GLES_TEXTURE0)，并且如果不选的话OpenGL默认激活的也就是第一个纹理单元。采样器统一变量将加载一个指定纹理绑定的纹理单元的数值，例如，用数值0指定采样器表示从单元GL_TEXTURE0读取，指定数值1表示从GL_TEXTURE1读取，以此类推。激活纹理单元后需要把它和纹理Id绑定，然后再通过GLES30.glUniform1i()方法将纹理单元，与GLSL中的采样器属性相关联。
 
 - 纹理目标:一个纹理单元中包含了多个类型的纹理目标，有GL_TEXTURE_1D、GL_TEXTURE_2D、CUBE_MAP等。本章中，将纹理ID绑定到纹理单元0的GL_TEXTURE_2D纹理目标上，之后对纹理目标的操作都是对纹理Id对应的数据进行操作。
 
@@ -221,7 +221,7 @@ public class TextureUtil {
   ```
   #version 300 es
   precision mediump float;
-  // 采样器(sampler)是用于从纹理贴图读取的特殊统一变量。采样器统一变量将加载一个指定纹理绑定的纹理单元额数据，java代码里面需要把它设置为0
+  // 采样器(sampler)是用于从纹理贴图读取的特殊统一变量。采样器统一变量将加载一个指定纹理绑定的纹理单元额数据，java代码里面需要把它设置为纹理单元对应的index值。
   uniform sampler2D uTextureUnit;
   //接收刚才顶点着色器传入的纹理坐标(s,t)
   in vec2 vTexCoord;

From e17d6201c8ee6abd29d6d60a5ee5b805e59741dd Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 25 Mar 2020 21:50:53 +0800
Subject: [PATCH 012/213] update

---
 "JavaKnowledge/Git\347\256\200\344\273\213.md" | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git "a/JavaKnowledge/Git\347\256\200\344\273\213.md" "b/JavaKnowledge/Git\347\256\200\344\273\213.md"
index f98977be..98287ca2 100644
--- "a/JavaKnowledge/Git\347\256\200\344\273\213.md"
+++ "b/JavaKnowledge/Git\347\256\200\344\273\213.md"
@@ -259,6 +259,14 @@ git push  // 把所有文件从本地仓库推送进远程仓库
     执行`git reset --hard origin/master`还是`git reset --hard`命令，只不过这次多了一个参数`origin/master`，这代表远程仓库，既然本地仓库已经有了
     你提交的脏代码，那么就从远程仓库中把代码恢复把。   
 
+    但是上面这样会导致你之前修改的代码都没有了，如果我只是想撤回提交，还想要我之前修改的东西重新回到本地仓库呢？ 
+    `git reset --soft HEAD^`，这样就成功的撤销了你的commit。注意，仅仅是撤回commit操作，您写的代码仍然保留。
+
+    至于这几个参数：
+    1. --mixed：不删除工作空间改动代码，撤销commit，并且撤销git add . 操作这个为默认参数,git reset --mixed HEAD^ 和 git reset HEAD^ 效果是一样的。
+    2. --soft：不删除工作空间改动代码，撤销commit，不撤销git add . 
+    3. --hard：删除工作空间改动代码，撤销commit，撤销git add . 注意完成这个操作后，就恢复到了上一次的commit状态。
+
 - 已推送到远程仓库  
     如果你执行`git add .`后又`commit`又执行了`git push`操作了，这时候你的代码已经进入到了远程仓库中，如果你发现你提交的代码又问题想恢复的话，那你只能先把本地仓库的
     代码恢复，然后再强制执行`git push`仓做，`push`到远程仓库就可以了。    

From 2075581d87f30eb2de51b83688c550f2b5255a3c Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 26 Mar 2020 21:23:50 +0800
Subject: [PATCH 013/213] update

---
 ...55\346\224\276\350\247\206\351\242\221.md" | 184 +++++++++++++++++-
 .../11.OpenGL ES\346\273\244\351\225\234.md"  |   2 +-
 2 files changed, 178 insertions(+), 8 deletions(-)

diff --git "a/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md" "b/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
index da220e6f..88ca3e35 100644
--- "a/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
+++ "b/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
@@ -58,13 +58,8 @@ public class VideoPlayerActivity extends Activity {
     @Override
     protected void onCreate(@Nullable Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
-        mGLSurfaceView = new GLSurfaceView(this);
-        Display display = getWindowManager().getDefaultDisplay();
-        int width = display.getWidth();
-        int height = (int) ((width) * (9 / 16f));
-        ViewGroup.LayoutParams layoutParams = new ViewGroup.LayoutParams(width, height);
-        mGLSurfaceView.setLayoutParams(layoutParams);
-        setContentView(mGLSurfaceView);
+        setContentView(R.layout.activity_video_player);
+        mGLSurfaceView = findViewById(R.id.mGLSurfaceView);
         mGLSurfaceView.setEGLContextClientVersion(3);
         VideoPlayerRender videoPlayerRender = new VideoPlayerRender(mGLSurfaceView);
         videoPlayerRender.setIVideoTextureRenderListener(new VideoPlayerRender.IVideoTextureRenderListener() {
@@ -149,9 +144,184 @@ public class VideoPlayerActivity extends Activity {
 
 ### 修复变形
 
+我们要根据视频的宽高和Render中Surface的宽高来计算缩放的比例，让高度或者宽度进行缩放，这样就不会变形了。主要修改的地方就是通过换算这个比例然后根据这个比例来改变顶点渲染器中的点的坐标值，从而让其在换算后的坐标内开始画面，这样就不会变形了。
+
+下面是改动后的VideoPlayerRender类:   
+
+```java
+public class VideoPlayerRender extends BaseGLSurfaceViewRenderer {
+    private int mTextureId;
+    private SurfaceTexture mSurfaceTexture;
+    private GLSurfaceView mGLSurfaceView;
+    private boolean mUpdateSurfaceTexture;
+    private FloatBuffer mVertextBuffer;
+    private FloatBuffer mTextureBuffer;
+    private int vertexPosition;
+    private int texturePosition;
+    private int samplerTexturePosition;
+    /**
+     * 视频的宽高
+     */
+    private int mVideoWidth;
+    private int mVideoHeight;
+    /**
+     * 需改更改渲染的大小
+     */
+    private boolean mNeedUpdateSize;
+    /**
+     * Surface的宽高
+     */
+    private int mSurfaceWidth;
+    private int mSurfaceHeight;
+
+    /**
+     * 坐标占用的向量个数
+     */
+    private static final int POSITION_COMPONENT_COUNT = 2;
+    // 逆时针顺序排列
+    private static final float[] POINT_DATA = {
+            -1f, -1f,
+            1f, -1f,
+            -1f, 1f,
+            1f, 1f,
+    };
+    /**
+     * 颜色占用的向量个数
+     */
+    private static final int TEXTURE_COMPONENT_COUNT = 2;
+    // 纹理坐标(s, t)，t坐标方向和顶点y坐标反着
+    private static final float[] TEXTURE_DATA = {
+            0.0f, 1.0f,
+            1.0f, 1.0f,
+            0.0f, 0.0f,
+            1.0f, 0.0f
+    };
+
+    public VideoPlayerRender(GLSurfaceView surfaceView) {
+        mGLSurfaceView = surfaceView;
+        mVertextBuffer = BufferUtil.getFloatBuffer(POINT_DATA);
+        mTextureBuffer = BufferUtil.getFloatBuffer(TEXTURE_DATA);
+    }
+
+    @Override
+    public void onSurfaceCreated(GL10 gl, EGLConfig config) {
+        glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
+        handleProgram(MyApplication.getInstance(), R.raw.video_vertex_shader, R.raw.video_fragment_shader);
+        vertexPosition = glGetAttribLocation("vPosition");
+        texturePosition = glGetAttribLocation("vCoordPosition");
+        samplerTexturePosition = glGetUniformLocation("uSamplerTexture");
+        mTextureId = TextureUtil.createOESTextureId();
+        mSurfaceTexture = new SurfaceTexture(mTextureId);
+        mSurfaceTexture.setDefaultBufferSize(mGLSurfaceView.getWidth(), mGLSurfaceView.getHeight());
+        mSurfaceTexture.setOnFrameAvailableListener(new SurfaceTexture.OnFrameAvailableListener() {
+            @Override
+            public void onFrameAvailable(SurfaceTexture surfaceTexture) {
+                mUpdateSurfaceTexture = true;
+                if (mGLSurfaceView != null) {
+                    mGLSurfaceView.requestRender();
+                }
+            }
+        });
+        if (mTextureRenderListener != null) {
+            mTextureRenderListener.onCreate(mSurfaceTexture);
+        }
+    }
+
+    @Override
+    public void onSurfaceChanged(GL10 gl, int width, int height) {
+        mSurfaceWidth = width;
+        mSurfaceHeight = height;
+        adjustVideoSize();
+        Log.e("@@@", "onSurfaceChanged width: " + width + "...height.." + height);
+        glViewport(0, 0, width, height);
+    }
+
+    @Override
+    public void onDrawFrame(GL10 gl) {
+        glClear(GLES30.GL_DEPTH_BUFFER_BIT | GLES30.GL_COLOR_BUFFER_BIT);
+        adjustVideoSize();
+        glVertexAttribPointer(vertexPosition, POSITION_COMPONENT_COUNT, GLES30.GL_FLOAT, false, 0, mVertextBuffer);
+        glVertexAttribPointer(texturePosition, TEXTURE_COMPONENT_COUNT, GLES30.GL_FLOAT, false, 0, mTextureBuffer);
+        synchronized (this) {
+            if (mUpdateSurfaceTexture) {
+                mSurfaceTexture.updateTexImage();
+                mUpdateSurfaceTexture = false;
+            }
+        }
+        GLES30.glEnableVertexAttribArray(vertexPosition);
+        GLES30.glEnableVertexAttribArray(texturePosition);
+        GLES30.glUniform1i(samplerTexturePosition, 0);
+        // 绘制
+        GLES30.glDrawArrays(GLES30.GL_TRIANGLE_STRIP, 0, 4);
+        GLES30.glFlush();
+        GLES30.glDisableVertexAttribArray(vertexPosition);
+        GLES30.glDisableVertexAttribArray(texturePosition);
+    }
+
+    public void setVideoSize(int width, int height) {
+        if (mVideoWidth == width && mVideoHeight == height) {
+            return;
+        }
+        // videoWidth 272
+        // videoHeight 480
+        mVideoWidth = width;
+        mVideoHeight = height;
+        mNeedUpdateSize = true;
+    }
+
+    private void adjustVideoSize() {
+        if (mVideoWidth == 0 || mVideoHeight == 0 || mSurfaceHeight == 0 || mSurfaceWidth == 0) {
+            return;
+        }
+        if (!mNeedUpdateSize) {
+            return;
+        }
+        mNeedUpdateSize = false;
+        float widthRation = (float) mSurfaceWidth / mVideoWidth;
+        float heightRation = (float) mSurfaceHeight / mVideoHeight;
+        float ration = Math.max(widthRation, heightRation);
+        // 把视频宽高最小的一个扩大到Surface的大小
+        int targetVideoWidth = Math.round(mVideoWidth * ration);
+        int targetVideoHeight = Math.round(mVideoHeight * ration);
+        // 扩大之后的宽高除以目前surface的宽高，来算错各自要xy的比例，这俩里面有一个肯定是1
+
+        float rationX = (float) targetVideoWidth / mSurfaceWidth;
+        float rationY = (float) targetVideoHeight / mSurfaceHeight;
+
+        float[] targetPositionData = new float[]{
+                POINT_DATA[0] / rationY, POINT_DATA[1] / rationX,
+                POINT_DATA[2] / rationY, POINT_DATA[3] / rationX,
+                POINT_DATA[4] / rationY, POINT_DATA[5] / rationX,
+                POINT_DATA[6] / rationY, POINT_DATA[7] / rationX,
+
+        };
+        // 换算缩放后的顶点坐标。后面在onDraw()方法中会有这个值设置给顶点着色器
+        mVertextBuffer.clear();
+        mVertextBuffer.put(targetPositionData);
+        mVertextBuffer.position(0);
+    }
+
+    private IVideoTextureRenderListener mTextureRenderListener;
+
+    public void setIVideoTextureRenderListener(IVideoTextureRenderListener render) {
+        mTextureRenderListener = render;
+    }
+
+    public interface IVideoTextureRenderListener {
+        void onCreate(SurfaceTexture surfaceTexture);
+    }
+}
+```
+
+
+
+下面是具体的效果分别是填充宽和填充高的效果:   
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_video_player1.jpeg" style="zoom:40%;" />
 
 
 
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_video_player_2.jpeg" style="zoom:33%;" />
 
 
 
diff --git "a/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md" "b/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"
index 4d0adb8f..77c83770 100644
--- "a/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"	
+++ "b/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"	
@@ -74,7 +74,7 @@ RGB三个通道的颜色取反，而alpha通道不变。
 
 ## 视频播放滤镜实现
 
-滤镜的编写主要是靠基类。
+首先需要在GLSurfaceView.Renderer的实现类中提供一个setFilter()的方法，然后在onDrawFrame()的时候再去调用这个Filter的onDraw()方法，所以滤镜的编写主要是靠基类。
 
 - 先抽取BaseFilter类，封装好每个滤镜的着色器及onDraw等方法。
 - 不同的滤镜都继承该BaseFilter类，然后实现有区别的部分。其实每个不同滤镜的区别就是着色器的不同。

From 723968520c8d34f4e936cd7719969bba00bc40aa Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Sun, 29 Mar 2020 19:09:09 +0800
Subject: [PATCH 014/213] update

---
 .../11.OpenGL ES\346\273\244\351\225\234.md"  | 281 +++++++++++++++++-
 1 file changed, 279 insertions(+), 2 deletions(-)

diff --git "a/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md" "b/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"
index 77c83770..ed330195 100644
--- "a/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"	
+++ "b/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"	
@@ -90,9 +90,286 @@ RGB三个通道的颜色取反，而alpha通道不变。
 - onDestroy()：销毁，用于资源回收。
 
 
+```java
+public class BaseFilter {
+    private static final int POSITION_COMPONENT_COUNT = 2;
+    private static final int TEXTURE_COMPONENT_COUNT = 2;
+
+    protected int mProgram;
+    @RawRes
+    private int mVertexShaderResId;
+    @RawRes
+    private int mFragmentShaderResId;
+
+    private boolean mInited;
+
+    private int vertexPosition;
+    private int texturePosition;
+    private int samplerTexturePosition;
+
+    //渲染线程
+    private LinkedList<Runnable> mRunOnDraw = new LinkedList();
+
+    public BaseFilter() {
+        this(R.raw.video_no_filter_vertex_shader, R.raw.video_no_filter_fragment_shader);
+    }
+
+    public BaseFilter(@RawRes int vertexShaderResId, @RawRes int fragmentShaderResId) {
+        mVertexShaderResId = vertexShaderResId;
+        mFragmentShaderResId = fragmentShaderResId;
+    }
+
+    public void init() {
+        if (!mInited) {
+            onInit();
+            mInited = true;
+            onInited();
+        }
+    }
+
+    public void onInit() {
+        handleProgram(MyApplication.getInstance(), mVertexShaderResId, mFragmentShaderResId);
+        vertexPosition = glGetAttribLocation("vPosition");
+        texturePosition = glGetAttribLocation("vCoordPosition");
+        samplerTexturePosition = glGetUniformLocation("uSamplerTexture");
+    }
+
+    /**
+     * readResource -> compileShader -> linkProgram -> useProgram
+     *
+     * @param context
+     * @param vertexShader
+     * @param fragmentShader
+     */
+    protected void handleProgram(@NonNull Context context, @RawRes int vertexShader, @RawRes int fragmentShader) {
+        String vertexShaderStr = ResReadUtils.readResource(context, vertexShader);
+        int vertexShaderId = ShaderUtils.compileVertexShader(vertexShaderStr);
+        //编译片段着色程序
+        String fragmentShaderStr = ResReadUtils.readResource(context, fragmentShader);
+        int fragmentShaderId = ShaderUtils.compileFragmentShader(fragmentShaderStr);
+        //连接程序
+        mProgram = ShaderUtils.linkProgram(vertexShaderId, fragmentShaderId);
+        //在OpenGLES环境中使用程序
+        GLES30.glUseProgram(mProgram);
+    }
+
+    public void onInited() {
+
+    }
+
+    public final void destroy() {
+        mInited = false;
+        GLES30.glDeleteProgram(mProgram);
+        onDestroy();
+    }
+
+    public void onDestroy() {
+
+    }
+
+    public void onDraw(final int textureId, final FloatBuffer mVertextBuffer,
+                       final FloatBuffer mTextureBuffer) {
+        runPendingOnDrawTasks();
+        if (!mInited) {
+            return;
+        }
+
+        glVertexAttribPointer(vertexPosition, POSITION_COMPONENT_COUNT, GLES30.GL_FLOAT, false, 0, mVertextBuffer);
+        glVertexAttribPointer(texturePosition, TEXTURE_COMPONENT_COUNT, GLES30.GL_FLOAT, false, 0, mTextureBuffer);
+        GLES30.glEnableVertexAttribArray(vertexPosition);
+        GLES30.glEnableVertexAttribArray(texturePosition);
+        GLES30.glUniform1i(samplerTexturePosition, 0);
+//        if (textureId != GL.NO_TEXTURE) {
+//            GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
+//            GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, textureId);
+//            GLES20.glUniform1i(glUniformTexture, 0);
+//        }
+
+        onDrawArraysPre();
+        GLES30.glDrawArrays(GLES30.GL_TRIANGLE_STRIP, 0, 4);
+        GLES30.glDisableVertexAttribArray(vertexPosition);
+        GLES30.glDisableVertexAttribArray(texturePosition);
+    }
+
+    protected void runPendingOnDrawTasks() {
+        while (!mRunOnDraw.isEmpty()) {
+            mRunOnDraw.removeFirst().run();
+        }
+    }
+
+
+    /**
+     * 设置着色器中对象float值
+     */
+    protected void setFloat(final int location, final float floatValue) {
+        runOnDraw(new Runnable() {
+            @Override
+            public void run() {
+                GLES30.glUniform1f(location, floatValue);
+            }
+        });
+    }
+
+    /**
+     * 设置着色器中对象组值float值
+     */
+    protected void setFloatVec2(final int location, final float[] arrayValue) {
+        runOnDraw(new Runnable() {
+            @Override
+            public void run() {
+                GLES30.glUniform2fv(location, 1, FloatBuffer.wrap(arrayValue));
+            }
+        });
+    }
+
+    /**
+     * 设置着色中数组值
+     */
+    protected void setFloatVec3(final int location, final float[] arrayValue) {
+        runOnDraw(new Runnable() {
+            @Override
+            public void run() {
+                GLES20.glUniform3fv(location, 1, FloatBuffer.wrap(arrayValue));
+            }
+        });
+    }
+
+    /**
+     * 设置着色器中对象组值float值
+     */
+    protected void setFloatVec4(final int location, final float[] arrayValue) {
+        runOnDraw(new Runnable() {
+            @Override
+            public void run() {
+                GLES20.glUniform4fv(location, 1, FloatBuffer.wrap(arrayValue));
+            }
+        });
+    }
+
+    /**
+     * 设置着色器中3维矩阵的值
+     */
+    protected void setUniformMatrix3f(final int location, final float[] matrix) {
+        runOnDraw(new Runnable() {
+            @Override
+            public void run() {
+                GLES20.glUniformMatrix3fv(location, 1, false, matrix, 0);
+            }
+        });
+    }
+
+    /**
+     * 设置着色器中4维矩阵的值
+     */
+    protected void setUniformMatrix4f(final int location, final float[] matrix) {
+        runOnDraw(new Runnable() {
+            @Override
+            public void run() {
+                GLES20.glUniformMatrix4fv(location, 1, false, matrix, 0);
+            }
+        });
+    }
+
+
+    protected void runOnDraw(Runnable runnable) {
+        synchronized (mRunOnDraw) {
+            mRunOnDraw.addLast(runnable);
+        }
+    }
+
+    protected void onDrawArraysPre() {
+
+    }
+
+
+    protected void glViewport(int x, int y, int width, int height) {
+        GLES30.glViewport(x, y, width, height);
+    }
+
+    protected void glClearColor(float red, float green, float blue, float alpha) {
+        GLES30.glClearColor(red, green, blue, alpha);
+    }
+
+    protected void glClear(int mask) {
+        GLES30.glClear(mask);
+    }
+
+    protected static void glEnableVertexAttribArray(int index) {
+        GLES30.glEnableVertexAttribArray(index);
+    }
+
+    protected void glDisableVertexAttribArray(int index) {
+        GLES30.glDisableVertexAttribArray(index);
+    }
+
+    protected int glGetAttribLocation(String name) {
+        return GLES30.glGetAttribLocation(mProgram, name);
+    }
+
+    protected int glGetUniformLocation(String name) {
+        return GLES30.glGetUniformLocation(mProgram, name);
+    }
+
+    protected void glUniformMatrix4fv(int location, int count, boolean transpose, float[] value, int offset) {
+        GLES30.glUniformMatrix4fv(location, count, transpose, value, offset);
+    }
+
+    protected void glDrawArrays(int mode, int first, int count) {
+        GLES30.glDrawArrays(mode, first, count);
+    }
+
+    protected void glDrawElements(int mode, int count, int type, java.nio.Buffer indices) {
+        GLES30.glDrawElements(mode, count, type, indices);
+    }
+
+    protected void orthoM(String name, int width, int height) {
+        ProjectionMatrixUtil.orthoM(mProgram, width, height, name);
+    }
+
+    protected void glVertexAttribPointer(
+            int indx,
+            int size,
+            int type,
+            boolean normalized,
+            int stride,
+            java.nio.Buffer ptr) {
+        GLES30.glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
+    }
+
+    protected void glActiveTexture(int texture) {
+        GLES30.glActiveTexture(GLES30.GL_TEXTURE0);
+    }
+
+    protected void glBindTexture(int target, int texture) {
+        GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, texture);
+    }
+
+    protected void glUniform1i(int location, int x) {
+        GLES20.glUniform1i(location, x);
+    }
+
+    public int getProgram() {
+        return mProgram;
+    }
+}
+```
 
-
-
+在Render中改变的地方就是onDrawFrame()方法中去调用Filter.onDraw()方法:  
+```java
+    @Override
+    public void onDrawFrame(GL10 gl) {
+        glClear(GLES30.GL_DEPTH_BUFFER_BIT | GLES30.GL_COLOR_BUFFER_BIT);
+        adjustVideoSize();
+        synchronized (this) {
+            if (mUpdateSurfaceTexture) {
+                mSurfaceTexture.updateTexImage();
+                mUpdateSurfaceTexture = false;
+            }
+        }
+        runAll(mRunOnDraw);
+        mFilter.onDraw(mTextureId, mVertextBuffer, mTextureBuffer);
+    }
+```
 
 
 

From b898c6fc6b67b4cc2f353c577f217afa607691a7 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Fri, 3 Apr 2020 21:39:46 +0800
Subject: [PATCH 015/213] update

---
 VideoDevelopment/DASH.md | 96 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 96 insertions(+)
 create mode 100644 VideoDevelopment/DASH.md

diff --git a/VideoDevelopment/DASH.md b/VideoDevelopment/DASH.md
new file mode 100644
index 00000000..87f9790a
--- /dev/null
+++ b/VideoDevelopment/DASH.md
@@ -0,0 +1,96 @@
+# HLS协议
+
+HLS(HTTP Live Streaming)协议：是苹果公司实现的基于HTTP的流媒体传输协议，可实现流媒体的直播和点播。HLS点播，基本上就是常见的分段HTTP点播，不同在于，它的分段非常小。相对于常见的流媒体直播协议，例如RTMP协议、RTSP协议、MMS协议等，HLS直播最大的不同在于，直播客户端获取到的，并不是一个完整的数据流。HLS协议在服务器端将直播数据流存储为连续的、很短时长的媒体文件（MPEG-TS格式），而客户端则不断的下载并播放这些小文件。因为服务器端总是会将最新的直播数据生成新的小文件，这样客户端只要不停的按顺序播放从服务器获取到的文件，就实现了直播。由此可见，基本上可以认为，HLS是以点播的技术方式来实现直播。由于数据通过HTTP协议传输，所以完全不用考虑防火墙或者代理的问题，而且分段文件的时长很短，客户端可以很快的选择和切换码率，以适应不同带宽条件下的播放。不过HLS的这种技术特点，决定了它的延迟一般总是会高于普通的流媒体直播协议。它也解决了RTMP协议存在的一些问题，例如RTMP协议不使用标准的HTTP接口传输数据(TCP、UDP端口)，所以在一些特殊的网络环境下可能被防火墙屏蔽掉，而HLS使用的是HTTP协议传输数据(80端口)，不会遇到被防火墙屏蔽的情况。
+
+在开始一个流媒体会话时，客户端会下载一个包含元数据的extended M3U(m3u8)  playlist文件，用于寻找可用的媒体流(将视频分为一个个视频小分片，然后用m3u8索引表进行管理，由于客户端下载到的视频都是5-10秒的完整数据，所以视频的流畅性很好，但是同样也引入了很大的延迟(一般延迟在10-30s左右))。
+
+上面提到了m3u8，那m3u8构成是？直播中m3u8、ts如何实时更新？
+
+- 是一个索引地址/播放列表，通过FFmpeg将本地的xxx.mp4进行切片处理，生成m3u8播放列表（索引文件）和N多个  .ts文件，并将其（m3u8、N个ts）放置在本地搭建好的webServer服务器的指定目录下，我就可以得到一个可以实时播放的网址，我们把这个m3u8地址复制到 VLC 上就可以实时观看！ 在 HLS 流下，本地视频被分割成一个一个的小切片，一般10秒一个，这些个小切片被 m3u8管理，并且随着终端的FFmpeg  向本地拉流的命令而实时更新，影片进度随着拉流的进度而更新，播放过的片段不在本地保存，自动删除，直到该文件播放完毕或停止，ts  切片会相应的被删除，流停止，影片不会立即停止，影片播放会滞后于拉流一段时间
+
+HLS的整体流程为:
+
+视频源文件 -> 服务器(编码器、流分割器) -> 分发器(索引文件、*.ts) -> 传输网络 -> 客户端
+
+
+
+[http://devimages.apple.com/iphone/samples/bipbop/bipbopall.m3u8](https://link.jianshu.com?t=http%3A%2F%2Fwww.modrails.com%2Fvideos%2Fpassenger_nginx.mov)
+
+```
+#EXTM3U                           // m3u8文件头
+#EXT-X-VERSION:3                  // 协议版本
+#EXT-X-MEDIA-SEQUENCE:304240      // 第一个ts文件的序列号
+#EXT-X-TARGETDURATION:10          // 每个ts文件的最大时长
+#EXTINF:10.000,                   // 每个ts文件的持续时间
+cctv1hd-1585920024000.ts          // ts文件的url
+#EXTINF:10.000,
+cctv1hd-1585920034000.ts
+#EXTINF:10.000,
+cctv1hd-1585920044000.ts
+#EXTINF:10.000,
+cctv1hd-1585920054000.ts
+#EXTINF:10.000,
+cctv1hd-1585920064000.ts
+#EXTINF:10.000,
+cctv1hd-1585920074000.ts
+```
+
+
+
+# 简介
+
+
+
+DASH(MPEG-DASH)全称为Dynamic Adaptive Streaming over HTTP。是国际标准组MPEG  2014年推出的技术标准，主要目标是形成IP网络承载单一格式的流媒体并提供高效与高质量服务的统一方案，解决多制式传输方案(HTTP Live  Streaming, Microsoft Smooth Streaming, HTTP Dynamic  Streaming)并存格局下的存储与服务能力浪费、运营高成本与复杂度、系统间互操作弱等问题。
+
+DASH是基于HTTP的动态自适应的比特率流技术，使用的传输协议是TCP(有些老的客户端直播会采用UDP协议直播, 例如YY,  齐齐视频等). 和HLS, HDS技术类似， 都是把视频分割成一小段一小段，  通过HTTP协议进行传输，客户端得到之后进行播放；不同的是MPEG-DASH支持MPEG-2 TS、MP4等多种格式,  可以将视频按照多种编码切割, 下载下来的媒体格式既可以是ts文件也可以是mp4文件, 所以当客户端加载视频时,  按照当前的网速和支持的编码加载相应的视频片段进行播放.
+
+因为是分片的，客户端可以自由选择需要播放的媒体分片，可以实现`Adaptive Bitrate Streaming`技术，不同画质内容无缝切换，提供更好的播放体验。
+
+YouTube采用DASH！其网页端及移动端APP都使用了DASH。
+
+DASH的整个流程:
+
+内容生成服务器(编码模块、封装模块) -> 流媒体服务器(MPD、媒体文件、HTTP服务器) <-> DASH客户端(控制引擎、媒体引擎、HTTP接入容器)
+
+
+
+在2012年由ISO/IEC发表，正式成为国际标准。该技术与编解码器无关，可使用H.265，H.264，VP9等任何编码器进行编码。
+
+DASH和苹果的HLS(HTTP Live Streaming)技术相似，通过把内容分割成小的基于HTTP的文件段序列，来进行流媒体播放。各个文件段可以设置成不同的比特率进行编码，以满足不同客户端的网络需求。例如，DASH客户端可以根据当前的网络状况，自动选择对应的最匹配的比特率文件段下载，进行回访，而不会引起停顿或重新缓冲。这样DASH可以做到无缝的适应不断变化的网络条件，并提供高品质的播放，而能够尽量减少播放的停顿或缓冲。
+
+
+
+国外主要是YouTube、BBC、ITV等都已经开始推行DASH，国内B站、爱奇艺、腾讯
+
+# DASH vs HLS
+
+
+
+
+
+# DASH 
+
+- MPD
+- 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

From a8f73ad225055abe8df89a8b2c5746e6afac81d7 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 6 Apr 2020 19:18:11 +0800
Subject: [PATCH 016/213] add notes

---
 VideoDevelopment/DASH.md                      |  96 ----------
 .../DASH.md"                                  | 158 +++++++++++++++++
 .../HLS.md"                                   | 165 ++++++++++++++++++
 ...32\344\277\241\345\215\217\350\256\256.md" |   0
 4 files changed, 323 insertions(+), 96 deletions(-)
 delete mode 100644 VideoDevelopment/DASH.md
 create mode 100644 "VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/DASH.md"
 create mode 100644 "VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HLS.md"
 rename "VideoDevelopment/\346\265\201\345\252\222\344\275\223\351\200\232\344\277\241\345\215\217\350\256\256.md" => "VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/\346\265\201\345\252\222\344\275\223\351\200\232\344\277\241\345\215\217\350\256\256.md" (100%)

diff --git a/VideoDevelopment/DASH.md b/VideoDevelopment/DASH.md
deleted file mode 100644
index 87f9790a..00000000
--- a/VideoDevelopment/DASH.md
+++ /dev/null
@@ -1,96 +0,0 @@
-# HLS协议
-
-HLS(HTTP Live Streaming)协议：是苹果公司实现的基于HTTP的流媒体传输协议，可实现流媒体的直播和点播。HLS点播，基本上就是常见的分段HTTP点播，不同在于，它的分段非常小。相对于常见的流媒体直播协议，例如RTMP协议、RTSP协议、MMS协议等，HLS直播最大的不同在于，直播客户端获取到的，并不是一个完整的数据流。HLS协议在服务器端将直播数据流存储为连续的、很短时长的媒体文件（MPEG-TS格式），而客户端则不断的下载并播放这些小文件。因为服务器端总是会将最新的直播数据生成新的小文件，这样客户端只要不停的按顺序播放从服务器获取到的文件，就实现了直播。由此可见，基本上可以认为，HLS是以点播的技术方式来实现直播。由于数据通过HTTP协议传输，所以完全不用考虑防火墙或者代理的问题，而且分段文件的时长很短，客户端可以很快的选择和切换码率，以适应不同带宽条件下的播放。不过HLS的这种技术特点，决定了它的延迟一般总是会高于普通的流媒体直播协议。它也解决了RTMP协议存在的一些问题，例如RTMP协议不使用标准的HTTP接口传输数据(TCP、UDP端口)，所以在一些特殊的网络环境下可能被防火墙屏蔽掉，而HLS使用的是HTTP协议传输数据(80端口)，不会遇到被防火墙屏蔽的情况。
-
-在开始一个流媒体会话时，客户端会下载一个包含元数据的extended M3U(m3u8)  playlist文件，用于寻找可用的媒体流(将视频分为一个个视频小分片，然后用m3u8索引表进行管理，由于客户端下载到的视频都是5-10秒的完整数据，所以视频的流畅性很好，但是同样也引入了很大的延迟(一般延迟在10-30s左右))。
-
-上面提到了m3u8，那m3u8构成是？直播中m3u8、ts如何实时更新？
-
-- 是一个索引地址/播放列表，通过FFmpeg将本地的xxx.mp4进行切片处理，生成m3u8播放列表（索引文件）和N多个  .ts文件，并将其（m3u8、N个ts）放置在本地搭建好的webServer服务器的指定目录下，我就可以得到一个可以实时播放的网址，我们把这个m3u8地址复制到 VLC 上就可以实时观看！ 在 HLS 流下，本地视频被分割成一个一个的小切片，一般10秒一个，这些个小切片被 m3u8管理，并且随着终端的FFmpeg  向本地拉流的命令而实时更新，影片进度随着拉流的进度而更新，播放过的片段不在本地保存，自动删除，直到该文件播放完毕或停止，ts  切片会相应的被删除，流停止，影片不会立即停止，影片播放会滞后于拉流一段时间
-
-HLS的整体流程为:
-
-视频源文件 -> 服务器(编码器、流分割器) -> 分发器(索引文件、*.ts) -> 传输网络 -> 客户端
-
-
-
-[http://devimages.apple.com/iphone/samples/bipbop/bipbopall.m3u8](https://link.jianshu.com?t=http%3A%2F%2Fwww.modrails.com%2Fvideos%2Fpassenger_nginx.mov)
-
-```
-#EXTM3U                           // m3u8文件头
-#EXT-X-VERSION:3                  // 协议版本
-#EXT-X-MEDIA-SEQUENCE:304240      // 第一个ts文件的序列号
-#EXT-X-TARGETDURATION:10          // 每个ts文件的最大时长
-#EXTINF:10.000,                   // 每个ts文件的持续时间
-cctv1hd-1585920024000.ts          // ts文件的url
-#EXTINF:10.000,
-cctv1hd-1585920034000.ts
-#EXTINF:10.000,
-cctv1hd-1585920044000.ts
-#EXTINF:10.000,
-cctv1hd-1585920054000.ts
-#EXTINF:10.000,
-cctv1hd-1585920064000.ts
-#EXTINF:10.000,
-cctv1hd-1585920074000.ts
-```
-
-
-
-# 简介
-
-
-
-DASH(MPEG-DASH)全称为Dynamic Adaptive Streaming over HTTP。是国际标准组MPEG  2014年推出的技术标准，主要目标是形成IP网络承载单一格式的流媒体并提供高效与高质量服务的统一方案，解决多制式传输方案(HTTP Live  Streaming, Microsoft Smooth Streaming, HTTP Dynamic  Streaming)并存格局下的存储与服务能力浪费、运营高成本与复杂度、系统间互操作弱等问题。
-
-DASH是基于HTTP的动态自适应的比特率流技术，使用的传输协议是TCP(有些老的客户端直播会采用UDP协议直播, 例如YY,  齐齐视频等). 和HLS, HDS技术类似， 都是把视频分割成一小段一小段，  通过HTTP协议进行传输，客户端得到之后进行播放；不同的是MPEG-DASH支持MPEG-2 TS、MP4等多种格式,  可以将视频按照多种编码切割, 下载下来的媒体格式既可以是ts文件也可以是mp4文件, 所以当客户端加载视频时,  按照当前的网速和支持的编码加载相应的视频片段进行播放.
-
-因为是分片的，客户端可以自由选择需要播放的媒体分片，可以实现`Adaptive Bitrate Streaming`技术，不同画质内容无缝切换，提供更好的播放体验。
-
-YouTube采用DASH！其网页端及移动端APP都使用了DASH。
-
-DASH的整个流程:
-
-内容生成服务器(编码模块、封装模块) -> 流媒体服务器(MPD、媒体文件、HTTP服务器) <-> DASH客户端(控制引擎、媒体引擎、HTTP接入容器)
-
-
-
-在2012年由ISO/IEC发表，正式成为国际标准。该技术与编解码器无关，可使用H.265，H.264，VP9等任何编码器进行编码。
-
-DASH和苹果的HLS(HTTP Live Streaming)技术相似，通过把内容分割成小的基于HTTP的文件段序列，来进行流媒体播放。各个文件段可以设置成不同的比特率进行编码，以满足不同客户端的网络需求。例如，DASH客户端可以根据当前的网络状况，自动选择对应的最匹配的比特率文件段下载，进行回访，而不会引起停顿或重新缓冲。这样DASH可以做到无缝的适应不断变化的网络条件，并提供高品质的播放，而能够尽量减少播放的停顿或缓冲。
-
-
-
-国外主要是YouTube、BBC、ITV等都已经开始推行DASH，国内B站、爱奇艺、腾讯
-
-# DASH vs HLS
-
-
-
-
-
-# DASH 
-
-- MPD
-- 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/DASH.md" "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/DASH.md"
new file mode 100644
index 00000000..bb951503
--- /dev/null
+++ "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/DASH.md"
@@ -0,0 +1,158 @@
+# 简介
+
+除了前面将的Apple的HLS，还有Adobe HTTP Dynamic Streaming (HDS)、Microsoft Smooth Streaming (MSS)。他们各家的协议原理大致相同，但是格式又不一样，也无法兼容，所以Moving Picture Expert Group (MPEG) 就把大家叫到了一起，呼吁大家一起来制定一个标准的，然后就有了[MPEG-DASH](https://www.encoding.com/mpeg-dash/),它的主要目标是形成IP网络承载单一格式的流媒体并提供高效与高质量服务的统一方案，解决多制式传输方案(HTTP Live  Streaming, Microsoft Smooth Streaming, HTTP Dynamic  Streaming)并存格局下的存储与服务能力浪费、运营高成本与复杂度、系统间互操作弱等问题。
+
+[DASH(MPEG-DASH)](https://mpeg.chiariglione.org/standards/mpeg-dash/)全称为Dynamic Adaptive Streaming over HTTP.是由MPEG和ISO批准的独立于供应商的国际标准，它是一种基于HTTP的使用TCP传输协议的流媒体传输技术。MPEG-DASH是一种自适应比特率流技术，可根据实时网络状况实现动态自适应下载。和HLS, HDS技术类似， 都是把视频分割成一小段一小段，  通过HTTP协议进行传输，客户端得到之后进行播放；不同的是MPEG-DASH支持MPEG-2 TS、MP4(最新的HLS也支持了MP4)等多种格式,  可以将视频按照多种编码切割, 下载下来的媒体格式既可以是ts文件也可以是mp4文件，MPEG—DASH技术与编解码器无关，可使用H.265，H.264，VP9等任何编解码器进行编码。
+
+安卓平台上的ExoPlayer支持MPEG-DASH。另外，三星、索尼、飞利浦、松下的一些较新型号的智能电视支持MPEG—DASH。Google的Chromecast、YouTube 和Netflix 也已支持MPEG-DASH。
+
+![dash_compare](https://raw.githubusercontent.com/CharonChui/Pictures/master/dash_compare.png)
+
+## 思想
+
+![dash_main_idea](https://raw.githubusercontent.com/CharonChui/Pictures/master/dash_main_idea.png)
+
+DASH的核心思想是，在服务端，视频被提前编好多种码率，并且被切成固定长度的视频片段，存放到HTTP服务器中，当客户端播放时，通过HTTP请求向服务器请求视频切片，并根据网络状况的变化，请求相应质量的视频切片，从而达到对网络带宽的最大利用，并且保证播放流畅。可以实现不同画质内容无缝切换。所以在 YouTube 切换画质时完全不会黑屏，更不会影响观看。
+
+![image-20200406163508642](https://raw.githubusercontent.com/CharonChui/Pictures/master/a_dash_scenario.png)
+
+
+
+DASH的整个流程:
+
+内容生成服务器(编码模块、封装模块) -> 流媒体服务器(MPD、媒体文件、HTTP服务器) <-> DASH客户端(控制引擎、媒体引擎、HTTP接入容器)
+
+![image-20200406164238038](https://raw.githubusercontent.com/CharonChui/Pictures/master/mpd_hierarchical_data.png)
+
+### MPD
+
+DASH采用3GPP AHS中定义的MPD(Media Presentation Description)作为媒体文件的描述文件（manifest），作用类似HLS的m3u8文件。MPD文件以XML格式组织，用于描述segment的信息，比如时间、url、视频分辨率、码率等。   
+DASH会通过media presentation description (MPD)将视频内容切片成一个很短的文件片段，每个切片都有多个不同的码率，DASH Client可以根据网络的情况选择一个码率进行播放，支持在不同码率之间无缝切换。
+DASH中的重要概念
+
+### Period
+
+MPD文件包含一个或者多个片段(Period)，它表示时间轴上的一段时间，每个片段都有一个起始时间和结束时间，并且包含了一个或者多个适配集合(Adaptation Set)。每个适配集合提供了一个或者多个媒体组件的信息，并包含了多种不同的码率。每个适配集合又是由多个呈现(Representation)组成，每个呈现就是同一个视频的不同特征的版本，如码率、分辨率等特征。由于每个的视频都要被切成固定长度的切片，因此每个呈现包括多个视频切片(Segment)，每个视频切片都有一个URL地址，这样客户端就可以通过这个地址向服务器发送HTTP GET请求获取该片段。同一个Period内，意味着可用的媒体内容及其各个可用码率（Representation）不会发生变更。直播情况下，“可能”需要周期地去服务器更新MPD文件，服务器可能会移除旧的已经过时的Period,或是添加新的Period。新的Period中可能会添加新的可用码率或去掉上一个Period中存在的某些码率(Representation)。
+
+### Adaptation Set
+
+ 一个Period由一个或者多个Adaptationset组成。Adaptationset由一组可供切换的不同码率的码流（Representation)组成，这些码流中可能包含一个（ISO profile)或者多个(TS profile)media content components，因为ISO profile的mp4或者fmp4 segment中通常只含有一个视频或者音频内容，而TS profile中的TS segment同时含有视频和音频内容，当同时含有多个media component content时，每个被复用的media content component将被单独描述
+
+### Representation
+
+每个Adaptationset包含了一个或者多个Representations,一个Representation包含一个或者多个media streams，每个media stream对应一个media content component。为了适应不同的网络带宽，dash客户端可能会从一个Representation切换到另外一个Representation，如果不支持某个Representation的编码格式，在切换时可以忽略之。
+
+### Segments
+
+Segments可以包含任何媒体数据，关于容器，官方提供了两种建议: ISO base media file format(比如MP4文件格式)和MPEG-2 Transport Stream。
+
+每个Representation会划分为多个Segment。Segment分为4类，其中，最重要的是：Initialization Segment（每个Representation都包含1个Init Seg），Media Segment（每个Representation的媒体内容包含若干Media Seg）
+
+- Initialization Segment：
+
+  Representation的Segments一般都采用1个Init Segment+多个普通Segment的方式，还有一种形式就是Self Initialize Segment，这种形式没有单独的Init Segment，初始化信息包括在了各个Segment中。Init Segment中包含了解封装需要的全部信息，比如Representation中有哪些音视频流，各自的编码格式及参数。对于 ISO profile来说(容器为MP4)，包含了moov box,H264的sps/pps数据等关键信息存放于此（avCc box）。另外，同一个Adaptation set的多个Representation还可能共享同一个Init Segment，该种情况下，对于ISO profile来说，诸如stsd box，avCc box等重要的box会含有多个entry，每个entry对应一个Representation，第一个entry对应第一个Representation，第二个entry对应第二个Representation，以此类推。
+
+- Subsegment
+
+   Segment可能进一步划分为subsegment，每个subsegment由数个Acess Unit组成，Segment index提供了subsegment相对于Segment的字节范围和presentation time range 。客户端可以先下载Segment index。
+
+### SAP和无缝切换以及SEEK
+
+  SAP：Stream Acess Point，可以简单理解为I帧，每个Segment的第一个帧都是SAP，因此Seek时可直接Seek到某一个Segment的起始位置，利用Init Segment+Seek到的某个Segment的数据，在解封装后可实现完美解码。一般来说，同一个Adaptation set中的多个Representation是Segment Align的（当Adaptation set的属性@segmentAlignment不为false时），因此，当从Representation A切换到Representation B时，如果当前Representation A的第N个Segment已经下载完成，切换时直接下载Representation B的第N+1个Segment即可。
+
+
+    
+    
+
+![dash_compare2.png](https://raw.githubusercontent.com/CharonChui/Pictures/master/dash_compare2.png)
+
+码率自适应切换算法
+
+- 基于带宽的码率自适应切换算法
+- 基于缓存的码率自适应切换算法
+
+![image-20200406165443536](https://raw.githubusercontent.com/CharonChui/Pictures/master/dash_change_compare.png)
+
+此基于时间缓存的码率自适应算法对网络带宽变化反应敏感，能够有效的提高平均码率，但同时码率切换次数过大，尤其是在网络状况波动很大的情况下，这势必会造成用户体验的下降。
+
+- MSS拥有最高的平均码率和较少的切换次数
+
+- HLS的切换次数最少，但是以最低的平均码率作为代价
+
+- HDS不能保证流程的播放
+
+- DASH有足够的竞争力，也具有巨大的提升空间。
+
+
+
+## DASH地址
+
+http://ftp.itec.aau.at/datasets/mmsys12/BigBuckBunny/MPDs/BigBuckBunnyNonSeg_2s_isoffmain_DIS_23009_1_v_2_1c2_2011_08_30.mpd
+
+http://www-itec.uni-klu.ac.at/ftp/datasets/mmsys12/BigBuckBunny/bunny_2s/bunny_2s_50kbit/bunny_50kbit_dashNonSeg.mp4
+
+
+
+## fMP4
+
+fMP4（fragmented MP4），可以简单理解为分片化的MP4，是DASH采用的媒体文件格式，文件扩展名通常为（.m4s或直接用.mp4）。     
+
+![fMP4](https://img-blog.csdn.net/20171107114807709?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQveXVlX2h1YW5n/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
+
+
+
+### fMP4与ts的区别
+
+### 媒体数据与元数据的分离
+
+在mp4格式中，元数据可以和媒体数据很好地分开存储，后者都在mdat box中，而在ts中，诸多es流和header/metadata信息是复用在一起的。
+ 元数据的分离允许我们在streaming中先读取各个流的元数据，知道他们的媒体内容的属性（比如不同的视频质量、不同的语言等），从而可以更好地在不同的media data之间做自适应切换。
+ 当然，在更实际的应用场景中，比如在dash协议中会直接把这些元数据信息写在mpd中，player可以只读一个mpd就知道各个媒体数据的属性
+
+### 各个Track独立存储
+
+在fmp4中，不仅媒体数据和metadata相互独立的存储，音视频track的数据也可以分开存储，这里的“分开”已经不仅仅局限于box层面的分开，而是真的可以分开存储于不同的目录。在这种情况下，player只需要读一个记录了它们各自存储位置的manifest，即可去对应的位置download它们的分片，只要做好音视频分片之间的同步工作，就可以正常的播放。
+ 举个例子，下面是一个dash中常见的mpd：
+
+在这个mpd中我们看到视频的分片都是存储在video/1/这个目录下，而音频分片都存储在audio/und/mp4a/1这个目录下，而player还是可以将它们拼接到一起完成播放。
+ 相对地，在streaming TS流时，音视频往往是复用在一起的，以HLS这个应用场景为例的话，server端一定还需要提前将TS切片做好，这样就会带来几个问题：
+
+1. 媒体文件存储成本和媒资管理成本增加
+    假设server端将video track编码为三个质量级别V1, V2, V3，audio track也被编码为三个质量级别A1, A2,  A3，那么如果利用fmp4格式的特性，我们只需要存储这6份媒体文件，player在播放时再自主组合不同质量级别的音视频track即可。而对于TS，则不得不提前将3x3=9种不同的音视频复用情况对应的媒体文件都存储到server端，平白无故多出三份文件的存储成本。实际中，因为要考虑到大屏端、小屏端、移动端、桌面端、不同语言、不同字幕等各种情况，使用TS而造成的冗余成本将更加可观。同时，存储文件的增加也意味着媒资管理成本的增加。这也是包括Netflix在内的一些公司选择使用fmp4做streaming格式的原因。
+2. manifest文件更加复杂
+    fmp4格式的特性可以确保每一个单独的媒体分片都是可解密可解码的（当然player需要先从moov  box中读到它们的编解码等信息），这意味着server端甚至根本不需要真的存储一大堆分片，player可以直接利用byte range  request技术从一个大文件中准确地读出一个分片对应的media data，这也使得对应manifest(mpd)文件可以更加简洁，如下：
+
+针对不同语言的音频，都只需要存一个大文件就够了。
+相对地，在streaming TS流时，不得不在manifest（m3u8）文件中把成百上千个ts分片文件全都老老实实地记录下来。
+
+所以Dash同样可以支持下面的操作: 
+
+- 音频视频分离，在后台播放时可以只拉取音频
+- 支持多音轨，多视频轨，多字幕任意切换
+
+### 服务器的cache效率会降低
+ 实际的streaming应用场景中，往往需要cdn的支持，经常会被client请求的媒体分片就会存在距离client最近的edge  server上。对于fmp4 streaming的情况，因为需要的文件更少，cache命中率也就更高，举个例子：可能某一个audio  track会和其他各种video track组合，那么就可以将这个audio track放在edge server上，而不用每次都跟origin server去请求。
+ 相对地，在streaming TS流时，因为每一个音视频组合的都需要以复用文件的形式存储，组合数又非常多，相当于分母大了，edge server就会有很大的几率没有缓存需要的组合而要去向orgin server请求。
+
+### 对Trick-play的支持
+
+所谓Trick-play，就是快进、快退、直接跳到章节起点、慢动作播放这些“花式”播放功能。支持这些功能往往意味着要快速找到播放流中的关键帧，以快进播放为例，如果利用fmp4格式的特点，可以通过只读取每个媒体分片的moof加上mdat的起始（包含了关键帧图像）部分即可，说白了就是通过只显示关键帧的方法达到“快进”的视觉效果。因为fmp4格式中可以保证每一个分片一定是以IDR帧开始的，这就使得上述的方案实现起来非常方便。
+ 相对地，在streaming TS流时，没有办法保证关键帧一定在什么位置，所以你可能需要解析一大堆TS packets才能找到关键帧的位置。
+
+### 无缝码流切换
+
+无缝码流切换实现的关键在于：当第一个码流播放结束时，也就是发生切换的时间，第二个码流一定要以关键帧开始播放。在streaming  TS流时，因为不能保证每一个TS  chunk一定以关键帧开始，做码流切换时就意味着要同时download两个码流的相应分片，同时解析两个码流，然后找到关键帧对应的位置，才能切换。同时下载、解析两个码流的媒体内容对网络带宽以及设备性能都形成了挑战。而且有意思的是，如果当前网络环境不佳，player想要切换到低码率码流，结果还要在本来就不好的网络环境下同时进行两个码流的下载，可谓是雪上加霜。
+ 而在fmp4中，除了保证各个分片一定以IDR帧开始外，还能保证不同码流的分片之间在时间线上是对齐的。而且streaming  fmp4流时因为不要求音视频复用存储，也就意味着视频和音频的同步点可以不一样，视频可以全都以GOP边界作为同步点，音频可以都以sync  frame作为同步点，这都使得无缝码流切换更简单。
+
+### 与DRM的集成
+
+所谓DRM即数字版权管理，说白了就是对流进行加密，这东西在国内用的不多，但是在国外可是每一个内容提供商必须要有的东西。和编码标准一样，业界也存在很多DRM方案，为了避免每采用一个新的加密方案就要重新编一个码流，MPEG推出了通用加密（CENC）标准（23001-7 - Common Encryption）。使用这一标准的码流，就可以将一个码流应用于各种不同的DRM方案。在DASH  spec中，也定义了Content Protection字段来对应这种加密方案。
+ CENC使用的就是fMP4格式，这是利用了fMP4中音视频可以不复用同时还能提供独立于media data存储的metadata的特点。TS流就享受不了这样的好处了。
+
+DASH和HLS之间的另一个关键区别是它支持DRM。可是，在DASH中不存在一个单一通用的DRM解决方案。例如，Google的Chrome支持Widevine，而Microsoft的Internet  Explorer支持PlayReady。然而，通过使用MPEG-CENC（MPEG通用加密）结合加密媒体扩展（EME），视频流内容可以仅被加密一次。HLS支持AES-128加密，以及苹果自己的DRM，Fairplay。
+
+
+
+
+
+
diff --git "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HLS.md" "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HLS.md"
new file mode 100644
index 00000000..62acc949
--- /dev/null
+++ "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HLS.md"
@@ -0,0 +1,165 @@
+# HLS协议
+
+[HLS(HTTP Live Streaming)协议](https://developer.apple.com/library/archive/documentation/NetworkingInternet/Conceptual/StreamingMediaGuide/Introduction/Introduction.html)：2009年由苹果公司实现的基于HTTP的流媒体传输协议，可实现流媒体的直播和点播。它的工作原理是把整个流分成一个个小的基于HTTP的文件来下载，每次只下载一些。
+
+HLS协议规定:  
+
+- 视频的封装格式是TS
+- 视频的编码格式为H264，音频编码格式为MP3、AAC或者AC-3
+- 除了TS视频文件本身，还定义了用来控制播放的m3u8文件(文本文件)
+
+HLS协议由三部分组成:  
+
+- HTTP:传输协议
+- m3u8:索引文件
+- TS:音视频媒体信息
+
+HLS点播，基本上就是常见的分段HTTP点播，不同在于，它的分段非常小。相对于常见的流媒体直播协议，例如RTMP协议、RTSP协议、MMS协议等，HLS直播最大的不同在于，直播客户端获取到的，并不是一个完整的数据流。HLS协议在服务器端将直播数据流存储为连续的、很短时长的媒体文件（MPEG-TS格式），而客户端则不断的下载并播放这些小文件。因为服务器端总是会将最新的直播数据生成新的小文件，这样客户端只要不停的按顺序播放从服务器获取到的文件，就实现了直播。由此可见，基本上可以认为，HLS是以点播的技术方式来实现直播。由于数据通过HTTP协议传输，所以完全不用考虑防火墙或者代理的问题，而且分段文件的时长很短，客户端可以很快的选择和切换码率，以适应不同带宽条件下的播放。不过HLS的这种技术特点，决定了它的延迟一般总是会高于普通的流媒体直播协议。它也解决了RTMP协议存在的一些问题，例如RTMP协议不使用标准的HTTP接口传输数据(TCP、UDP端口)，所以在一些特殊的网络环境下可能被防火墙屏蔽掉，而HLS使用的是HTTP协议传输数据(80端口)，不会遇到被防火墙屏蔽的情况。
+
+## TS
+
+TS(Transport Stream)，全程为MPEG2-TS。它的特点就是要求从视频流的任一片段开始都是可以独立解码的。DVD节目中的MPEG2格式，确切的说是MPEG2-PS，全程是Program Stream，而TS的全称是Transport Stream。MPEG2-PS主要应用于存储的具有固定市场的节目，如DVD电影，而MPEG2-TS则主要应用于实时传送的节目，比如实时广播的电视节目。这两种格式的主要区别是什么呢？简单地打个比喻说，你将DVD上的[VOB](https://baike.baidu.com/item/VOB)文件的前面一截cut掉（或者干脆就是数据损坏），那么就会导致整个文件无法解码了，而电视节目是你任何时候打开电视机都能解码（收看）的，所以，MPEG2-TS格式的特点就是要求从[视频流](https://baike.baidu.com/item/视频流)的任一片段开始都是可以独立解码的。
+
+
+
+在开始一个流媒体会话时，客户端会下载一个包含元数据的extended M3U(m3u8)  playlist文件，用于寻找可用的媒体流(将视频分为一个个视频小分片，然后用m3u8索引表进行管理，由于客户端下载到的视频都是5-10秒的完整数据，所以视频的流畅性很好，但是同样也引入了很大的延迟(一般延迟在10-30s左右))。
+
+- 是一个索引地址/播放列表，通过FFmpeg将本地的xxx.mp4进行切片处理，生成m3u8播放列表（索引文件）和N多个  .ts文件，并将其（m3u8、N个ts）放置在本地搭建好的webServer服务器的指定目录下，我就可以得到一个可以实时播放的网址，我们把这个m3u8地址复制到 VLC 上就可以实时观看！ 在 HLS 流下，本地视频被分割成一个一个的小切片，一般10秒一个，这些个小切片被 m3u8管理，并且随着终端的FFmpeg  向本地拉流的命令而实时更新，影片进度随着拉流的进度而更新，播放过的片段不在本地保存，自动删除，直到该文件播放完毕或停止，ts  切片会相应的被删除，流停止，影片不会立即停止，影片播放会滞后于拉流一段时间
+
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/transport_stream_2x.png" style="zoom:50%;" />
+
+- Media encoder(媒体编码)
+
+媒体编码器获取到音视频设备的实时信号，将其编码后压缩用于传输
+
+- Stream segmenter(流切片器)
+
+  通常是一个软件，将流进行切片，切片的同时会创建一个索引文件(index file)，索引文件会包含这些切片的引用。
+
+从左到右讲，左下方的inputs的视频源是什么格式都无所谓，他与server之间的通信协议也可以任意（比如RTMP），总之只要把视频数据传输到服务器上即可。这个视频在server服务器上被转换成HLS格式的视频（既TS和m3u8文件）文件。细拆分来看server里面的Media encoder的是一个转码模块负责将视频源中的视频数据转码到目标编码格式（H264）的视频数据，视频源的编码格式可以是任何的视频编码格式。转码成H264视频数据之后用硬件打包到MPEG-2(MPEG-2 Transport Stream)的传输流中，传输流再经过stream segmenter模块，它的工作是把MPEG-2传输流分散为小片段然后保存为一个或多个系列的.ts格式的媒体文件，结果就是index file（m3u8）和ts文件了。图中的Distribution其实只是一个普通的HTTP文件服务器，然后客户端只需要访问一级index文件的路径就会自动播放HLS视频流了。
+
+### 多码率适配流(Master Playlist)
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/indexing_2x.png" style="zoom:70%;" />
+
+客户端播放HLS视频流的逻辑其实非常简单，先下载一级Index file，它里面记录了二级索引文件（Alternate-A、Alternate-B、Alternate-C）的地址，然后客户端再去下载二级索引文件，二级索引文件中又记录了TS文件的下载地址，这样客户端就可以按顺序下载TS视频文件并连续播放。
+
+#### 一级index文件
+
+```bash
+#EXTM3U    // m3u8文件头
+#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=1064000
+1000kbps.m3u8
+#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=564000
+500kbps.m3u8
+#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=282000
+250kbps.m3u8
+#EXT-X-STREAM-INF:PROGRAM-ID=1,BANDWIDTH=2128000
+2000kbps.m3u8
+```
+
+bandwidth指定视频流的比特率，PROGRAM-ID无用无需关注，每一个#EXT-X-STREAM-INF的下一行是二级index文件的路径，可以用相对路径也可以用绝对路径。例子中用的是相对路径。这个文件中记录了不同比特率视频流的二级index文件路径，客户端可以自己判断自己的现行网络带宽，来决定播放哪一个视频流。也可以在网络带宽变化的时候平滑切换到和带宽匹配的视频流。客户端会默认选择码率最高的情况，如果发现码率达不到，会请求降低码率的流。
+
+```css
+#EXTM3U
+#EXT-X-PLAYLIST-TYPE:VOD
+#EXT-X-TARGETDURATION:10  // 指定当前视频流中的单个切片(ts)文件的最大时长(秒)
+#EXTINF:10,     // 指定每个媒体段ts的持续时间
+2000kbps-00001.ts
+#EXTINF:10,
+2000kbps-00002.ts
+#EXTINF:10,
+2000kbps-00003.ts
+#EXTINF:10,
+2000kbps-00004.ts
+#EXTINF:10,
+
+... ...
+
+#EXTINF:10,
+2000kbps-00096.ts
+#EXTINF:10,
+2000kbps-00097.ts
+#EXTINF:10,
+2000kbps-00098.ts
+#EXTINF:10,
+2000kbps-00099.ts
+#EXTINF:10,
+2000kbps-00100.ts
+#ZEN-TOTAL-DURATION:999.66667
+#ZEN-AVERAGE-BANDWIDTH:2190954
+#ZEN-MAXIMUM-BANDWIDTH:3536205
+#EXT-X-ENDLIST
+```
+
+二级文件实际负责给出ts文件的下载地址，这里同样使用了相对路径。#EXTINF表示每个ts切片视频文件的时长。#EXT-X-TARGETDURATION指定当前视频流中的切片文件的最大时长，也就是说这些ts切片的时长不能大于#EXT-X-TARGETDURATION的值。#EXT-X-PLAYLIST-TYPE:VOD的意思是当前的视频流并不是一个直播流，而是点播流，换句话说就是该视频的全部的ts文件已经被生成好了，#EXT-X-ENDLIST这个表示视频结束，有这个标志同时也说明当前的流是一个非直播流。
+
+#### 播放模式
+
+- **点播VOD**的特点就是当前时间点可以获取到所有index文件和ts文件，二级index文件中记录了所有ts文件的地址。这种模式允许客户端访问全部内容。上面的例子中就是一个点播模式下的m3u8的结构。
+- **Live** 模式就是实时生成M3u8和ts文件。它的索引文件一直处于动态变化的，播放的时候需要不断下载二级index文件，以获得最新生成的ts文件播放视频。如果一个二级index文件的末尾没有#EXT-X-ENDLIST标志，说明它是一个Live视频流。
+
+客户端在播放VOD模式的视频时其实只需要下载一次一级index文件和二级index文件就可以得到所有ts文件的下载地址，除非客户端进行比特率切换，否则无需再下载任何index文件，只需顺序下载ts文件并播放就可以了。但是Live模式下略有不同，因为播放的同时，新ts文件也在被生成中，所以客户端实际上是下载一次二级index文件，然后下载ts文件，再下载二级index文件（这个时候这个二级index文件已经被重写，记录了新生成的ts文件的下载地址）,再下载新ts文件，如此反复进行播放。
+
+### 单码率适配流(Media Playlist)
+
+[http://devimages.apple.com/iphone/samples/bipbop/bipbopall.m3u8](https://link.jianshu.com?t=http%3A%2F%2Fwww.modrails.com%2Fvideos%2Fpassenger_nginx.mov)
+
+```
+#EXTM3U                           // m3u8文件头
+#EXT-X-VERSION:3                  // 协议版本，不写默认是1
+#EXT-X-MEDIA-SEQUENCE:304240      // 第一个ts文件的序列号
+#EXT-X-TARGETDURATION:10          // 每个ts文件的最大时长
+#EXTINF:10.000,                   // 每个ts文件的持续时间
+cctv1hd-1585920024000.ts          // ts文件的url
+#EXTINF:10.000,
+cctv1hd-1585920034000.ts
+#EXTINF:10.000,
+cctv1hd-1585920044000.ts
+#EXTINF:10.000,
+cctv1hd-1585920054000.ts
+#EXTINF:10.000,
+cctv1hd-1585920064000.ts
+#EXTINF:10.000,
+cctv1hd-1585920074000.ts
+```
+
+
+
+
+
+## HLS 的优势
+
+- 客户端支持简单, 只需要支持 HTTP 请求即可, HTTP 协议无状态, 只需要按顺序下载媒体片段即可.
+- 使用 HTTP 协议网络兼容性好, HTTP 数据包也可以方便地通过防火墙或者代理服务器, CDN 支持良好.
+- Apple 的全系列产品支持, 由于 HLS 是苹果提出的, 所以在 Apple 的全系列产品包括 iphone, ipad, safari 都不需要安装任何插件就可以原生支持播放 HLS, 现在, Android 也加入了对 HLS 的支持.
+- 自带多码率自适应, Apple 在提出 HLS 时, 就已经考虑了码流自适应的问题.
+
+## HLS 的劣势
+
+- 相比 RTMP 这类长连接协议, 延时较高, 难以用到互动直播场景.HLS 理论延时 = 1 个切片的时长 + 0-1个 td (td 是 EXT-X-TARGETDURATION, 可简单理解为播放器取片的间隔时间) + 0-n 个启动切片(苹果官方建议是请求到 3 个片之后才开始播放) + 播放器最开始请求的片的网络延时(网络连接耗时)。为了追求低延时效果, 可以将切片切的更小, 取片间隔做的更小, 播放器未取到 3 个片就启动播放. 但是, 这些优化方式都会增加 HLS 不稳定和出现错误的风险.
+- 对于点播服务来说, 由于 TS 切片通常较小, 海量碎片在文件分发, 一致性缓存, 存储等方面都有较大挑战.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\351\200\232\344\277\241\345\215\217\350\256\256.md" "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/\346\265\201\345\252\222\344\275\223\351\200\232\344\277\241\345\215\217\350\256\256.md"
similarity index 100%
rename from "VideoDevelopment/\346\265\201\345\252\222\344\275\223\351\200\232\344\277\241\345\215\217\350\256\256.md"
rename to "VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/\346\265\201\345\252\222\344\275\223\351\200\232\344\277\241\345\215\217\350\256\256.md"

From 6910f48f6e2d8556bdd9d08c9db07dba6ada021d Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 6 Apr 2020 21:46:08 +0800
Subject: [PATCH 017/213] add notes

---
 README.md                                              | 10 ++++++++--
 .../DASH.md"                                           |  6 ------
 ...351\200\232\344\277\241\345\215\217\350\256\256.md" |  4 ++--
 3 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/README.md b/README.md
index 82ccb40e..2aeb5d5f 100644
--- a/README.md
+++ b/README.md
@@ -53,7 +53,10 @@ Android学习笔记
     - [DNS及HTTPDNS][23]
     - [DLNA简介][24]
     - [AudioTrack简介][214]
-    - [流媒体通信协议][224]
+    - [流媒体协议][224]
+        - [流媒体通信协议][246]
+        - [HLS][247]
+        - [DASH][248]
     - [ExoPlayer][216]
         - [1. ExoPlayer简介.md][217]
         - [2. ExoPlayer MediaSource简介][218]
@@ -499,7 +502,7 @@ Android学习笔记
 [221]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/ExoPlayer/5.%20ExoPlayer%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90%E4%B9%8BPlayerView.md "5. ExoPlayer源码分析之PlayerView"
 [222]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E5%8F%8D%E7%BC%96%E8%AF%91.md "反编译"
 [223]: https://github.com/CharonChui/AndroidNote/blob/master/Tools%26Library/Icon%E5%88%B6%E4%BD%9C.md "Icon制作"
-[224]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E9%80%9A%E4%BF%A1%E5%8D%8F%E8%AE%AE.md "流媒体通信协议"
+[224]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE "流媒体协议"
 [225]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/MP4%E6%A0%BC%E5%BC%8F%E8%AF%A6%E8%A7%A3.md "MP4格式详解"
 [226]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/SurfaceView%E4%B8%8ETextureView.md "SurfaceView与TextureView"
 [227]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E5%85%B3%E9%94%AE%E5%B8%A7.md "关键帧"
@@ -521,6 +524,9 @@ Android学习笔记
 [243]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/Danmaku "弹幕"
 [244]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/Danmaku/Android%E5%BC%B9%E5%B9%95%E5%AE%9E%E7%8E%B0.md "Android弹幕实现"
 [245]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/MediaExtractor%E3%80%81MediaCodec%E3%80%81MediaMuxer.md "MediaExtractor、MediaCodec、MediaMuxer"
+[246]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE/%E6%B5%81%E5%AA%92%E4%BD%93%E9%80%9A%E4%BF%A1%E5%8D%8F%E8%AE%AE.md "流媒体通信协议"
+[247]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE/HLS.md "HLS"
+[248]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE/DASH.md "DASH"
 
 
 
diff --git "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/DASH.md" "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/DASH.md"
index bb951503..a9969659 100644
--- "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/DASH.md"
+++ "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/DASH.md"
@@ -60,12 +60,6 @@ Segments可以包含任何媒体数据，关于容器，官方提供了两种建
 
   SAP：Stream Acess Point，可以简单理解为I帧，每个Segment的第一个帧都是SAP，因此Seek时可直接Seek到某一个Segment的起始位置，利用Init Segment+Seek到的某个Segment的数据，在解封装后可实现完美解码。一般来说，同一个Adaptation set中的多个Representation是Segment Align的（当Adaptation set的属性@segmentAlignment不为false时），因此，当从Representation A切换到Representation B时，如果当前Representation A的第N个Segment已经下载完成，切换时直接下载Representation B的第N+1个Segment即可。
 
-
-    
-    
-
-![dash_compare2.png](https://raw.githubusercontent.com/CharonChui/Pictures/master/dash_compare2.png)
-
 码率自适应切换算法
 
 - 基于带宽的码率自适应切换算法
diff --git "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/\346\265\201\345\252\222\344\275\223\351\200\232\344\277\241\345\215\217\350\256\256.md" "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/\346\265\201\345\252\222\344\275\223\351\200\232\344\277\241\345\215\217\350\256\256.md"
index b4fbe002..6521d7ff 100644
--- "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/\346\265\201\345\252\222\344\275\223\351\200\232\344\277\241\345\215\217\350\256\256.md"
+++ "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/\346\265\201\345\252\222\344\275\223\351\200\232\344\277\241\345\215\217\350\256\256.md"
@@ -1,6 +1,6 @@
 流媒体通信协议
 ===
- 
+
 
 流媒体(Streaming Media)是指采用流式传输技术在网络上连续实时播放的媒体格式，如音频、视频或多媒体文件，采用流媒体技术使得数据包得以像流水一样发送, 如果没有流媒体技术, 那么我们就要像以前用迅雷下电影一样, 下载整个影片才能观看。   
 
@@ -78,7 +78,7 @@ Smooth Streaming
 ---
 微软提供的一套解决方案，是IIS的媒体服务扩张，用于支持基于HTTP的自适应串流，它的文件切片为mp4，索引文件为ism/ismc。
 
-
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/dash_compare2.png)
 
 ***视频编码标准和音频编码标准是`H.264`和`AAC`，这两种标准分别是当今实际应用中编码效率最高的视频标准和音频标准。***
 

From bfd962ed5b3fa9ba05f5e372517e734f8fe58658 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 8 Apr 2020 10:47:47 +0800
Subject: [PATCH 018/213] update

---
 .../DASH.md"                                  | 81 +++++++++++++++++--
 .../HLS.md"                                   |  6 +-
 2 files changed, 76 insertions(+), 11 deletions(-)

diff --git "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/DASH.md" "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/DASH.md"
index a9969659..fc9c87fe 100644
--- "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/DASH.md"
+++ "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/DASH.md"
@@ -24,6 +24,32 @@ DASH的整个流程:
 
 ![image-20200406164238038](https://raw.githubusercontent.com/CharonChui/Pictures/master/mpd_hierarchical_data.png)
 
+
+
+```xml
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<MPD id="0564e940-122b-42bb-9d56-98f3def67247" profiles="urn:mpeg:dash:profile:isoff-main:2011" type="static" availabilityStartTime="2016-01-14T09:30:35.000Z" publishTime="2016-01-14T09:31:33.000Z" mediaPresentationDuration="P0Y0M0DT0H2M17.000S" minBufferTime="P0Y0M0DT0H0M1.000S" bitmovin:version="1.6.0" xmlns:ns2="http://www.w3.org/1999/xlink" xmlns="urn:mpeg:dash:schema:mpd:2011" xmlns:bitmovin="http://www.bitmovin.net/mpd/2015">
+    <Period>
+        <AdaptationSet mimeType="video/mp4" codecs="avc1.42c00d">
+            <SegmentTemplate media="../video/$RepresentationID$/dash/segment_$Number$.m4s" initialization="../video/$RepresentationID$/dash/init.mp4" duration="120119" startNumber="0" timescale="30000"/>
+            <Representation id="1920_9000000" bandwidth="9000000" width="3840" height="1920" frameRate="30"/>
+            <Representation id="1080_5000000" bandwidth="5000000" width="2160" height="1080" frameRate="30"/>
+            <Representation id="720_3000000" bandwidth="3000000" width="1440" height="720" frameRate="30"/>
+            <Representation id="540_1500000" bandwidth="1500000" width="1080" height="540" frameRate="30"/>
+            <Representation id="360_1000000" bandwidth="1000000" width="720" height="360" frameRate="30"/>
+        </AdaptationSet>
+        <AdaptationSet lang="en" mimeType="audio/mp4" codecs="mp4a.40.2" bitmovin:label="english stereo">
+            <AudioChannelConfiguration schemeIdUri="urn:mpeg:dash:23003:3:audio_channel_configuration:2011" value="2"/>
+            <SegmentTemplate media="../audio/$RepresentationID$/dash/segment_$Number$.m4s" initialization="../audio/$RepresentationID$/dash/init.mp4" duration="191472" startNumber="0" timescale="48000"/>
+            <Representation id="1_stereo_128000" bandwidth="128000" audioSamplingRate="48000"/>
+        </AdaptationSet>
+    </Period>
+</MPD>
+
+```
+
+
+
 ### MPD
 
 DASH采用3GPP AHS中定义的MPD(Media Presentation Description)作为媒体文件的描述文件（manifest），作用类似HLS的m3u8文件。MPD文件以XML格式组织，用于描述segment的信息，比如时间、url、视频分辨率、码率等。   
@@ -79,14 +105,6 @@ Segments可以包含任何媒体数据，关于容器，官方提供了两种建
 
 
 
-## DASH地址
-
-http://ftp.itec.aau.at/datasets/mmsys12/BigBuckBunny/MPDs/BigBuckBunnyNonSeg_2s_isoffmain_DIS_23009_1_v_2_1c2_2011_08_30.mpd
-
-http://www-itec.uni-klu.ac.at/ftp/datasets/mmsys12/BigBuckBunny/bunny_2s/bunny_2s_50kbit/bunny_50kbit_dashNonSeg.mp4
-
-
-
 ## fMP4
 
 fMP4（fragmented MP4），可以简单理解为分片化的MP4，是DASH采用的媒体文件格式，文件扩展名通常为（.m4s或直接用.mp4）。     
@@ -147,6 +165,53 @@ DASH和HLS之间的另一个关键区别是它支持DRM。可是，在DASH中不
 
 
 
+### 测试流
+
+- HEVC HLS with fMP4: [http://bitmovin-a.akamaihd.net/content/dataset/multi-codec/hevc/stream_fmp4.m3u8](https://bitmovin-a.akamaihd.net/content/dataset/multi-codec/hevc/stream_fmp4.m3u8)
+
+    
+
+- HEVC HLS with TS (not supported by Apple): [http://bitmovin-a.akamaihd.net/content/dataset/multi-codec/hevc/stream_ts.m3u8](https://bitmovin-a.akamaihd.net/content/dataset/multi-codec/hevc/stream_ts.m3u8)
+
+    [https://bitmovin-a.akamaihd.net/content/playhouse-vr/m3u8s/105560.m3u8](https://bitmovin-a.akamaihd.net/content/playhouse-vr/m3u8s/105560.m3u8)
+
+- HEVC MPEG-DASH: [http://bitmovin-a.akamaihd.net/content/dataset/multi-codec/hevc/stream.mpd](https://bitmovin-a.akamaihd.net/content/dataset/multi-codec/hevc/stream.mpd)
+
+- Multi-Codec MPEG-DASH (AVC/H.264, HEVC/H.265, VP9): http://bitmovin-a.akamaihd.net/content/dataset/multi-codec/stream.mpd
+
+    https://bitmovin-a.akamaihd.net/content/playhouse-vr/mpds/105560.mpd
+
+- VP9 MPEG-DASH: http://bitmovin-a.akamaihd.net/content/dataset/multi-codec/stream_vp9.mpd
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+在线测试播放器: 
+
+http://demo.theoplayer.com/test-your-stream-with-statistics
+
+
 
 
 
diff --git "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HLS.md" "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HLS.md"
index 62acc949..3aede2fa 100644
--- "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HLS.md"
+++ "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HLS.md"
@@ -4,8 +4,8 @@
 
 HLS协议规定:  
 
-- 视频的封装格式是TS
-- 视频的编码格式为H264，音频编码格式为MP3、AAC或者AC-3
+- 视频的封装格式是ts(16年发布也支持了fMP4)
+- 视频的编码格式为H264、H265、VP9(17年支持H265、VP9)，音频编码格式为MP3、AAC或者AC-3
 - 除了TS视频文件本身，还定义了用来控制播放的m3u8文件(文本文件)
 
 HLS协议由三部分组成:  
@@ -41,7 +41,7 @@ TS(Transport Stream)，全程为MPEG2-TS。它的特点就是要求从视频流
 
 ### 多码率适配流(Master Playlist)
 
-<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/indexing_2x.png" style="zoom:70%;" />
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/adaptive_bitratestreaming_HLS.jpg" style="zoom:70%;" />
 
 客户端播放HLS视频流的逻辑其实非常简单，先下载一级Index file，它里面记录了二级索引文件（Alternate-A、Alternate-B、Alternate-C）的地址，然后客户端再去下载二级索引文件，二级索引文件中又记录了TS文件的下载地址，这样客户端就可以按顺序下载TS视频文件并连续播放。
 

From 98afb02c9ad3e638be5bc347e4505b60de4ede8b Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 22 Apr 2020 21:11:03 +0800
Subject: [PATCH 019/213] update

---
 README.md                                     | 13 ++++----
 .../SurfaceView\344\270\216TextureView.md"    | 12 +++++--
 .../DASH.md"                                  | 32 +++++++++++++++++--
 ...32\344\277\241\345\215\217\350\256\256.md" |  4 +++
 4 files changed, 50 insertions(+), 11 deletions(-)

diff --git a/README.md b/README.md
index 2aeb5d5f..ae74c648 100644
--- a/README.md
+++ b/README.md
@@ -276,8 +276,8 @@ Android学习笔记
     - [反编译][222]
     
 
-[1]: https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/%E8%87%AA%E5%AE%9A%E4%B9%89View%E8%AF%A6%E8%A7%A3.md        "自定义View详解" 
-[2]: https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/Activity%E7%95%8C%E9%9D%A2%E7%BB%98%E5%88%B6%E8%BF%87%E7%A8%8B%E8%AF%A6%E8%A7%A3.md  "Activity界面绘制过程详解" 
+[1]: https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/%E8%87%AA%E5%AE%9A%E4%B9%89View%E8%AF%A6%E8%A7%A3.md        "自定义View详解"
+[2]: https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/Activity%E7%95%8C%E9%9D%A2%E7%BB%98%E5%88%B6%E8%BF%87%E7%A8%8B%E8%AF%A6%E8%A7%A3.md  "Activity界面绘制过程详解"
 [3]: https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/Activity%E5%90%AF%E5%8A%A8%E8%BF%87%E7%A8%8B.md    "Activity启动过程"
 [4]: https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/Android%20Touch%E4%BA%8B%E4%BB%B6%E5%88%86%E5%8F%91%E8%AF%A6%E8%A7%A3.md    "Android Touch事件分发详解"
 [5]: https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/AsyncTask%E8%AF%A6%E8%A7%A3.md   "AsyncTask详解"
@@ -518,7 +518,8 @@ Android学习笔记
 [237]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/6.OpenGL%20ES%E7%BB%98%E5%88%B6%E7%9F%A9%E5%BD%A2%E5%8F%8A%E5%9C%86%E5%BD%A2.md "6.OpenGL ES绘制矩形及圆形"
 [238]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/7.OpenGL%20ES%E7%9D%80%E8%89%B2%E5%99%A8%E8%AF%AD%E8%A8%80GLSL.md "7.OpenGL ES着色器语言GLSL"
 [239]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/8.GLES%E7%B1%BB%E5%8F%8AMatrix%E7%B1%BB.md "8.GLES类及Matrix类"
-[240]:  "https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/9.OpenGL%20ES%E7%BA%B9%E7%90%86.md "9.OpenGL ES纹理"
+
+[240]:  https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/9.OpenGL%20ES%E7%BA%B9%E7%90%86.md "9.OpenGL ES纹理"
 [241]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md " 10.GLSurfaceView+MediaPlayer播放视频"
 [242]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/11.OpenGL%20ES%E6%BB%A4%E9%95%9C.md "11.OpenGL ES滤镜"
 [243]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/Danmaku "弹幕"
@@ -541,13 +542,13 @@ License
 ===
 
     Copyright (C) 2013 Charon Chui <charon.chui@gmail.com>
-
+    
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
     You may obtain a copy of the License at
-
+    
        http://www.apache.org/licenses/LICENSE-2.0
-
+    
     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
diff --git "a/VideoDevelopment/SurfaceView\344\270\216TextureView.md" "b/VideoDevelopment/SurfaceView\344\270\216TextureView.md"
index 4234918a..de765b86 100644
--- "a/VideoDevelopment/SurfaceView\344\270\216TextureView.md"
+++ "b/VideoDevelopment/SurfaceView\344\270\216TextureView.md"
@@ -82,15 +82,21 @@ SurfaceTexture.OnFrameAvailableListener用于通知TextureView内容流有新图
 SurfaceTexture可以用作非直接输出的内容流，这样就提供二次处理的机会。与SurfaceView直接输出相比，这样会有若干帧的延迟。同时，由于它本身管理BufferQueue，因此内存消耗也会稍微大一些。
 TextureView是一个可以把内容流作为外部纹理输出在上面的View, 它本身需要是一个硬件加速层。
 
-
 ### SurfaceTexture
 
-SurfaceTexture是Surface和OpenGL ES(GLES)纹理的组合。SurfaceTexture用于提供输出到GLES 纹理的Surface。
+SurfaceTexture是Surface和OpenGL ES(GLES)纹理的组合。SurfaceTexture用于提供输出到GLES 纹理的Surface。SurfaceTexture是从Android 3.0开始加入，与SurfaceView不同的是，它对图像流的处理并不直接显示，而是转为GL外部纹理，因此用于图像流数据的二次处理。比如Camera的预览数据，变成纹理后可以交给GLSurfaceView直接显示，也可以通过SurfaceTexture交给TextureView作为View heirachy中的一个硬件加速层来显示。首先，SurfaceTexture从图像流(来自Camera预览、视频解码、GL绘制场景等)中获得帧数据，当调用updateTexImage()时，根据内容流中最近的图像更新SurfaceTexture对应的GL纹理对象。
+
+
 
 SurfaceTexture 包含一个应用是其使用方的BufferQueue。当生产方将新的缓冲区排入队列时，onFrameAvailable() 回调会通知应用。然后，应用调用updateTexImage()，这会释放先前占有的缓冲区，从队列中获取新缓冲区并执行EGL调用，从而使GLES可将此缓冲区作为外部纹理使用。
 
 ## SurfaceView vs TextureView
 
+
+
+简单地说，SurfaceView是一个有自己Surface的View。它的渲染可以放在单独线程而不是主线程中。其缺点是不能做变形和动画。SurfaceTexture可以用作非直接输出的内容流，这样就提供二次处理的机会。与SurfaceView直接输出相比，这样会有若干帧的延迟。同时，由于它本身管理BufferQueue，因此内存消耗也会稍微大一些。TextureView是一个可以把内容流作为外部纹理输出在上面的View。它本身需要是一个硬件加速层。事实上TextureView本身也包含了SurfaceTexture。它与SurfaceView+SurfaceTexture组合相比可以完成类似的功能（即把内容流上的图像转成纹理，然后输出）。区别在于TextureView是在View hierachy中做绘制，因此一般它是在主线程上做的（在Android 5.0引入渲染线程后，它是在渲染线程中做的）。而SurfaceView+SurfaceTexture在单独的Surface上做绘制，可以是用户提供的线程，而不是系统的主线程或是渲染线程。
+
+
 与 SurfaceView 相比，TextureView 具有更出色的 Alpha 版和旋转处理能力，但在视频上以分层方式合成界面元素时，SurfaceView 具有性能方面的优势。当客户端使用 SurfaceView 呈现内容时，SurfaceView 会为客户端提供单独的合成层。如果设备支持，SurfaceFlinger 会将单独的层合成为硬件叠加层。当客户端使用 TextureView 呈现内容时，界面工具包会使用 GPU 将 TextureView 的内容合成到 View 层次结构中。对内容进行的更新可能会导致其他 View 元素重绘，例如，如果其他 View 位于 TextureView 上方。View 呈现完成后，SurfaceFlinger 会合成应用界面层和所有其他层，以便每个可见像素合成两次。
 
 ***注意：受 DRM 保护的视频只能在叠加平面上呈现。支持受保护内容的视频播放器必须使用 SurfaceView 进行实现。***
@@ -113,7 +119,7 @@ SurfaceTexture 包含一个应用是其使用方的BufferQueue。当生产方将
 
 
 
-    
+​    
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
diff --git "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/DASH.md" "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/DASH.md"
index fc9c87fe..0ebf8bd3 100644
--- "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/DASH.md"
+++ "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/DASH.md"
@@ -1,6 +1,6 @@
 # 简介
 
-除了前面将的Apple的HLS，还有Adobe HTTP Dynamic Streaming (HDS)、Microsoft Smooth Streaming (MSS)。他们各家的协议原理大致相同，但是格式又不一样，也无法兼容，所以Moving Picture Expert Group (MPEG) 就把大家叫到了一起，呼吁大家一起来制定一个标准的，然后就有了[MPEG-DASH](https://www.encoding.com/mpeg-dash/),它的主要目标是形成IP网络承载单一格式的流媒体并提供高效与高质量服务的统一方案，解决多制式传输方案(HTTP Live  Streaming, Microsoft Smooth Streaming, HTTP Dynamic  Streaming)并存格局下的存储与服务能力浪费、运营高成本与复杂度、系统间互操作弱等问题。
+除了前面讲的Apple的HLS，还有Adobe HTTP Dynamic Streaming (HDS)、Microsoft Smooth Streaming (MSS)。他们各家的协议原理大致相同，但是格式又不一样，也无法兼容，所以Moving Picture Expert Group (MPEG) 就把大家叫到了一起，呼吁大家一起来制定一个标准的，然后就有了[MPEG-DASH](https://www.encoding.com/mpeg-dash/),它的主要目标是形成IP网络承载单一格式的流媒体并提供高效与高质量服务的统一方案，解决多制式传输方案(HTTP Live  Streaming, Microsoft Smooth Streaming, HTTP Dynamic  Streaming)并存格局下的存储与服务能力浪费、运营高成本与复杂度、系统间互操作弱等问题。
 
 [DASH(MPEG-DASH)](https://mpeg.chiariglione.org/standards/mpeg-dash/)全称为Dynamic Adaptive Streaming over HTTP.是由MPEG和ISO批准的独立于供应商的国际标准，它是一种基于HTTP的使用TCP传输协议的流媒体传输技术。MPEG-DASH是一种自适应比特率流技术，可根据实时网络状况实现动态自适应下载。和HLS, HDS技术类似， 都是把视频分割成一小段一小段，  通过HTTP协议进行传输，客户端得到之后进行播放；不同的是MPEG-DASH支持MPEG-2 TS、MP4(最新的HLS也支持了MP4)等多种格式,  可以将视频按照多种编码切割, 下载下来的媒体格式既可以是ts文件也可以是mp4文件，MPEG—DASH技术与编解码器无关，可使用H.265，H.264，VP9等任何编解码器进行编码。
 
@@ -105,8 +105,30 @@ Segments可以包含任何媒体数据，关于容器，官方提供了两种建
 
 
 
+## 为什么使用DASH
+
+- DASH支持多种编码，支持H.265、H.264、VP9等。
+
+- DASH支持MultiDRM，支持PlayReady、Widewine，采用通用加密技术，支持终端自带DRM，可以大幅度降低DRM投资成本。
+
+- DASH支持多种文件封装，支持MPEG-4、MPEG-2 TS。
+
+- DASH支持多种CDN对接，采用相同的封装描述对接多厂家CDN。
+
+- DASH支持直播、点播、录制等丰富的视频特性。
+
+- DASH支持动态码率适配Adaptive Bitrate (ABR) ，支持多码率平滑切换。
+
+- DASH支持缩略型描述以支持快速启动。
+
+    
+
 ## fMP4
 
+[MP4和fMP4的详细介绍](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/MP4%E6%A0%BC%E5%BC%8F%E8%AF%A6%E8%A7%A3.md)
+
+
+
 fMP4（fragmented MP4），可以简单理解为分片化的MP4，是DASH采用的媒体文件格式，文件扩展名通常为（.m4s或直接用.mp4）。     
 
 ![fMP4](https://img-blog.csdn.net/20171107114807709?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQveXVlX2h1YW5n/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
@@ -115,6 +137,10 @@ fMP4（fragmented MP4），可以简单理解为分片化的MP4，是DASH采用
 
 ### fMP4与ts的区别
 
+最主要的就是.ts文件不提供关于时长等信息，你无法在ts文件中去实现音视频的seek操作。fmp4不同于ts，它是提供了时长等信息，可以执行seek到指定位置。
+
+
+
 ### 媒体数据与元数据的分离
 
 在mp4格式中，元数据可以和媒体数据很好地分开存储，后者都在mdat box中，而在ts中，诸多es流和header/metadata信息是复用在一起的。
@@ -185,9 +211,11 @@ DASH和HLS之间的另一个关键区别是它支持DRM。可是，在DASH中不
 
 
 
+参考:  
 
+[HLS，MPEG-DASH - What is ABR?](http://telestreamblog.telestream.net/2017/05/what-is-abr/)
 
-
+[B站我们为什么使用DASH](https://www.bilibili.com/read/cv855111)
 
 
 
diff --git "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/\346\265\201\345\252\222\344\275\223\351\200\232\344\277\241\345\215\217\350\256\256.md" "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/\346\265\201\345\252\222\344\275\223\351\200\232\344\277\241\345\215\217\350\256\256.md"
index 6521d7ff..644494bf 100644
--- "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/\346\265\201\345\252\222\344\275\223\351\200\232\344\277\241\345\215\217\350\256\256.md"
+++ "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/\346\265\201\345\252\222\344\275\223\351\200\232\344\277\241\345\215\217\350\256\256.md"
@@ -54,6 +54,8 @@ HLS的整体流程为:
 
 视频源文件 -> 服务器(编码器、流分割器) -> 分发器(索引文件、*.ts) -> 传输网络 -> 客户端
 
+[HLS的详细介绍](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE/HLS.md)
+
 HDS
 ---
 `Http Dynamic Streaming`:是一个由Adobe公司模仿HLS协议提出的另一个基于Http的流媒体传输协议。其模式与HLS类似，也是索引文件和媒体切片文件结合的下载方式，但是又要比HLS协议更复杂。
@@ -73,6 +75,8 @@ DASH的整个流程:
 
 内容生成服务器(编码模块、封装模块) -> 流媒体服务器(MPD、媒体文件、HTTP服务器) <-> DASH客户端(控制引擎、媒体引擎、HTTP接入容器)
 
+[DASH详细介绍](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE/DASH.md)
+
 
 Smooth Streaming
 ---

From 5f18eddee276ecc18324d27c4fa6c1985df06861 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 27 May 2020 16:32:01 +0800
Subject: [PATCH 020/213] update notes

---
 "VideoDevelopment/CDN\345\217\212PCDN.md"     | 147 ++++++++++++++----
 .../DLNA\347\256\200\344\273\213.md"          |   9 +-
 .../P2P\346\212\200\346\234\257/P2P.md"       |   0
 ...47\220\206_NAT\347\251\277\351\200\217.md" |  71 +++++++++
 .../\345\205\263\351\224\256\345\270\247.md"  |  38 ++++-
 ...47\350\203\275\344\274\230\345\214\226.md" |   3 +-
 ...32\344\277\241\345\215\217\350\256\256.md" |  12 +-
 .../AV1.md"                                   | 101 ++++++++++++
 .../H264.md"                                  | 101 ++++++++++++
 .../H265.md"                                  | 101 ++++++++++++
 ...72\347\241\200\347\237\245\350\257\206.md" |   4 +
 11 files changed, 540 insertions(+), 47 deletions(-)
 rename VideoDevelopment/P2P.md => "VideoDevelopment/P2P\346\212\200\346\234\257/P2P.md" (100%)
 create mode 100644 "VideoDevelopment/P2P\346\212\200\346\234\257/P2P\345\216\237\347\220\206_NAT\347\251\277\351\200\217.md"
 create mode 100644 "VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/AV1.md"
 create mode 100644 "VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/H264.md"
 create mode 100644 "VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/H265.md"

diff --git "a/VideoDevelopment/CDN\345\217\212PCDN.md" "b/VideoDevelopment/CDN\345\217\212PCDN.md"
index 084186b0..672f475e 100644
--- "a/VideoDevelopment/CDN\345\217\212PCDN.md"
+++ "b/VideoDevelopment/CDN\345\217\212PCDN.md"
@@ -39,14 +39,11 @@ CDN网络中包含的功能实体包括以下部分:
 - 内容缓存:CDN网络节点，位于用户接入点，是面向最终用户的内容提供设备，可缓存静态Web内容和流媒
 体内容，实现内容的边缘传播和存储，以便用户的就近访问。它借助于建立索引、缓存、流分裂、组播（Multicast）等技术，将内容发布或投递到距离用户最近的远程服务点（POP）处。
 内容分发包含从内容源到CDN边缘的Cache的过程。从实现上，有两种主流的内容分发技术：PUSH和PULL。
-PUSH是一种主动分发的技术。通常，PUSH由内容管理系统发起，将内容从源或者中心媒体资源库分发到各边缘的
-Cache节点。分发的协议可以采用Http/ftp等。通过PUSH分发的内容一般是比较热点的内容，
+PUSH是一种主动分发的技术。通常，PUSH由内容管理系统发起，将内容从源或者中心媒体资源库分发到各边缘的Cache节点。分发的协议可以采用Http/ftp等。通过PUSH分发的内容一般是比较热点的内容，
 这些内容通过PUSH方式预分发到边缘Cache，可以实现有针对的内容提供。
 对于PUSH分发需要考虑的主要问题是分发策略，即在什么时候分发什么内容。一般来说，
 内容分发可以由CP（内容提供商）或者CDN内容管理员人工确定，也可以通过智能的方式决定，
-即所谓的智能分发，它根据用户访问的统计信息，以及预定义的内容分发的规则，确定内容分发的过程PULL是一种被
-动的分发技术，PULL分发通常由用户请求驱动。当用户请求的内容在本地的边缘 Cache上不存在（未命中）时，
-Cache启动PUL方法从内容源或者其他CDN节点实时获取内容。在PULL方式下，内容的分发是按需的。
+即所谓的智能分发，它根据用户访问的统计信息，以及预定义的内容分发的规则，确定内容分发的过程PULL是一种被动的分发技术，PULL分发通常由用户请求驱动。当用户请求的内容在本地的边缘 Cache上不存在（未命中）时，Cache启动PULL方法从内容源或者其他CDN节点实时获取内容。在PULL方式下，内容的分发是按需的。
 - 内容交换机:处于用户接入集中点，可以均衡单点多个内容缓存设备的负载，并对内容进行缓存负载平衡及访问控制。
 - 内容路由器:负责将用户的请求调度到适当的设备上。它是整体性的网络负载均衡技术，通过内容路由器中的重定向（DNS）机制，在多个远程POP上均衡用户的请求，
 以使用户请求得到最近内容源的响应。CDN负载均衡系统实现CDN的内容路由功能。它的作用是将用户的请求导向
@@ -106,39 +103,49 @@ CDN的负载均衡和分布式存储技术，可以加强网站的可靠性，
 
 ### 原理 
 
-CDN的工作原理就是将您源站的资源缓存到位于全国各地的CDN节点上，用户请求资源时，就近返回节点上缓存的
-资源，而不需要每个用户的请求都回您的源站获取，避免网络拥塞、分担源站压力，保证用户访问资源的速度和体验。
+CDN的工作原理就是将您源站的资源缓存到位于全国各地的CDN节点上，用户请求资源时，就近返回节点上缓存的资源，而不需要每个用户的请求都回您的源站获取，避免网络拥塞、分担源站压力，保证用户访问资源的速度和体验。
 
 下面分别是不用CDN以及使用CDN时的访问流程:    
 ![image](https://github.com/CharonChui/Pictures/blob/master/dns_no_cdn.png?raw=true)
 
 ![image](https://github.com/CharonChui/Pictures/blob/master/dns_cdn.png?raw=true)
 
-上面图中在使用CDN时，server-isp-DNS服务器不是直接把域名做A记录映射到源站，而是CNAME记录到调度中心，
-调度中心根据用户请求的来源，选择一个最近的CDN节点，主要的流程如下:     
+上面图中在使用CDN时，server-isp-DNS服务器不是直接把域名做A记录映射到源站，而是CNAME记录到调度中心，调度中心根据用户请求的来源，选择一个最近的CDN节点，主要的流程如下:     
 
-1. 当用户点击网站页面上的内容URL，经过本地DNS系统解析，DNS系统会最终将域名的解析权交给CNAME指向的CDN
-专用DNS服务器。
+1. 当用户点击网站页面上的内容URL，经过本地DNS系统解析，DNS系统会最终将域名的解析权交给CNAME指向的CDN专用DNS服务器。
 2. CDN的DNS服务器将CDN的全局负载均衡设备IP地址返回用户。
 3. 用户向CDN的全局负载均衡设备发起内容URL访问请求。
-4. CDN全局负载均衡设备根据用户IP地址，以及用户请求的内容URL，选择一台用户所属区域的区域负载均衡设备，
-告诉用户向这台设备发起请求。
+4. CDN全局负载均衡设备根据用户IP地址，以及用户请求的内容URL，选择一台用户所属区域的区域负载均衡设备，告诉用户向这台设备发起请求。
 5. 区域负载均衡设备会为用户选择一台合适的缓存服务器提供服务，选择的依据包括：根据用户IP地址，
-判断哪一台服务器距用户最近；根据用户所请求的URL中携带的内容名称，判断哪一台服务器上有用户所需内容；
-查询各个服务器当前的负载情况，判断哪一台服务器尚有服务能力。基于以上这些条件的综合分析之后，
+判断哪一台服务器距用户最近；根据用户所请求的URL中携带的内容名称，判断哪一台服务器上有用户所需内容；查询各个服务器当前的负载情况，判断哪一台服务器尚有服务能力。基于以上这些条件的综合分析之后，
 区域负载均衡设备会向全局负载均衡设备返回一台缓存服务器的IP地址。
 6. 全局负载均衡设备把服务器的IP地址返回给用户。
-7. 用户向缓存服务器发起请求，缓存服务器响应用户请求，将用户所需内容传送到用户终端。如果这台缓存服务器
-上并没有用户想要的内容，而区域均衡设备依然将它分配给了用户，那么这台服务器就要向它的上一级缓存服务器
-请求内容，直至追溯到网站的源服务器将内容拉到本地。
+7. 用户向缓存服务器发起请求，缓存服务器响应用户请求，将用户所需内容传送到用户终端。如果这台缓存服务器上并没有用户想要的内容，而区域均衡设备依然将它分配给了用户，那么这台服务器就要向它的上一级缓存服务器请求内容，直至追溯到网站的源服务器将内容拉到本地。
 
 ### 网站接入CDN
 
-- 将需要加速的域名，添加一个由CDN提供的CNAME。这样用户在访问加速域名时，实际上会访问到这个CNAME。
-- CNAME在解析时会使用CDN的权威域名服务器。在那里根据DNS，去判断用户的物理位置和运营商情况等，
-然后返回边缘节点服务器ip客户端。
-- 客户端再次请求返回的ip，边缘节点服务器由本地负载均衡服务器根据用户请求内容、节点服务器状态等动态因素
-去判断哪台服务器可以提供服务，通过302重定向到那台服务器。
+使用CDN的方法很简单，只需要修改自己的DNS解析，设置一个CNAME指向CDN服务商即可。
+
+用户访问未使用CDN缓存资源的过程为:
+
+- 浏览器通过前面提到的过程对域名进行解析，以得到此域名对应的IP地址；
+- 浏览器使用所得到的IP地址，向域名的服务主机发出数据访问请求；
+- 服务器向浏览器返回响应数据
+
+使用CDN后: 
+
+- 当用户点击网站页面上的内容URL，经过本地DNS系统解析，DNS系统会最终将域名的解析权交给CNAME指向的CDN专用DNS服务器。
+- CDN的DNS服务器将CDN的全局负载均衡设备IP地址返回用户。
+- 用户向CDN的全局负载均衡设备发起内容URL访问请求。
+- CDN全局负载均衡设备根据用户IP地址，以及用户请求的内容URL，选择一台用户所属区域的区域负载均衡设备，告诉用户向这台设备发起请求。
+
+- 区域负载均衡设备会为用户选择一台合适的缓存服务器提供服务，选择的依据包括：根据用户IP地址，判断哪一台服务器距用户最近；根据用户所请求的URL中携带的内容名称，判断哪一台服务器上有用户所需内容；查询各个服务器当前的负载情况，判断哪一台服务器尚有服务能力。基于以上这些条件的综合分析之后，区域负载均衡设备会向全局负载均衡设备返回一台缓存服务器的IP地址。
+
+- 全局负载均衡设备把服务器的IP地址返回给用户
+
+- 用户向缓存服务器发起请求，缓存服务器响应用户请求，将用户所需内容传送到用户终端。如果这台缓存服务器上并没有用户想要的内容，而区域均衡设备依然将它分配给了用户，那么这台服务器就要向它的上一级缓存服务器请求内容，直至追溯到网站的源服务器将内容拉到本地。
+
+上面的字太多，有点绕？通俗点就是用户访问的资源原本是存放在你自己的服务器，通过修改DNS让用户根据IP等情况来选择合适的CDN缓存服务器来获取资源。
 
 
 ## PCDN
@@ -148,22 +155,60 @@ PCDN:(P2P技术和CDN的融合创新)，下面是[阿里云PCDN](https://help.al
 海量碎片化闲置资源而构建的低成本高品质内容分发网络服务。客户通过集成PCDN SDK接入该服务后能获得等
 同（或略高于）CDN的分发质量，同时显著降低分发成本。适用于视频点播、直播、大文件下载等业务场景。
 
+
+
+我们知道，在移动终端上，通常上传流量会带来很多负面影响，比如消耗用户流量、更加耗电、频繁读写T卡/ROM影响硬件设备寿命等。阿里云PCDN利用海量的P2P节点资源，使终端能做到只下载而不用上传，大大扩展了P2P CDN的使用范围，这个优势已明显领先于那些完全依靠客户端上传流量而获得P2P效率的P2P产品。
+
+P2P节点布局中有路由器、运营商接入层/汇聚层节点等二级节点可以为客户APP提供P2P带宽，不强制要求客户APP上传流量，所以移动端不需要上传流量也可以使用PCDN。
+
+另外，PCDN针对各类业务场景做了进一步优化，使之对各场景的支持更加完善，给客户提供了更多差异化价值。在下载业务方面，支持下载速率控制（限速）。在带宽峰期对下载速度进行限制，可以有效控制带宽峰值。对于一些不追求下载速度的后台下载场景，同样可以对下载速度进行控制，使后台下载不至于影响前台的游戏、视频等网络体验。在安全方面，支持https，防止内容被篡改。并且集成了httpdns，保证了调度精准性，同时有效避免了域名劫持的发生。在防盗链的处理上，PCDN除了继承CDN的referer、鉴权策略、IP黑名单等防盗链机制，还从云+端的角度，使SDK跟本地业务结合，实现鉴权逻辑、DRM等，弥补了单纯靠云端鉴权的不足，使防盗链机制更加完善。
+
 ### CDN存在的问题
 
 传统的CDN技术虽然可以在一定程度上加速流媒体，实现下载、直播和点播。但是其核心仍然是基于
 集中服务器的结构，跟地域化管制紧密相连，很难降低其扩展的成本。另外，传统CDN技术在高峰时期
-对突发流量的适应性，容错性等方面仍然存在一定缺陷。随着用户规模的迅速增加，对CDN应用发展提出了较大挑战。
-因部署或租用机房带来的多方面高昂成本和管理压力，学界和业界也研究了将P2P技术融入CDN部署和管理的技术，
-以降低运营成本和通信时延。迅雷、优酷、百度、阿里巴巴等公司就在2010年代多次试水用户端运行的P2P众包类
-CDN服务、专用设备，模式为用户自愿以PC或专用设备利用闲置上行带宽充当CDN缓存节点，
+对突发流量的适应性，容错性等方面仍然存在一定缺陷。随着用户规模的迅速增加，对CDN应用发展提出了较大挑战。因部署或租用机房带来的多方面高昂成本和管理压力，学界和业界也研究了将P2P技术融入CDN部署和管理的技术，以降低运营成本和通信时延。迅雷、优酷、百度、阿里巴巴等公司就在2010年代多次试水用户端运行的P2P众包类CDN服务、专用设备，模式为用户自愿以PC或专用设备利用闲置上行带宽充当CDN缓存节点，
 提供服务并赚取积分，而积分可兑换现金红包、特定商品或服务。     
- 
+
 P2P技术则是打破了传统的Client/Server模式，是一种基于对等节点非中心化服务的平台方案。
 P2P技术发展迅猛，迅速改变了整个互联网传统秩序。“去中性化”符合WEB2.0技术潮流。特别在流媒体领域，
 由于采用Peer之间对等计算的模式，大大提高了资源共享的利用率，能在较低的成本下，充分利用空闲时间分
 发数据，避免拥塞，提供具备高实时性，和容错性能的流服务。为流媒体服务开辟了一条崭新的道路。   
 
-### P2P简介   
+
+
+
+
+### PCDN节点及架构
+
+
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/pcdn_jiedian.png)
+
+
+
+**PCDN的基础架构**
+
+关键组件
+
+- index服务：全局调度，把用户请求调度到最佳的机房
+
+- ZooKeeper (Global&Local)：服务活动情况汇报给调度服务，动态配置更新
+
+- Nignx Proxy：支持私有协议的Nginx代理服务，针对不同文件一致性Hash到不同的Channel服务
+
+- Channel服务：记录文件和拥有文件的端点地址信息，为下载提供就近的端点地址
+
+- Realy服务：服务P2P建立连接和通讯
+
+- Hot服务：hot文件发现和推送
+
+PCDN架构图：
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/pcdn_jiagou.png)
+
+### P2P简介
+
 P2P(Peer to Peer):点对点通信或称为对等联网。每个用户既下载数据，又作为服务器存储数据
 并供其他用户下载。他的本质，是一种硬盘的共享，是把每个人电脑上的一部分硬盘，拿出来与其他人共享。
 
@@ -172,15 +217,49 @@ P2P(Peer to Peer):点对点通信或称为对等联网。每个用户既下载
 产品采用的拓扑结构、算法模型不尽相同，缺乏标准体系，应用模式也不清晰。这些问题都阻碍了P2P技术
 进一步发展成为运营商级别的可靠技术平台。
 
+### P2P技术的发展演变过程
+
+早期的P2P技术，称为1.0版本，这个版本主要是依靠P2P尽力而为的提供服务，没有服务质量保障。像2000年前后出现的迅雷、BT、电驴等2C的应用。这类应用是互联网上内容传播分享的工具，并没有严谨的服务质量保证，而且从技术层面来说，这样的应用都是基于终端流量的上传，需要同时读写电脑本地的磁盘。
+
+经过几年的发展，到2005年左右，发展到P2P的2.0版本，这个版本的主要特征是P2P+CDN，有了一定的服务质量保障。像风行、PPlive、PPS、优酷等视频网站，把P2P和CDN相结合，做了自建的技术方案。但是从技术实现上来讲，还是基于终端的流量互传，主要是PC客户端和Flash这两种形态。
+
+到2014年以后，P2P技术发展到了3.0版本，这个版本的特征就是CDN+P2P技术+P2P节点资源，能提供全面的服务质量保障，性能不低于CDN。这个时期有优酷路由宝和迅雷赚钱宝等智能硬件产品面世，吸纳用户家庭和商业场所中闲散的带宽资源，打包成P2P的分发服务。P2P节点自此发展成了共享经济的模型。技术上，使用了智能硬件产品，客户端APP不再需要终端上传和读写磁盘。在业务场景上也支持的比较全面，长视频/短视频点播、大型赛事直播、秀场直播、大文件下载等都能完美支持。质量好，价格低，并且业务场景支持全面，这些因素促成了P2P CDN产品的不断发展，这个阶段积累了较大规模的商业化案例。
+
+
+
+### PCDN保证高质量的基本原理
+
+CDN对外服务是单节点、单链路的方式，这要求CDN节点有很高的稳定性。一旦CDN节点出现故障或者链路出现抖动、拥塞等，将势必影响服务质量。而PCDN对外服务是多点对单点、多链路的方式，这种特性使PCDN能够有效避免节点故障、链路网络问题带来的影响，使整个传输更加稳定。
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/pcdn_vs_cdn.png)
+
+PCDN对外服务时，CDN将被当做超级种子，同时也有很多P2P节点提供服务。虽然单个P2P节点的能力弱于CDN，但依赖数量众多的P2P节点和优良的调度算法，可以很好的保证整网的可靠性。CDN在节点水位问题、稳定性、网络波动等问题将要发生之前，P2P调度会尽可能从P2P节点把用户所要的内容返回给SDK，来抑制缓冲和卡顿的情况。所以PCDN相对于CDN，服务质量有所优化。
+
+有数据显示，以视频点播业务为例，PCDN的首播时间等同于CDN，流畅性同比CDN平均提升1~3%。在下载业务方面，PCDN的下载速度、下载完成率等指标全面领先CDN。
+
+### 四、PCDN保证低价格的基本原理
+
+PCDN的带宽分为一、二、三级节点带宽，一级节点带宽为CDN带宽；二级节点带宽为分布全国各地P2P节点提供的带宽，包含接入层节点、路由器等提供的运营商/家庭出口带宽；三级带宽为客户端之间互相分享的带宽。如下图所示，各级节点能力不同，从一级CDN节点到三级客户端节点，根据其自身能力，按网络质量、存储容量、稳定性、计算能力、节点数量、可控性六个基本维度进行划分。其中，CDN各方面能力是最强的，但是节点数量是最少的，成本是最高的。逐一往右推移，网络质量和存储能力、计算能力在不同程度的下降，但是节点数量在提升，成本在降低。
+
+
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/pcdn_peer.png)
+
+所以，PCDN在对外提供服务时，调度系统根据质量优先、兼顾成本的原则，对各级节点进行合理配比。以视频点播的业务为例，当播放器开始播放的时候，无论从用户还是从业务角度，都希望尽快拿到数据，不愿意缓冲和等待，这个时候PCDN默认CDN的响应是比较及时，调度系统首先从CDN上拿数据，即首帧时间与CDN等效。在正常播放过程中，播放器预缓冲时，播放器对数据的请求不是很着急，这时优先使用低成本的P2P，如果P2P没有命中或者调度系统评估要很慢才能回传，再回源CDN。通过这样的方法，能有效减少高成本的CDN用量。
+
+通过这种方式，根据业务场景和使用量，PCDN的价格一般比CDN降低30%~50%。目前支持按日峰值带宽、月95峰值带宽和日流量三种计费方式。从客户的时间使用情况看，对于一个峰值带宽30G左右的业务，使用PCDN一年相比CDN可以节省至少100万。对于带宽峰值超过100G的业务，成本节省效果将更加可观。
+
+PCDN目前已支持视频点播、视频直播、大文件下载各类典型的业务场景，包括但不限于长视频点播、短视频点播、互动娱乐直播、晚会赛事直播、应用市场分发等各类产品，全面支持Android、iOS、OTT、Flash、PC-Client等各种主流平台和主流协议。通过在娱乐、教育、体育、广电等多个行业积累的众多成熟服务客户案例，PCDN对各业务场景的理解与服务也不断升级优化，目前已能支持更多的下载场景、提供更好的防劫持防盗链方案和更好的视频播放体验，让质量和价格不再是矛盾体，达到高质量低成本这一超高性价比的效果，鱼和熊掌兼得。PCDN，期待为您提供更好的服务。
+
 ### CDN和P2P技术优劣势分析
 
 |        | CDN  | P2P |
-| ------ | ----  | ----  |    
+| ------ | ----  | ----  |
 | 可扩展性  |  扩展成本较高   |   低成本扩展   |
-| 内容版权  |   可监管   |   不可监管  | 
+| 内容版权  |   可监管   |   不可监管  |
 | 用户管理有效性 | 可实现用户的有效管理 | 无法进行有效的用户管理 |
 | QoS服务 | 可保障服务 | 无法保障 |
-| 流量有序性 | 流量区域控制 | 无序无序 | 
+| 流量有序性 | 流量区域控制 | 无序无序 |
 
 也就是说，P2P和CDN技术在几个关键点上，完全实现互补，如果能将两种技术有效的结合起来，
 必然是一种更加完美的组合。于是，一种全新的思路是在CDN网络中，引入P2P技术。通过这种模式，
@@ -202,8 +281,10 @@ P2P用户将根据这些规则来完成P2P共享。P2P在边缘层的引入大
 一方面，P2P+CDN结合的方式，使得有限的服务能力可以为更多的用户提供流媒体服务。超级种子的存在保证了
 服务质量。另一方面，P2P技术的应用也能够更有效地防止因网络的抖动而产生对服务质量的影响。
 
+​    
+
+[Content Delivery Acceleration and Cost Reduction with P2P CDN (PCDN)](https://dzone.com/articles/content-delivery-acceleration-and-cost-reduction-w)
 
-    
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
diff --git "a/VideoDevelopment/DLNA\347\256\200\344\273\213.md" "b/VideoDevelopment/DLNA\347\256\200\344\273\213.md"
index 7abc3486..cbf52924 100644
--- "a/VideoDevelopment/DLNA\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/DLNA\347\256\200\344\273\213.md"
@@ -17,7 +17,7 @@ DLNA
 `DLNA`的骨干成员包括以Intel为首的芯片制造商；以HP为首的PC制造商，以Sony，Panasonic，Sharp，Samsung，LG 为首的家电、消费电子制造商；以CISCO，HUWEI，MOTOROLA，ERICSSON为首的电信设备/移动终端/标准商；一家独大的Microsoft软件/操作系统商等等。
 
 值得注意的有几点：  
-  
+
 1. DLNA这个东西基本Intel，Microsoft两个领域巨头在推，一个搞芯片，一个搞系统。AMD没出现在2011的promoter名单中；Google来年会不会掺一脚不好说。还有QUALCOMM也参加进来了，这几年的智能手机芯片处理器他家的也比较多，而且他家还有很多专利可以吃。
 
 2. 2011就剩HP一个大PC商了，其他大PC商如Acer,Asus都还不是promoter，他们肯定要抢着加入的。lenovo不仅从promotor名单中消失了，自然也不会是contributor了，和AMD一样。最开始时lenovo是很积极的，在DHWG的时候也是骨干成员，回来中国搞了一个“IGRS闪联”，退出的原因不知道和这个有没有关系。IGRS在很大程度上和DLNA是比较类似的，框架协议和UPnP也是比较像的。
@@ -122,11 +122,12 @@ DLNA架构分为如下图7个层次：
    - 从DMS/M-DMS至DMP/M-DMP，即使不立即播放。
    - 从一个DMS到另一个DMS，这时接收方DMS播放接收媒体内容，表现为一个DMP；也可以不立即播放，可能只是存储或者处理。    
           
+   
    传输 模式有三种：
    - 流传输。当DMR/DMP需要实时渲染接收媒体，媒体具时序性。
    - 交互传输。不包含时序的媒体，如图片传输。
-   - 后台传输。非实时的媒体传输，比如上传下载等。
-
+- 后台传输。非实时的媒体传输，比如上传下载等。
+	
 6. Media Formats媒体格式。格式Formats在这里等同于编码格式Codec，平时我们说的编码格式比如Mpeg-2，AVC，x264就是视频编码格式；PCM，mp3(MPEG-2 Layer 3)，aac，flac就是音频编码格式。而avi，rmvb，mkv这些是媒体封装格式，包含视频音频可能还有字幕流。比如一个常见的后缀为mkv的文件，它的视频Codec是x264，音频是aac，它的视音频编码属于Mpeg-4 Codec Family。
 
 7. Remote UI 远程用户接口。
@@ -170,7 +171,7 @@ http://upnp.org/
 	填"M-SEARCH * HTTP/1.1/r/n"就是要搜索了；respone别人的搜索就填"HTTP/1.1 200 OK/r/n"。
 
     SSDP第二个要填充的字段是目的地址HOST。比如填上"HOST: 239.255.255.250:1900"，就是组播(multicast)搜索，这里239.255.255.250是组播地址，就是说这条消息会给网络里面该组地址的设备发，1900是SSDP协议的端口号。如果HOST地址是特定地址，那这就是单播(unicast)。Respone不填这个字段，他会在ST字段里面填respone address，就是发来搜索信息的设备的地址，Respone消息的话还会发送一个包含自己地址URL的字段，Respone的意思就是跟Searcher说：我好像是你要找的人，我的电话是XXX，详细情况请CALL我。Respone也是UDP单播。
- 
+
 3. 描述(Description)
 
 	前面我们说了CP想要一个device更详细的信息，就打给它的URL跟它要。返回来的东西一般是个XML（Extensible Markup Language，是种结构化的数据。和HTML比较像，有tag和data，具体不说了自己去查），描述分为两部分：一个是device description，是device的物理描述，就是说这个device是什么；还有一个是service descriptions，就是device的服务描述了，就是device能干些什么。这些device和device service的描述的格式也是有要求的，开发商也可以自定义，只要符合UPnP Forum的规范。
diff --git a/VideoDevelopment/P2P.md "b/VideoDevelopment/P2P\346\212\200\346\234\257/P2P.md"
similarity index 100%
rename from VideoDevelopment/P2P.md
rename to "VideoDevelopment/P2P\346\212\200\346\234\257/P2P.md"
diff --git "a/VideoDevelopment/P2P\346\212\200\346\234\257/P2P\345\216\237\347\220\206_NAT\347\251\277\351\200\217.md" "b/VideoDevelopment/P2P\346\212\200\346\234\257/P2P\345\216\237\347\220\206_NAT\347\251\277\351\200\217.md"
new file mode 100644
index 00000000..43bcfc89
--- /dev/null
+++ "b/VideoDevelopment/P2P\346\212\200\346\234\257/P2P\345\216\237\347\220\206_NAT\347\251\277\351\200\217.md"
@@ -0,0 +1,71 @@
+P2P原理_NAT穿透
+===
+
+
+
+### NAT
+
+NAT（Network Address Translation，网络地址转换），也叫做网络掩蔽或者IP掩蔽。NAT是一种网络地址翻译技术，主要是将内部的私有IP地址（private IP）转换成可以在公网使用的公网IP（public IP）。
+
+
+
+网络地址转换，就是替换IP报文头部的地址信息。NAT通常部署在一个组织的网络出口位置，通过将内部网络IP地址替换为出口的IP地址提供公网可达性和上层协议的连接能力。那么，什么是内部网络IP地址？
+
+ [RFC1918](https://datatracker.ietf.org/doc/rfc1918/)规定了三个保留地址段落：10.0.0.0-10.255.255.255；172.16.0.0-172.31.255.255；192.168.0.0-192.168.255.255。这三个范围分别处于A,B,C类的地址段，不向特定的用户分配，被IANA作为私有地址保留。这些地址可以在任何组织或企业内部使用，和其他Internet地址的区别就是，仅能在内部使用，不能作为全球路由地址。这就是说，出了组织的管理范围这些地址就不再有意义，无论是作为源地址，还是目的地址。对于一个封闭的组织，如果其网络不连接到Internet，就可以使用这些地址而不用向IANA提出申请，而在内部的路由管理和报文传递方式与其他网络没有差异。
+
+ 对于有Internet访问需求而内部又使用私有地址的网络，就要在组织的出口位置部署NAT网关，在报文离开私网进入Internet时，将源IP替换为公网地址，通常是出口设备的接口地址。一个对外的访问请求在到达目标以后，表现为由本组织出口设备发起，因此被请求的服务端可将响应由Internet发回出口网关。出口网关再将目的地址替换为私网的源主机地址，发回内部。这样一次由私网主机向公网服务端的请求和响应就在通信两端均无感知的情况下完成了。依据这种模型，数量庞大的内网主机就不再需要公有IP地址了。
+
+ 那么，NAT与此同时也带来一些弊端：首先是，NAT设备会对数据包进行编辑修改，这样就降低了发送数据的效率；此外，各种协议的应用各有不同，有的协议是无法通过NAT的（不能通过NAT的协议还是蛮多的），这就需要通过穿透技术来解决。我们后面会重点讨论穿透技术。
+
+
+
+**虽然实际过程远比这个复杂，但上面的描述概括了NAT处理报文的几个关键特点：**
+
+
+
+- 1）网络被分为私网和公网两个部分，NAT网关设置在私网到公网的路由出口位置，双向流量必须都要经过NAT网关；
+- 2）网络访问只能先由私网侧发起，公网无法主动访问私网主机；
+- 3）NAT网关在两个访问方向上完成两次地址的转换或翻译，出方向做源信息替换，入方向做目的信息替换；
+- 4）NAT网关的存在对通信双方是保持透明的；
+- 5）NAT网关为了实现双向翻译的功能，需要维护一张关联表，把会话的信息保存下来。
+
+
+
+ 简单的背景了解过后，下面介绍下NAT实现的主要方式，以及NAT都有哪些类型。
+
+
+
+### NAT的实现方式
+
+
+
+- 静态NAT: 就是静态地址转换。是指一个公网IP对应一个私有IP，是一对一的转换，同时注意，这里只进行了IP转换，而没有进行端口的转换。
+
+- NAPT： 端口多路复用技术。与静态NAT的差别是，NAPT不但要转换IP地址，还要进行传输层的端口转换。具体的表现形式就是，对外只有一个公网IP，通过端口来区别不同私有IP主机的数据。
+
+    
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/VideoDevelopment/\345\205\263\351\224\256\345\270\247.md" "b/VideoDevelopment/\345\205\263\351\224\256\345\270\247.md"
index ac0d3d9b..da3274dc 100644
--- "a/VideoDevelopment/\345\205\263\351\224\256\345\270\247.md"
+++ "b/VideoDevelopment/\345\205\263\351\224\256\345\270\247.md"
@@ -1,23 +1,30 @@
 关键帧
 ===
 
-MP4是一种格式的规范，这个规范是被ISO机构认证的，你如果要生成一个mp4文件，就必须按照这个规矩来。
+**编码器将多张图像进行编码后生产成一段一段的 GOP ( Group of Pictures ) ， 解码器在播放时则是读取一段一段的 GOP 进行解码后读取画面再渲染显示。**GOP ( Group of Pictures) 是一组连续的画面，由一张 I 帧和数张 B / P  帧组成，是视频图像编码器和解码器存取的基本单位，它的排列顺序将会一直重复到影像结束。I  帧是内部编码帧（也称为关键帧），P帧是前向预测帧（前向参考帧），B 帧是双向内插帧（双向参考帧）。简单地讲，I 帧是一个完整的画面，而 P 帧和 B 帧记录的是相对于 I 帧的变化。如果没有 I 帧，P 帧和 B 帧就无法解码。
 
-
-视频压缩中，每一帧代表一副静止的图像，在实际的压缩时，会采取各种算法来减少数据的容量。视频压缩采用的方法是分组，把几帧图像分为一组(GOP(Group of picture)).其中IPB是最常见的。 
+在H.264压缩标准中I帧、P帧、B帧用于表示传输的视频画面。
 
 - I帧(Intra coded picture):帧内编码图像帧简称关键帧，这一帧画面的完整保留，解码时只需要本帧数据就可以完成.I帧通常是每个GOP(MPEG所使用的一种视频压缩技术)的第一个，GOP就是指两个I帧之间的距离。
 
-这里有一个IDR帧的概念需要讲一下，所有的IDR帧都是I帧，但是并不是所有I帧都是IDR帧，IDR帧是I帧的子集。I帧严格定义是帧内编码帧，由于是一个全帧压缩编码帧，通常用I帧表示「关键帧」。IDR是基于I帧的一个扩展，带了控制逻辑，IDR图像都是I帧图像，当解码器解码到IDR图像时，会立即将参考帧队列清空，将已解码的数据全部输出或抛弃。重新查找参数集，开始一个新的序列。这样如果前一个序列出现重大错误，在这里可以获得重新同步的机会。IDR图像之后的图像永远不会使用IDR之前的图像的数据来解码。在H.264编码中，GOP是封闭式的，一个GOP的第一帧都是IDR帧。    
-
-我们在做直播的时候，想要能达到秒开的效果，因为I帧是能不依赖其他帧独立完成解码的，这就意味着当播放器接收到I帧就能立马渲染出来，而接收到P、B帧则需要等待依赖的帧而不能立马完成解码和渲染，这个期间就会黑屏，所以可以在服务端通过缓存GOP，保证播放端在接入直播时能先获取到I帧马上渲染出画面，从而提高起播速度。在直播服务器中，支持设置一个cache，用于存放GOP，直播服务器缓存了当前的GOP序列，当播放端请求数据的时候，CDN会从I帧返回给客户端，从而保证客户端可以快速进行播放。当然由于缓存的是之前的视频信息，当音频数据到达播放端后，为了音视频同步播放器会进行视频的快进处理。
+    我们在做直播的时候，想要能达到秒开的效果，因为I帧是能不依赖其他帧独立完成解码的，这就意味着当播放器接收到I帧就能立马渲染出来，而接收到P、B帧则需要等待依赖的帧而不能立马完成解码和渲染，这个期间就会黑屏，所以可以在服务端通过缓存GOP，保证播放端在接入直播时能先获取到I帧马上渲染出画面，从而提高起播速度。在直播服务器中，支持设置一个cache，用于存放GOP，直播服务器缓存了当前的GOP序列，当播放端请求数据的时候，CDN会从I帧返回给客户端，从而保证客户端可以快速进行播放。当然由于缓存的是之前的视频信息，当音频数据到达播放端后，为了音视频同步播放器会进行视频的快进处理。
 
 - P帧(Predictive coded picture):预测编码图像帧简称差别帧，这一帧跟之前的一个关键帧或P帧的差别，解码时需要用之前缓存的画面叠加上本帧定义的差别，生成最终的画面。也就是说P帧没有完整的画面数据，只有与前一帧的画面差别的数据。 
 - B帧(Bidirectionally predicted picture):双向预测编码图像帧简称双向差别帧，也就是B帧记录的是本帧与前后帧的差别。也就是要解码B帧，不仅要取得之前的缓存画面，还要解码之后的画面，通过前后画面与本帧数据的叠加来获取最终的画面。B帧压缩率高，但是解码时会更耗CPU。
 - GOP(Group of Pictures)是一组连续的画面，由一张I帧和数张B/P帧组成，是视频图像编码器和解码器存取的基本单位，它的排列顺序将会一直重复到影像结束。
-编码器将多张图像进行编码后生产成一段一段的 GOP ，解码器在播放时则是读取一段一段的GOP进行解码后读取画面再渲染显示。
+  编码器将多张图像进行编码后生产成一段一段的 GOP ，解码器在播放时则是读取一段一段的GOP进行解码后读取画面再渲染显示。
 
+- IDR（Instantaneous Decoding Refresh）--即时解码刷新。
+     I帧:帧内编码帧是一种自带全部信息的独立帧，无需参考其它图像便可独立进行解码，视频序列中的第一个帧始终都是I帧。
+     I和IDR帧都是使用帧内预测的。它们都是同一个东西而已,在编码和解码中为了方便，要首个I帧和其他I帧区别开，所以才把第一个首个I帧叫IDR，这样就方便控制编码和解码流程。 IDR帧的作用是立刻刷新,使错误不致传播,从IDR帧开始,重新算一个新的序列开始编码。而I帧不具有随机访问的能力，这个功能是由IDR承担。  IDR会导致DPB（DecodedPictureBuffer  参考帧列表——这是关键所在）清空，而I不会。IDR图像一定是I图像，但I图像不一定是IDR图像。一个序列中可以有很多的I图像，I图像之后的图像可以引用I图像之间的图像做运动参考。一个序列中可以有很多的I图像，I图像之后的图象可以引用I图像之间的图像做运动参考。
+     对于IDR帧来说，在IDR帧之后的所有帧都不能引用任何IDR帧之前的帧的内容，与此相反，对于普通的I-帧来说，位于其之后的B-和P-帧可以引用位于普通I-帧之前的I-帧。从随机存取的视频流中，播放器永远可以从一个IDR帧播放，因为在它之后没有任何帧引用之前的帧。但是，不能在一个没有IDR帧的视频中从任意点开始播放，因为后面的帧总是会引用前面的帧 。
+     收到 IDR 帧时，解码器另外需要做的工作就是：把所有的 PPS 和 SPS 参数进行更新。
+     对IDR帧的处理(与I帧的处理相同)：(1) 进行帧内预测，决定所采用的帧内预测模式。(2) 像素值减去预测值，得到残差。(3) 对残差进行变换和量化。(4) 变长编码和算术编码。(5) 重构图像并滤波，得到的图像作为其它帧的参考帧。
+     多参考帧情况下， 举个例子 ：有如下帧序列： IPPPP I P PPP ……。按照 3 个参考帧编码。
+     因为“按照 3 个参考帧编码”，所以参考帧队列长度为 3 。
+     遇到第二个 I 时，并不清空参考帧队列，把这个 I 帧加入参考帧队列（当然 I 编码时不用参考帧。）。再检测到其后面的 P 帧时，用到之前的 PPI 三帧做参考了。
 
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/video_frame_ipb.jpg)
 
 ### 数据压缩比
 
@@ -31,6 +38,23 @@ P帧和B帧极大的节省了数据量，节省出来的空间可以用来多保
 
 
 
+【为什么会有PTS和DTS的概念】
+
+通过上面的描述可以看出：P帧需要参考前面的I帧或P帧才可以生成一张完整的图片，而B帧则需要参考前面I帧或P帧及其后面的一个P帧才可以生成一张完整的图片。这样就带来了一个问题：在视频流中，先到来的 B 帧无法立即解码，需要等待它依赖的后面的 I、P 帧先解码完成，这样一来播放时间与解码时间不一致了，顺序打乱了，那这些帧该如何播放呢？这时就引入了另外两个概念：DTS 和 PTS。
+
+【PTS和DTS】
+
+先来了解一下PTS和DTS的基本概念：
+
+DTS（Decoding Time Stamp）：即**解码时间戳**，这个时间戳的意义在于告诉播放器该在什么时候解码这一帧的数据。
+PTS（Presentation Time Stamp）：即**显示时间戳**，这个时间戳用来告诉播放器该在什么时候显示这一帧的数据。
+
+虽然 DTS、PTS 是用于指导播放端的行为，但它们是在编码的时候由编码器生成的。
+
+在视频采集的时候是录制一帧就编码一帧发送一帧的，在编码的时候会生成 PTS，这里需要特别注意的是  frame（帧）的编码方式，在通常的场景中，编解码器编码一个 I 帧，然后向后跳过几个帧，用编码 I 帧作为基准帧对一个未来 P  帧进行编码，然后跳回到 I 帧之后的下一个帧。编码的 I 帧和 P 帧之间的帧被编码为 B 帧。之后，编码器会再次跳过几个帧，使用第一个 P  帧作为基准帧编码另外一个 P 帧，然后再次跳回，用 B 帧填充显示序列中的空隙。这个过程不断继续，每 12 到 15 个 P 帧和 B  帧内插入一个新的 I 帧。P 帧由前一个 I 帧或 P 帧图像来预测，而 B 帧由前后的两个 P 帧或一个 I 帧和一个 P  帧来预测，因而编解码和帧的显示顺序有所不同
+
+
+
 
 
 
diff --git "a/VideoDevelopment/\346\222\255\346\224\276\345\231\250\346\200\247\350\203\275\344\274\230\345\214\226.md" "b/VideoDevelopment/\346\222\255\346\224\276\345\231\250\346\200\247\350\203\275\344\274\230\345\214\226.md"
index ab28c0f6..ba32b52d 100644
--- "a/VideoDevelopment/\346\222\255\346\224\276\345\231\250\346\200\247\350\203\275\344\274\230\345\214\226.md"
+++ "b/VideoDevelopment/\346\222\255\346\224\276\345\231\250\346\200\247\350\203\275\344\274\230\345\214\226.md"
@@ -64,7 +64,7 @@ DNS解析加快，通常，DNS解析，意味着要把一个域名为xxx.com解
 
 #### 预加载
 
-预加载能减少首次缓冲号码，但是预加载不能和当前播放的视频抢下载带宽，需要达到一个合适的阈值再开始下载。
+预加载能减少首次缓冲时间，但是预加载不能和当前播放的视频抢下载带宽，需要达到一个合适的阈值再开始下载。
 
 优先保证封面图等信息完成后再根据云控的当前缓冲的时长等信息来控制是否要启动预加载
 
@@ -72,7 +72,6 @@ DNS解析加快，通常，DNS解析，意味着要把一个域名为xxx.com解
 
 有关CDN相关可参考[CDN及PCDN](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/CDN%E5%8F%8APCDN.md)
 
-    
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
diff --git "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/\346\265\201\345\252\222\344\275\223\351\200\232\344\277\241\345\215\217\350\256\256.md" "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/\346\265\201\345\252\222\344\275\223\351\200\232\344\277\241\345\215\217\350\256\256.md"
index 644494bf..5eb94854 100644
--- "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/\346\265\201\345\252\222\344\275\223\351\200\232\344\277\241\345\215\217\350\256\256.md"
+++ "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/\346\265\201\345\252\222\344\275\223\351\200\232\344\277\241\345\215\217\350\256\256.md"
@@ -1,11 +1,21 @@
 流媒体通信协议
 ===
 
-
 流媒体(Streaming Media)是指采用流式传输技术在网络上连续实时播放的媒体格式，如音频、视频或多媒体文件，采用流媒体技术使得数据包得以像流水一样发送, 如果没有流媒体技术, 那么我们就要像以前用迅雷下电影一样, 下载整个影片才能观看。   
 
 
 
+HTTP
+---
+
+
+
+HTTP 视频协议是在互联网普及之后在互联网上看视频的需求下形成的。最初的 HTTP 视频协议，没有任何特别之处，就是通用的 HTTP  文件渐进式下载，但是在这种情况下，视频无法快进或者跳转到文件尚未被下载到的部分，这就对 HTTP 协议提出了范围请求（Range  Request）的要求，目前几乎所有 HTTP 服务器都支持范围请求。所谓范围请求指的是请求文件的部分数据，这可以在 HTTP 请求头中通过  Range 字段设置偏移量来实现。
+
+这种方式应用于视频点播还可以，用于直播的话实时性较差，延迟也很高，于是，苹果公司又在 HTTP 协议的基础上推出了 HTTP Live Streaming（简称 HLS）这个流媒体传输协议。
+
+
+
 RTP
 ---
 
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/AV1.md" "b/VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/AV1.md"
new file mode 100644
index 00000000..45aa49ec
--- /dev/null
+++ "b/VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/AV1.md"
@@ -0,0 +1,101 @@
+H264
+===
+
+
+
+
+
+H.264是一种高性能的视频编解码技术。目前国际上制定视频编解码技术的组织有两个，一个是“国际电联”，它制定的标准有H.261、H.263、H.263+等，另一个是“国际标准化组织（ISO）”它制定的标准有MPEG-1、MPEG-2、MPEG-4等。而H.264则是由两个组织联合组建的联合视频组（JVT）共同制定的新数字视频编码标准，所以它既是ITU-T的H.264，又是ISO/IEC的MPEG-4高级视频编码，而且它将成为MPEG-4标准的第10部分。因此，不论是MPEG-4 AVC、MPEG-4 Part 10，还是ISO/IEC 14496-10，都是指H.264。
+
+
+
+
+
+## H.264算法的优势
+
+
+ H.264是在MPEG-4技术的基础之上建立起来的，其编解码流程主要包括5个部分：帧间和帧内预测、变换和反变换、量化和反量化、环路滤波、熵编码。
+
+ H.264/MPEG-4  AVC（H.264）是1995年自MPEG-2视频压缩标准发布以后的最新、最有前途的视频压缩标准。H.264是由ITU-T和ISO/IEC的联合开发组共同开发的最新国际视频编码标准。通过该标准，在同等图象质量下的压缩效率比以前的标准提高了2倍以上，因此，H.264被普遍认为是最有影响力的行业标准。
+
+## H.264的优势
+
+
+ H.264在1997年ITU的视频编码专家组提出时被称为H.26L，在ITU与ISO合作研究后被称为MPEG4 Part10或H.264（JVT）。H.264标准的主要目标是：与其它现有的视频编码标准相比，在相同的带宽下提供更加优秀的图象质量。
+
+**而，H.264与以前的国际标准如H.263和MPEG-4相比，最大的优势体现在以下四个方面：**
+
+
+
+- 将每个视频帧分离成由像素组成的块，因此视频帧的编码处理的过程可以达到块的级别。
+- 采用空间冗余的方法，对视频帧的一些原始块进行空间预测、转换、优化和熵编码（可变长编码）。
+- 对连续帧的不同块采用临时存放的方法，这样，只需对连续帧中有改变的部分进行编码。该算法采用运动预测和运动补偿来完成。对某些特定的块，在一个或多个已经进行了编码的帧执行搜索来决定块的运动向量，并由此在后面的编码和解码中预测主块。
+- 采用剩余空间冗余技术，对视频帧里的残留块进行编码。例如：对于源块和相应预测块的不同，再次采用转换、优化和熵编码。
+
+
+**具体优势表现为：**
+
+
+
+- 低码流：和MPEG2和MPEG4 ASP等压缩技术相比，在同等图像质量下，采用H.264技术压缩后的数据量只有MPEG2的1/8，MPEG4的1/3。显然，H.264压缩技术的采用将大大节省用户的下载时间和数据流量收费。
+- 高质量的图象：H.264能提供连续、流畅的高质量图象（DVD质量）。
+- 容错能力强：H.264提供了解决在不稳定网络环境下容易发生的丢包等错误的必要工具。
+- 网络适应性强：H.264提供了网络适应层， 使得H.264的文件能容易地在不同网络上传输（例如互联网，CDMA，GPRS，WCDMA，CDMA2000等）。
+
+
+ H.264和以前的标准一样，也是DPCM加变换编码的混合编码模式。但它采用“回归基本”的简洁设计，不用众多的选项，获得比H.263++好得多的压缩性能；加强了对各种信道的适应能力，采用“网络友好”的结构和语法，有利于对误码和丢包的处理；应用目标范围较宽，以满足不同速率、不同解析度以及不同传输（存储）场合的需求。
+
+## H.264标准的关键技术
+
+
+
+### 1 帧内预测编码
+
+
+ 帧内编码用来缩减图像的空间冗余。为了提高H.264帧内编码的效率，在给定帧中充分利用相邻宏块的空间相关性，相邻的宏块通常含有相似的属性。因此，在对一给定宏块编码时，首先可以根据周围的宏块预测（典型的是根据左上角的宏块，因为此宏块已经被编码处理），然后对预测值与实际值的差值进行编码，这样，相对于直接对该帧编码而言，可以大大减小码率。
+
+
+
+### 2帧间预测编码
+
+
+ 帧间预测编码利用连续帧中的时间冗余来进行运动估计和补偿。H.264的运动补偿支持以往的视频编码标准中的大部分关键特性，而且灵活地添加了更多的功能，除了支持P帧、B帧外，H.264还支持一种新的流间传送帧——SP帧，如图3所示。码流中包含SP帧后，能在有类似内容但有不同码率的码流之间快速切换，同时支持随机接入和快速回放模式。
+
+
+
+### 3整数变换
+
+
+ 在变换方面，H.264使用了基于4×4像素块的类似于DCT的变换，但使用的是以整数为基础的空间变换，不存在反变换，因为取舍而存在误差的问题，变换矩阵如图5所示。与浮点运算相比，整数DCT变换会引起一些额外的误差，但因为DCT变换后的量化也存在量化误差，与之相比，整数DCT变换引起的量化误差影响并不大。此外，整数DCT变换还具有减少运算量和复杂度，有利于向定点DSP移植的优点。
+
+
+
+### 4量化
+
+
+ H.264中可选32种不同的量化步长，这与H.263中有31个量化步长很相似，但是在H.264中，步长是以12.5%的复合率递进的，而不是一个固定常数。
+
+ 在H.264中，变换系数的读出方式也有两种：之字形（Zigzag）扫描和双扫描，如图6所示。大多数情况下使用简单的之字形扫描；双扫描仅用于使用较小量化级的块内，有助于提高编码效率。
+
+
+
+### 5熵编码
+
+
+ 视频编码处理的最后一步就是熵编码，在H.264中采用了两种不同的熵编码方法：通用可变长编码（UVLC）和基于文本的自适应二进制算术编码（CABAC）。
+
+ 在H.263等标准中，根据要编码的数据类型如变换系数、运动矢量等，采用不同的VLC码表。H.264中的UVLC码表提供了一个简单的方法，不管符号表述什么类型的数据，都使用统一变字长编码表。其优点是简单；缺点是单一的码表是从概率统计分布模型得出的，没有考虑编码符号间的相关性，在中高码率时效果不是很好。
+
+ 因此，H.264中还提供了可选的CABAC方法。算术编码使编码和解码两边都能使用所有句法元素（变换系数、运动矢量）的概率模型。为了提高算术编码的效率，通过内容建模的过程，使基本概率模型能适应随视频帧而改变的统计特性。内容建模提供了编码符号的条件概率估计，利用合适的内容模型，存在于符号间的相关性可以通过选择目前要编码符号邻近的已编码符号的相应概率模型来去除，不同的句法元素通常保持不同的模型。
+
+## H.264在实时视频聊天中的应用
+
+
+ 目前，H.264已被广泛应用于实时视频应用中，相比以往的方案使得在同等速率下，H.264能够比H.263减小50%的码率。也就是说，用户即使是只利用 384kbit/s的带宽，就可以享受H.263下高达 768kbit/s的高质量视频服务。H.264  不但有助于节省庞大开支，还可以提高资源的使用效率，同时令达到商业质量的实时视频服务拥有更多的潜在客户。
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/H264.md" "b/VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/H264.md"
new file mode 100644
index 00000000..45aa49ec
--- /dev/null
+++ "b/VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/H264.md"
@@ -0,0 +1,101 @@
+H264
+===
+
+
+
+
+
+H.264是一种高性能的视频编解码技术。目前国际上制定视频编解码技术的组织有两个，一个是“国际电联”，它制定的标准有H.261、H.263、H.263+等，另一个是“国际标准化组织（ISO）”它制定的标准有MPEG-1、MPEG-2、MPEG-4等。而H.264则是由两个组织联合组建的联合视频组（JVT）共同制定的新数字视频编码标准，所以它既是ITU-T的H.264，又是ISO/IEC的MPEG-4高级视频编码，而且它将成为MPEG-4标准的第10部分。因此，不论是MPEG-4 AVC、MPEG-4 Part 10，还是ISO/IEC 14496-10，都是指H.264。
+
+
+
+
+
+## H.264算法的优势
+
+
+ H.264是在MPEG-4技术的基础之上建立起来的，其编解码流程主要包括5个部分：帧间和帧内预测、变换和反变换、量化和反量化、环路滤波、熵编码。
+
+ H.264/MPEG-4  AVC（H.264）是1995年自MPEG-2视频压缩标准发布以后的最新、最有前途的视频压缩标准。H.264是由ITU-T和ISO/IEC的联合开发组共同开发的最新国际视频编码标准。通过该标准，在同等图象质量下的压缩效率比以前的标准提高了2倍以上，因此，H.264被普遍认为是最有影响力的行业标准。
+
+## H.264的优势
+
+
+ H.264在1997年ITU的视频编码专家组提出时被称为H.26L，在ITU与ISO合作研究后被称为MPEG4 Part10或H.264（JVT）。H.264标准的主要目标是：与其它现有的视频编码标准相比，在相同的带宽下提供更加优秀的图象质量。
+
+**而，H.264与以前的国际标准如H.263和MPEG-4相比，最大的优势体现在以下四个方面：**
+
+
+
+- 将每个视频帧分离成由像素组成的块，因此视频帧的编码处理的过程可以达到块的级别。
+- 采用空间冗余的方法，对视频帧的一些原始块进行空间预测、转换、优化和熵编码（可变长编码）。
+- 对连续帧的不同块采用临时存放的方法，这样，只需对连续帧中有改变的部分进行编码。该算法采用运动预测和运动补偿来完成。对某些特定的块，在一个或多个已经进行了编码的帧执行搜索来决定块的运动向量，并由此在后面的编码和解码中预测主块。
+- 采用剩余空间冗余技术，对视频帧里的残留块进行编码。例如：对于源块和相应预测块的不同，再次采用转换、优化和熵编码。
+
+
+**具体优势表现为：**
+
+
+
+- 低码流：和MPEG2和MPEG4 ASP等压缩技术相比，在同等图像质量下，采用H.264技术压缩后的数据量只有MPEG2的1/8，MPEG4的1/3。显然，H.264压缩技术的采用将大大节省用户的下载时间和数据流量收费。
+- 高质量的图象：H.264能提供连续、流畅的高质量图象（DVD质量）。
+- 容错能力强：H.264提供了解决在不稳定网络环境下容易发生的丢包等错误的必要工具。
+- 网络适应性强：H.264提供了网络适应层， 使得H.264的文件能容易地在不同网络上传输（例如互联网，CDMA，GPRS，WCDMA，CDMA2000等）。
+
+
+ H.264和以前的标准一样，也是DPCM加变换编码的混合编码模式。但它采用“回归基本”的简洁设计，不用众多的选项，获得比H.263++好得多的压缩性能；加强了对各种信道的适应能力，采用“网络友好”的结构和语法，有利于对误码和丢包的处理；应用目标范围较宽，以满足不同速率、不同解析度以及不同传输（存储）场合的需求。
+
+## H.264标准的关键技术
+
+
+
+### 1 帧内预测编码
+
+
+ 帧内编码用来缩减图像的空间冗余。为了提高H.264帧内编码的效率，在给定帧中充分利用相邻宏块的空间相关性，相邻的宏块通常含有相似的属性。因此，在对一给定宏块编码时，首先可以根据周围的宏块预测（典型的是根据左上角的宏块，因为此宏块已经被编码处理），然后对预测值与实际值的差值进行编码，这样，相对于直接对该帧编码而言，可以大大减小码率。
+
+
+
+### 2帧间预测编码
+
+
+ 帧间预测编码利用连续帧中的时间冗余来进行运动估计和补偿。H.264的运动补偿支持以往的视频编码标准中的大部分关键特性，而且灵活地添加了更多的功能，除了支持P帧、B帧外，H.264还支持一种新的流间传送帧——SP帧，如图3所示。码流中包含SP帧后，能在有类似内容但有不同码率的码流之间快速切换，同时支持随机接入和快速回放模式。
+
+
+
+### 3整数变换
+
+
+ 在变换方面，H.264使用了基于4×4像素块的类似于DCT的变换，但使用的是以整数为基础的空间变换，不存在反变换，因为取舍而存在误差的问题，变换矩阵如图5所示。与浮点运算相比，整数DCT变换会引起一些额外的误差，但因为DCT变换后的量化也存在量化误差，与之相比，整数DCT变换引起的量化误差影响并不大。此外，整数DCT变换还具有减少运算量和复杂度，有利于向定点DSP移植的优点。
+
+
+
+### 4量化
+
+
+ H.264中可选32种不同的量化步长，这与H.263中有31个量化步长很相似，但是在H.264中，步长是以12.5%的复合率递进的，而不是一个固定常数。
+
+ 在H.264中，变换系数的读出方式也有两种：之字形（Zigzag）扫描和双扫描，如图6所示。大多数情况下使用简单的之字形扫描；双扫描仅用于使用较小量化级的块内，有助于提高编码效率。
+
+
+
+### 5熵编码
+
+
+ 视频编码处理的最后一步就是熵编码，在H.264中采用了两种不同的熵编码方法：通用可变长编码（UVLC）和基于文本的自适应二进制算术编码（CABAC）。
+
+ 在H.263等标准中，根据要编码的数据类型如变换系数、运动矢量等，采用不同的VLC码表。H.264中的UVLC码表提供了一个简单的方法，不管符号表述什么类型的数据，都使用统一变字长编码表。其优点是简单；缺点是单一的码表是从概率统计分布模型得出的，没有考虑编码符号间的相关性，在中高码率时效果不是很好。
+
+ 因此，H.264中还提供了可选的CABAC方法。算术编码使编码和解码两边都能使用所有句法元素（变换系数、运动矢量）的概率模型。为了提高算术编码的效率，通过内容建模的过程，使基本概率模型能适应随视频帧而改变的统计特性。内容建模提供了编码符号的条件概率估计，利用合适的内容模型，存在于符号间的相关性可以通过选择目前要编码符号邻近的已编码符号的相应概率模型来去除，不同的句法元素通常保持不同的模型。
+
+## H.264在实时视频聊天中的应用
+
+
+ 目前，H.264已被广泛应用于实时视频应用中，相比以往的方案使得在同等速率下，H.264能够比H.263减小50%的码率。也就是说，用户即使是只利用 384kbit/s的带宽，就可以享受H.263下高达 768kbit/s的高质量视频服务。H.264  不但有助于节省庞大开支，还可以提高资源的使用效率，同时令达到商业质量的实时视频服务拥有更多的潜在客户。
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/H265.md" "b/VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/H265.md"
new file mode 100644
index 00000000..45aa49ec
--- /dev/null
+++ "b/VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/H265.md"
@@ -0,0 +1,101 @@
+H264
+===
+
+
+
+
+
+H.264是一种高性能的视频编解码技术。目前国际上制定视频编解码技术的组织有两个，一个是“国际电联”，它制定的标准有H.261、H.263、H.263+等，另一个是“国际标准化组织（ISO）”它制定的标准有MPEG-1、MPEG-2、MPEG-4等。而H.264则是由两个组织联合组建的联合视频组（JVT）共同制定的新数字视频编码标准，所以它既是ITU-T的H.264，又是ISO/IEC的MPEG-4高级视频编码，而且它将成为MPEG-4标准的第10部分。因此，不论是MPEG-4 AVC、MPEG-4 Part 10，还是ISO/IEC 14496-10，都是指H.264。
+
+
+
+
+
+## H.264算法的优势
+
+
+ H.264是在MPEG-4技术的基础之上建立起来的，其编解码流程主要包括5个部分：帧间和帧内预测、变换和反变换、量化和反量化、环路滤波、熵编码。
+
+ H.264/MPEG-4  AVC（H.264）是1995年自MPEG-2视频压缩标准发布以后的最新、最有前途的视频压缩标准。H.264是由ITU-T和ISO/IEC的联合开发组共同开发的最新国际视频编码标准。通过该标准，在同等图象质量下的压缩效率比以前的标准提高了2倍以上，因此，H.264被普遍认为是最有影响力的行业标准。
+
+## H.264的优势
+
+
+ H.264在1997年ITU的视频编码专家组提出时被称为H.26L，在ITU与ISO合作研究后被称为MPEG4 Part10或H.264（JVT）。H.264标准的主要目标是：与其它现有的视频编码标准相比，在相同的带宽下提供更加优秀的图象质量。
+
+**而，H.264与以前的国际标准如H.263和MPEG-4相比，最大的优势体现在以下四个方面：**
+
+
+
+- 将每个视频帧分离成由像素组成的块，因此视频帧的编码处理的过程可以达到块的级别。
+- 采用空间冗余的方法，对视频帧的一些原始块进行空间预测、转换、优化和熵编码（可变长编码）。
+- 对连续帧的不同块采用临时存放的方法，这样，只需对连续帧中有改变的部分进行编码。该算法采用运动预测和运动补偿来完成。对某些特定的块，在一个或多个已经进行了编码的帧执行搜索来决定块的运动向量，并由此在后面的编码和解码中预测主块。
+- 采用剩余空间冗余技术，对视频帧里的残留块进行编码。例如：对于源块和相应预测块的不同，再次采用转换、优化和熵编码。
+
+
+**具体优势表现为：**
+
+
+
+- 低码流：和MPEG2和MPEG4 ASP等压缩技术相比，在同等图像质量下，采用H.264技术压缩后的数据量只有MPEG2的1/8，MPEG4的1/3。显然，H.264压缩技术的采用将大大节省用户的下载时间和数据流量收费。
+- 高质量的图象：H.264能提供连续、流畅的高质量图象（DVD质量）。
+- 容错能力强：H.264提供了解决在不稳定网络环境下容易发生的丢包等错误的必要工具。
+- 网络适应性强：H.264提供了网络适应层， 使得H.264的文件能容易地在不同网络上传输（例如互联网，CDMA，GPRS，WCDMA，CDMA2000等）。
+
+
+ H.264和以前的标准一样，也是DPCM加变换编码的混合编码模式。但它采用“回归基本”的简洁设计，不用众多的选项，获得比H.263++好得多的压缩性能；加强了对各种信道的适应能力，采用“网络友好”的结构和语法，有利于对误码和丢包的处理；应用目标范围较宽，以满足不同速率、不同解析度以及不同传输（存储）场合的需求。
+
+## H.264标准的关键技术
+
+
+
+### 1 帧内预测编码
+
+
+ 帧内编码用来缩减图像的空间冗余。为了提高H.264帧内编码的效率，在给定帧中充分利用相邻宏块的空间相关性，相邻的宏块通常含有相似的属性。因此，在对一给定宏块编码时，首先可以根据周围的宏块预测（典型的是根据左上角的宏块，因为此宏块已经被编码处理），然后对预测值与实际值的差值进行编码，这样，相对于直接对该帧编码而言，可以大大减小码率。
+
+
+
+### 2帧间预测编码
+
+
+ 帧间预测编码利用连续帧中的时间冗余来进行运动估计和补偿。H.264的运动补偿支持以往的视频编码标准中的大部分关键特性，而且灵活地添加了更多的功能，除了支持P帧、B帧外，H.264还支持一种新的流间传送帧——SP帧，如图3所示。码流中包含SP帧后，能在有类似内容但有不同码率的码流之间快速切换，同时支持随机接入和快速回放模式。
+
+
+
+### 3整数变换
+
+
+ 在变换方面，H.264使用了基于4×4像素块的类似于DCT的变换，但使用的是以整数为基础的空间变换，不存在反变换，因为取舍而存在误差的问题，变换矩阵如图5所示。与浮点运算相比，整数DCT变换会引起一些额外的误差，但因为DCT变换后的量化也存在量化误差，与之相比，整数DCT变换引起的量化误差影响并不大。此外，整数DCT变换还具有减少运算量和复杂度，有利于向定点DSP移植的优点。
+
+
+
+### 4量化
+
+
+ H.264中可选32种不同的量化步长，这与H.263中有31个量化步长很相似，但是在H.264中，步长是以12.5%的复合率递进的，而不是一个固定常数。
+
+ 在H.264中，变换系数的读出方式也有两种：之字形（Zigzag）扫描和双扫描，如图6所示。大多数情况下使用简单的之字形扫描；双扫描仅用于使用较小量化级的块内，有助于提高编码效率。
+
+
+
+### 5熵编码
+
+
+ 视频编码处理的最后一步就是熵编码，在H.264中采用了两种不同的熵编码方法：通用可变长编码（UVLC）和基于文本的自适应二进制算术编码（CABAC）。
+
+ 在H.263等标准中，根据要编码的数据类型如变换系数、运动矢量等，采用不同的VLC码表。H.264中的UVLC码表提供了一个简单的方法，不管符号表述什么类型的数据，都使用统一变字长编码表。其优点是简单；缺点是单一的码表是从概率统计分布模型得出的，没有考虑编码符号间的相关性，在中高码率时效果不是很好。
+
+ 因此，H.264中还提供了可选的CABAC方法。算术编码使编码和解码两边都能使用所有句法元素（变换系数、运动矢量）的概率模型。为了提高算术编码的效率，通过内容建模的过程，使基本概率模型能适应随视频帧而改变的统计特性。内容建模提供了编码符号的条件概率估计，利用合适的内容模型，存在于符号间的相关性可以通过选择目前要编码符号邻近的已编码符号的相应概率模型来去除，不同的句法元素通常保持不同的模型。
+
+## H.264在实时视频聊天中的应用
+
+
+ 目前，H.264已被广泛应用于实时视频应用中，相比以往的方案使得在同等速率下，H.264能够比H.263减小50%的码率。也就是说，用户即使是只利用 384kbit/s的带宽，就可以享受H.263下高达 768kbit/s的高质量视频服务。H.264  不但有助于节省庞大开支，还可以提高资源的使用效率，同时令达到商业质量的实时视频服务拥有更多的潜在客户。
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/VideoDevelopment/\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md" "b/VideoDevelopment/\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
index a3329194..a6e48d63 100644
--- "a/VideoDevelopment/\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
+++ "b/VideoDevelopment/\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
@@ -209,6 +209,10 @@ PAR DAR SAR
 
   音视频在网络上传播的时候，常常采用各种流媒体协议，例如HTTP、RTMP等等，这些协议在传输音视频数据的同时也会传输一些信令数据。这些信令数据包括对播放的控制(播放、暂停、停止)或者对网络状态的描述等。解协议的过程中会去除掉信令数据而只保留音视频数据。例如，采用RTMP协议传输的数据，经过解协议操作后，输出FLV格式的数据。
 
+[常见流媒体协议](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE/%E6%B5%81%E5%AA%92%E4%BD%93%E9%80%9A%E4%BF%A1%E5%8D%8F%E8%AE%AE.md)
+
+
+
 
 
 

From 5a9fcd1d9a7bd8bab7645015455612a15467a33a Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Sat, 6 Jun 2020 21:00:28 +0800
Subject: [PATCH 021/213] add images

---
 .../DASH.md"                                  |  86 +----
 .../HLS.md"                                   |  27 +-
 .../HTTP FLV.md"                              |  91 ++++++
 .../RTMP.md"                                  |  31 ++
 ...32\344\277\241\345\215\217\350\256\256.md" | 299 ++++++++++++++++--
 .../FLV.md"                                   |  21 ++
 ...74\345\274\217\350\257\246\350\247\243.md" |  63 +++-
 .../TS.md"                                    |  94 ++++++
 .../fMP4 vs ts.md"                            |  98 ++++++
 ...74\345\274\217\350\257\246\350\247\243.md" |  58 ++++
 ...01\350\243\205\346\240\274\345\274\217.md" | 195 ++++++++++++
 11 files changed, 947 insertions(+), 116 deletions(-)
 create mode 100644 "VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HTTP FLV.md"
 create mode 100644 "VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/RTMP.md"
 create mode 100644 "VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/FLV.md"
 rename "VideoDevelopment/MP4\346\240\274\345\274\217\350\257\246\350\247\243.md" => "VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/MP4\346\240\274\345\274\217\350\257\246\350\247\243.md" (57%)
 create mode 100644 "VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/TS.md"
 create mode 100644 "VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/fMP4 vs ts.md"
 create mode 100644 "VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/fMP4\346\240\274\345\274\217\350\257\246\350\247\243.md"
 create mode 100644 "VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217.md"

diff --git "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/DASH.md" "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/DASH.md"
index 0ebf8bd3..21743f4a 100644
--- "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/DASH.md"
+++ "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/DASH.md"
@@ -2,7 +2,9 @@
 
 除了前面讲的Apple的HLS，还有Adobe HTTP Dynamic Streaming (HDS)、Microsoft Smooth Streaming (MSS)。他们各家的协议原理大致相同，但是格式又不一样，也无法兼容，所以Moving Picture Expert Group (MPEG) 就把大家叫到了一起，呼吁大家一起来制定一个标准的，然后就有了[MPEG-DASH](https://www.encoding.com/mpeg-dash/),它的主要目标是形成IP网络承载单一格式的流媒体并提供高效与高质量服务的统一方案，解决多制式传输方案(HTTP Live  Streaming, Microsoft Smooth Streaming, HTTP Dynamic  Streaming)并存格局下的存储与服务能力浪费、运营高成本与复杂度、系统间互操作弱等问题。
 
-[DASH(MPEG-DASH)](https://mpeg.chiariglione.org/standards/mpeg-dash/)全称为Dynamic Adaptive Streaming over HTTP.是由MPEG和ISO批准的独立于供应商的国际标准，它是一种基于HTTP的使用TCP传输协议的流媒体传输技术。MPEG-DASH是一种自适应比特率流技术，可根据实时网络状况实现动态自适应下载。和HLS, HDS技术类似， 都是把视频分割成一小段一小段，  通过HTTP协议进行传输，客户端得到之后进行播放；不同的是MPEG-DASH支持MPEG-2 TS、MP4(最新的HLS也支持了MP4)等多种格式,  可以将视频按照多种编码切割, 下载下来的媒体格式既可以是ts文件也可以是mp4文件，MPEG—DASH技术与编解码器无关，可使用H.265，H.264，VP9等任何编解码器进行编码。
+[DASH(MPEG-DASH)](https://mpeg.chiariglione.org/standards/mpeg-dash/)全称为Dynamic Adaptive Streaming over HTTP.是由MPEG和ISO批准的独立于供应商的国际标准，它是一种基于HTTP的使用TCP传输协议的流媒体传输技术。它诞生的目的是为了统一标准，因此是兼容SmoothStreaming和HLS的.同时支持TS profile和 ISO  profile，支持节目观看等级控制，支持父母锁. mpeg  dash支持的DRM类型包括PlayReady和Marlin，而HLS支持的是AES128（密钥长度为128位的高级加密标准Advanced  Encryption Standard）加密类型。
+
+MPEG-DASH是一种自适应比特率流技术，可根据实时网络状况实现动态自适应下载。和HLS, HDS技术类似， 都是把视频分割成一小段一小段，  通过HTTP协议进行传输，客户端得到之后进行播放；不同的是MPEG-DASH支持MPEG-2 TS、MP4(最新的HLS也支持了MP4)等多种格式,  可以将视频按照多种编码切割, 下载下来的媒体格式既可以是ts文件也可以是mp4文件，MPEG—DASH技术与编解码器无关，可使用H.265，H.264，VP9等任何编解码器进行编码。
 
 安卓平台上的ExoPlayer支持MPEG-DASH。另外，三星、索尼、飞利浦、松下的一些较新型号的智能电视支持MPEG—DASH。Google的Chromecast、YouTube 和Netflix 也已支持MPEG-DASH。
 
@@ -123,71 +125,21 @@ Segments可以包含任何媒体数据，关于容器，官方提供了两种建
 
     
 
-## fMP4
-
-[MP4和fMP4的详细介绍](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/MP4%E6%A0%BC%E5%BC%8F%E8%AF%A6%E8%A7%A3.md)
-
-
-
-fMP4（fragmented MP4），可以简单理解为分片化的MP4，是DASH采用的媒体文件格式，文件扩展名通常为（.m4s或直接用.mp4）。     
-
-![fMP4](https://img-blog.csdn.net/20171107114807709?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQveXVlX2h1YW5n/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
-
-
-
-### fMP4与ts的区别
-
-最主要的就是.ts文件不提供关于时长等信息，你无法在ts文件中去实现音视频的seek操作。fmp4不同于ts，它是提供了时长等信息，可以执行seek到指定位置。
-
-
-
-### 媒体数据与元数据的分离
-
-在mp4格式中，元数据可以和媒体数据很好地分开存储，后者都在mdat box中，而在ts中，诸多es流和header/metadata信息是复用在一起的。
- 元数据的分离允许我们在streaming中先读取各个流的元数据，知道他们的媒体内容的属性（比如不同的视频质量、不同的语言等），从而可以更好地在不同的media data之间做自适应切换。
- 当然，在更实际的应用场景中，比如在dash协议中会直接把这些元数据信息写在mpd中，player可以只读一个mpd就知道各个媒体数据的属性
-
-### 各个Track独立存储
-
-在fmp4中，不仅媒体数据和metadata相互独立的存储，音视频track的数据也可以分开存储，这里的“分开”已经不仅仅局限于box层面的分开，而是真的可以分开存储于不同的目录。在这种情况下，player只需要读一个记录了它们各自存储位置的manifest，即可去对应的位置download它们的分片，只要做好音视频分片之间的同步工作，就可以正常的播放。
- 举个例子，下面是一个dash中常见的mpd：
-
-在这个mpd中我们看到视频的分片都是存储在video/1/这个目录下，而音频分片都存储在audio/und/mp4a/1这个目录下，而player还是可以将它们拼接到一起完成播放。
- 相对地，在streaming TS流时，音视频往往是复用在一起的，以HLS这个应用场景为例的话，server端一定还需要提前将TS切片做好，这样就会带来几个问题：
-
-1. 媒体文件存储成本和媒资管理成本增加
-    假设server端将video track编码为三个质量级别V1, V2, V3，audio track也被编码为三个质量级别A1, A2,  A3，那么如果利用fmp4格式的特性，我们只需要存储这6份媒体文件，player在播放时再自主组合不同质量级别的音视频track即可。而对于TS，则不得不提前将3x3=9种不同的音视频复用情况对应的媒体文件都存储到server端，平白无故多出三份文件的存储成本。实际中，因为要考虑到大屏端、小屏端、移动端、桌面端、不同语言、不同字幕等各种情况，使用TS而造成的冗余成本将更加可观。同时，存储文件的增加也意味着媒资管理成本的增加。这也是包括Netflix在内的一些公司选择使用fmp4做streaming格式的原因。
-2. manifest文件更加复杂
-    fmp4格式的特性可以确保每一个单独的媒体分片都是可解密可解码的（当然player需要先从moov  box中读到它们的编解码等信息），这意味着server端甚至根本不需要真的存储一大堆分片，player可以直接利用byte range  request技术从一个大文件中准确地读出一个分片对应的media data，这也使得对应manifest(mpd)文件可以更加简洁，如下：
 
-针对不同语言的音频，都只需要存一个大文件就够了。
-相对地，在streaming TS流时，不得不在manifest（m3u8）文件中把成百上千个ts分片文件全都老老实实地记录下来。
 
-所以Dash同样可以支持下面的操作: 
 
-- 音频视频分离，在后台播放时可以只拉取音频
-- 支持多音轨，多视频轨，多字幕任意切换
 
-### 服务器的cache效率会降低
- 实际的streaming应用场景中，往往需要cdn的支持，经常会被client请求的媒体分片就会存在距离client最近的edge  server上。对于fmp4 streaming的情况，因为需要的文件更少，cache命中率也就更高，举个例子：可能某一个audio  track会和其他各种video track组合，那么就可以将这个audio track放在edge server上，而不用每次都跟origin server去请求。
- 相对地，在streaming TS流时，因为每一个音视频组合的都需要以复用文件的形式存储，组合数又非常多，相当于分母大了，edge server就会有很大的几率没有缓存需要的组合而要去向orgin server请求。
+### HLS vs DASH
 
-### 对Trick-play的支持
 
-所谓Trick-play，就是快进、快退、直接跳到章节起点、慢动作播放这些“花式”播放功能。支持这些功能往往意味着要快速找到播放流中的关键帧，以快进播放为例，如果利用fmp4格式的特点，可以通过只读取每个媒体分片的moof加上mdat的起始（包含了关键帧图像）部分即可，说白了就是通过只显示关键帧的方法达到“快进”的视觉效果。因为fmp4格式中可以保证每一个分片一定是以IDR帧开始的，这就使得上述的方案实现起来非常方便。
- 相对地，在streaming TS流时，没有办法保证关键帧一定在什么位置，所以你可能需要解析一大堆TS packets才能找到关键帧的位置。
 
-### 无缝码流切换
+- 在标准HTTP服务器上的用法： HLS和DASH均可在常规HTTP服务器（例如Nginx，Apache等）上使用。
+- 多个音频通道: 特别是对于多语言内容，重要的是能够在各个语言的不同音频通道之间进行切换。 DASH和HLS都可以做到这一点。
+- 字幕和标题: 为了给视频添加字幕，通常创建一个单独的文件，例如，文件可以具有WebVTT格式。然后从清单（即.m3u8或.mpd文件）中引用该文件。
+- 插入广告: 通常，可以在HLS和DASH的实时流中插入广告。为此，只需交换单个视频块。 DASH为此提供了一种有效的方法：标准化的界面允许有效地插入广告。
+- 快速频道切换: 您可以在各个通道之间切换的速度取决于最大的子段（块）。块越小，通道更改速度越快。正如引言中已经提到的，HLS块通常长约10秒，而DASH块通常长2至4秒。因此，DASH在这方面领先一步。小块还具有降低代码效率的缺点。具有较小块的播放列表必须比具有较大块的播放列表更频繁地更新。这意味着包含较短视频片段的播放列表必须通过HTTP更频繁地更新。
 
-无缝码流切换实现的关键在于：当第一个码流播放结束时，也就是发生切换的时间，第二个码流一定要以关键帧开始播放。在streaming  TS流时，因为不能保证每一个TS  chunk一定以关键帧开始，做码流切换时就意味着要同时download两个码流的相应分片，同时解析两个码流，然后找到关键帧对应的位置，才能切换。同时下载、解析两个码流的媒体内容对网络带宽以及设备性能都形成了挑战。而且有意思的是，如果当前网络环境不佳，player想要切换到低码率码流，结果还要在本来就不好的网络环境下同时进行两个码流的下载，可谓是雪上加霜。
- 而在fmp4中，除了保证各个分片一定以IDR帧开始外，还能保证不同码流的分片之间在时间线上是对齐的。而且streaming  fmp4流时因为不要求音视频复用存储，也就意味着视频和音频的同步点可以不一样，视频可以全都以GOP边界作为同步点，音频可以都以sync  frame作为同步点，这都使得无缝码流切换更简单。
 
-### 与DRM的集成
-
-所谓DRM即数字版权管理，说白了就是对流进行加密，这东西在国内用的不多，但是在国外可是每一个内容提供商必须要有的东西。和编码标准一样，业界也存在很多DRM方案，为了避免每采用一个新的加密方案就要重新编一个码流，MPEG推出了通用加密（CENC）标准（23001-7 - Common Encryption）。使用这一标准的码流，就可以将一个码流应用于各种不同的DRM方案。在DASH  spec中，也定义了Content Protection字段来对应这种加密方案。
- CENC使用的就是fMP4格式，这是利用了fMP4中音视频可以不复用同时还能提供独立于media data存储的metadata的特点。TS流就享受不了这样的好处了。
-
-DASH和HLS之间的另一个关键区别是它支持DRM。可是，在DASH中不存在一个单一通用的DRM解决方案。例如，Google的Chrome支持Widevine，而Microsoft的Internet  Explorer支持PlayReady。然而，通过使用MPEG-CENC（MPEG通用加密）结合加密媒体扩展（EME），视频流内容可以仅被加密一次。HLS支持AES-128加密，以及苹果自己的DRM，Fairplay。
 
 
 
@@ -195,8 +147,6 @@ DASH和HLS之间的另一个关键区别是它支持DRM。可是，在DASH中不
 
 - HEVC HLS with fMP4: [http://bitmovin-a.akamaihd.net/content/dataset/multi-codec/hevc/stream_fmp4.m3u8](https://bitmovin-a.akamaihd.net/content/dataset/multi-codec/hevc/stream_fmp4.m3u8)
 
-    
-
 - HEVC HLS with TS (not supported by Apple): [http://bitmovin-a.akamaihd.net/content/dataset/multi-codec/hevc/stream_ts.m3u8](https://bitmovin-a.akamaihd.net/content/dataset/multi-codec/hevc/stream_ts.m3u8)
 
     [https://bitmovin-a.akamaihd.net/content/playhouse-vr/m3u8s/105560.m3u8](https://bitmovin-a.akamaihd.net/content/playhouse-vr/m3u8s/105560.m3u8)
@@ -213,23 +163,11 @@ DASH和HLS之间的另一个关键区别是它支持DRM。可是，在DASH中不
 
 参考:  
 
-[HLS，MPEG-DASH - What is ABR?](http://telestreamblog.telestream.net/2017/05/what-is-abr/)
-
-[B站我们为什么使用DASH](https://www.bilibili.com/read/cv855111)
-
-
-
-
-
-
-
-
-
-
-
-
+- [HLS，MPEG-DASH - What is ABR?](http://telestreamblog.telestream.net/2017/05/what-is-abr/)
 
+- [B站我们为什么使用DASH](https://www.bilibili.com/read/cv855111)
 
+- [Adaptive HTTP Streaming Technologies: HLS vs. DASH](https://strivecast.io/hls-vs-mpeg-dash/)
 
 
 
diff --git "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HLS.md" "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HLS.md"
index 3aede2fa..acfeaf00 100644
--- "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HLS.md"
+++ "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HLS.md"
@@ -11,11 +11,23 @@ HLS协议规定:
 HLS协议由三部分组成:  
 
 - HTTP:传输协议
-- m3u8:索引文件
+- m3u8:索引文件(m3u8 文件本质说其实是采用了编码是 UTF-8 的 m3u 文件。)
 - TS:音视频媒体信息
 
 HLS点播，基本上就是常见的分段HTTP点播，不同在于，它的分段非常小。相对于常见的流媒体直播协议，例如RTMP协议、RTSP协议、MMS协议等，HLS直播最大的不同在于，直播客户端获取到的，并不是一个完整的数据流。HLS协议在服务器端将直播数据流存储为连续的、很短时长的媒体文件（MPEG-TS格式），而客户端则不断的下载并播放这些小文件。因为服务器端总是会将最新的直播数据生成新的小文件，这样客户端只要不停的按顺序播放从服务器获取到的文件，就实现了直播。由此可见，基本上可以认为，HLS是以点播的技术方式来实现直播。由于数据通过HTTP协议传输，所以完全不用考虑防火墙或者代理的问题，而且分段文件的时长很短，客户端可以很快的选择和切换码率，以适应不同带宽条件下的播放。不过HLS的这种技术特点，决定了它的延迟一般总是会高于普通的流媒体直播协议。它也解决了RTMP协议存在的一些问题，例如RTMP协议不使用标准的HTTP接口传输数据(TCP、UDP端口)，所以在一些特殊的网络环境下可能被防火墙屏蔽掉，而HLS使用的是HTTP协议传输数据(80端口)，不会遇到被防火墙屏蔽的情况。
 
+
+
+### HLS架构
+
+HLS的架构分为三部分：Server，CDN，Client 。即服务器、分发组件和客户端。
+
+下面是 HLS 整体架构图：
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/transport_stream_2x.png" style="zoom:50%;" />
+
+
+
 ## TS
 
 TS(Transport Stream)，全程为MPEG2-TS。它的特点就是要求从视频流的任一片段开始都是可以独立解码的。DVD节目中的MPEG2格式，确切的说是MPEG2-PS，全程是Program Stream，而TS的全称是Transport Stream。MPEG2-PS主要应用于存储的具有固定市场的节目，如DVD电影，而MPEG2-TS则主要应用于实时传送的节目，比如实时广播的电视节目。这两种格式的主要区别是什么呢？简单地打个比喻说，你将DVD上的[VOB](https://baike.baidu.com/item/VOB)文件的前面一截cut掉（或者干脆就是数据损坏），那么就会导致整个文件无法解码了，而电视节目是你任何时候打开电视机都能解码（收看）的，所以，MPEG2-TS格式的特点就是要求从[视频流](https://baike.baidu.com/item/视频流)的任一片段开始都是可以独立解码的。
@@ -27,7 +39,7 @@ TS(Transport Stream)，全程为MPEG2-TS。它的特点就是要求从视频流
 - 是一个索引地址/播放列表，通过FFmpeg将本地的xxx.mp4进行切片处理，生成m3u8播放列表（索引文件）和N多个  .ts文件，并将其（m3u8、N个ts）放置在本地搭建好的webServer服务器的指定目录下，我就可以得到一个可以实时播放的网址，我们把这个m3u8地址复制到 VLC 上就可以实时观看！ 在 HLS 流下，本地视频被分割成一个一个的小切片，一般10秒一个，这些个小切片被 m3u8管理，并且随着终端的FFmpeg  向本地拉流的命令而实时更新，影片进度随着拉流的进度而更新，播放过的片段不在本地保存，自动删除，直到该文件播放完毕或停止，ts  切片会相应的被删除，流停止，影片不会立即停止，影片播放会滞后于拉流一段时间
 
 
-<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/transport_stream_2x.png" style="zoom:50%;" />
+
 
 - Media encoder(媒体编码)
 
@@ -138,16 +150,19 @@ cctv1hd-1585920074000.ts
 
 ## HLS 的劣势
 
-- 相比 RTMP 这类长连接协议, 延时较高, 难以用到互动直播场景.HLS 理论延时 = 1 个切片的时长 + 0-1个 td (td 是 EXT-X-TARGETDURATION, 可简单理解为播放器取片的间隔时间) + 0-n 个启动切片(苹果官方建议是请求到 3 个片之后才开始播放) + 播放器最开始请求的片的网络延时(网络连接耗时)。为了追求低延时效果, 可以将切片切的更小, 取片间隔做的更小, 播放器未取到 3 个片就启动播放. 但是, 这些优化方式都会增加 HLS 不稳定和出现错误的风险.
+- 相比 RTMP 这类长连接协议, 延时较高, 难以用到互动直播场景.HLS 理论延时 = 1 个切片的时长 + 0-1个 td (td 是 EXT-X-TARGETDURATION, 可简单理解为播放器取片的间隔时间) + 0-n 个启动切片(苹果官方建议是请求到 3 个片之后才开始播放) + 播放器最开始请求的片的网络延时(网络连接耗时)。为了追求低延时效果, 可以将切片切的更小, 取片间隔做的更小, 播放器未取到 3 个片就启动播放. 但是, 这些优化方式都会增加 HLS 不稳定和出现错误的风险.通常 HLS 直播延时会达到 20-30s，而高延时对于需要实时互动体验的直播来说是不可接受的。
 - 对于点播服务来说, 由于 TS 切片通常较小, 海量碎片在文件分发, 一致性缓存, 存储等方面都有较大挑战.
+- HLS 基于短连接 HTTP，HTTP 是基于 TCP 的，这就意味着 HLS 需要不断地与服务器建立连接，TCP 每次建立连接时的三次握手、慢启动过程、断开连接时的四次挥手都会产生消耗。
 
 
 
 
 
-
-
-
+CCTV1高清：http://ivi.bupt.edu.cn/hls/cctv1hd.m3u8
+CCTV3高清：http://ivi.bupt.edu.cn/hls/cctv3hd.m3u8
+CCTV5高清：http://ivi.bupt.edu.cn/hls/cctv5hd.m3u8
+CCTV5+高清：http://ivi.bupt.edu.cn/hls/cctv5phd.m3u8
+CCTV6高清：http://ivi.bupt.edu.cn/hls/cctv6hd.m3u8
 
 
 
diff --git "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HTTP FLV.md" "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HTTP FLV.md"
new file mode 100644
index 00000000..2ac14110
--- /dev/null
+++ "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HTTP FLV.md"	
@@ -0,0 +1,91 @@
+HTTP FLV
+===
+
+先看看HTTP-FLV长成什么样子：http://ip:port/live/livestream.flv，协议头是http,另外”.flv”这个尾巴是它最明显的特征。
+
+HttpFlv 就是 http+flv ，将音视频数据封装成FLV格式，然后通过 HTTP 协议传输给客户端。
+
+
+
+下的直播平台中大部分的主线路使用的都是HTTP-FLV协议，备线路多为RTMP。小编随便在Safari中打开几个直播平台房间，一抓包就不难发现使用HTTP-FLV协议的身影：熊猫、斗鱼、虎牙、B站。
+
+
+
+
+
+FLV（Flash  Video）是Adobe公司设计开发的一种流行的流媒体格式，由于其视频文件体积轻巧、封装简单等特点，使其很适合在互联网上进行应用。此外，FLV可以使用Flash Player进行播放，而Flash  Player插件已经安装在绝大部分浏览器上，这使得通过网页播放FLV视频十分容易。FLV封装格式的文件后缀通常为“.flv”。
+
+在说HTTP-FLV之前，我们有必要对FLV adobe 官方标准有个认识，因为HTTP-FLV协议中封装格式使用的是FLV。
+
+FLV文件格式标准是写F4V/FLV fileformat spec v10.1的附录E里面的FLVFile Format。
+
+
+
+Flash Video`:是Adobe公司推出的另一种视频格式，是一种在网络上传输的流媒体数据存储容器格式。其格式相对简单轻量，不需要很大的媒体头部信息。整个FLV由Header和Body以及其他Tag组成。因此加载速度极快。它是基于HTTP/80传输，可以避免被防火墙拦截的问题，除此之外，它可以通过 HTTP 302 跳转灵活调度/负载均衡，支持使用 HTTPS 加密传输，也能够兼容支持 Android，iOS 的移动端。但是由于它的传输特性，会让流媒体资源缓存在本地客户端，在保密性方面不够好，因为网络流量较大，它也不适合做拉流协议。
+
+
+
+
+
+HTTP-FLV
+
+我们这里说的HTTP-FLV，主要是说的是HTTP-FLV流，而不是基于HTTP的FLV视频文件点播，也不是能够随意SEEK的HTTP FLV伪流。
+
+FLV渐进式下载：通过HTTP协议将FLV下载到播放器中播放，无法直接拉到中间去播放。
+
+HTTP FLV伪流：支持SEEK，可从未下载的部分开始播放。
+
+HTTP-FLV流：拥有和流式协议RTMP一样的特征，长连接，流式数据。
+
+
+
+▣  HTTP-FLV技术实现
+
+HTTP协议中有个content-length字段的约定，即http的body部分的长度。服务器回复http请求时如果有这个字段，客户端就接收这个长度的数据然后认为数据传输完成了，开始播放。
+
+如果服务器回复http请求中没有这个字段，客户端就一直保持长连接接收数据，直到服务器跟客户端的socket断开。
+
+HTTP-FLV流就利用了上述的第二个原理，服务器回复客户端请求的时候不加content-length字段，在回复了http内容之后，进行持续的数据发送，客户端就一直接收数据，以此实现了HTTP-FLV流直播。
+
+数据传输依然是之前讲过的内容，每一个音视频数据都被封装成包含时间戳信息头的数据包，封装格式采用FLV，传输协议采用http。
+
+
+
+
+
+❸  RTMP和HTTP-FLV的比较：
+
+RTMP和HTTP-FLV延迟上保持一致，在这二者的区别如下：
+
+▲  穿墙：很多防火墙会墙掉RTMP，但是不会墙HTTP，因此HTTPFLV更不容易出问题。
+
+▲  调度：虽然RTMP也能支持302，单实现起来较麻烦。HTTP FLV本身就支持302，更方便CDN进行重定向以便更精准的调度。
+
+▲  容错： HTTP-FLV回源时也可以回多个源，能做到和RTMP一样，支持多级热备。
+
+▲  简单：FLV是最简单的流媒体封装，HTTP是最广泛的协议，这两个组合在一起维护性更高，比RTMP简单。
+
+▲  友好：HTTP-FLV代码量更小，集成SDK也更轻便。使用起来也更简单。
+
+综上，HTTP-FLV协议具有RTMP的延迟优势，又继承了HTTP所有优势，是流媒体直播首选的分发协议。
+
+
+
+
+
+
+
+
+
+https://blog.csdn.net/luzubodfgs/article/details/78155117
+
+
+
+https://blog.csdn.net/qq_37382077/article/details/103386289
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/RTMP.md" "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/RTMP.md"
new file mode 100644
index 00000000..e3918a9d
--- /dev/null
+++ "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/RTMP.md"
@@ -0,0 +1,31 @@
+RTMP
+===
+
+
+
+
+
+http://billchan.me/2019/04/27/livestreamprotocol/
+
+
+
+Real Time Messaging Protocol(实时消息传送协议):是Adobe Systems公司为`Flash`播放器和服务器之间音频、视频和数据传输开发的开放协议。协议基于`TCP`，是一个协议族(默认端口1935)，包括`RTMP`基本协议及`RTMPT/RTMPS/RTMPE`等多种变种。`RTMP` 是一种设计用来进行实时数据通信的网络协议，主要用来在`Flash/AIR`平台和支持`RTMP`协议的流媒体/交互服务器之间进行音视频和数据通信。市面上绝大部分PC秀场使用的都是它，他有低延迟(2s左右)、稳定性高、技术完善、高支持度、编码兼容性高等特点。但是RTMP协议不使用标准的HTTP接口传输数据(TCP、UDP端口)，所以在一些特殊的网络环境下可能被防火墙屏蔽掉。
+
+RTMP的整体流程为:  
+
+视频采集器 -> 支持RTMP的视频编码器 -> 网络传输  -> 流媒体服务器 -> 网络 -> 客户端
+
+
+
+
+
+
+
+https://blog.csdn.net/qq_37382077/article/details/103386289
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/\346\265\201\345\252\222\344\275\223\351\200\232\344\277\241\345\215\217\350\256\256.md" "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/\346\265\201\345\252\222\344\275\223\351\200\232\344\277\241\345\215\217\350\256\256.md"
index 5eb94854..402a87e7 100644
--- "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/\346\265\201\345\252\222\344\275\223\351\200\232\344\277\241\345\215\217\350\256\256.md"
+++ "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/\346\265\201\345\252\222\344\275\223\351\200\232\344\277\241\345\215\217\350\256\256.md"
@@ -1,81 +1,298 @@
 流媒体通信协议
 ===
 
-流媒体(Streaming Media)是指采用流式传输技术在网络上连续实时播放的媒体格式，如音频、视频或多媒体文件，采用流媒体技术使得数据包得以像流水一样发送, 如果没有流媒体技术, 那么我们就要像以前用迅雷下电影一样, 下载整个影片才能观看。   
 
 
+## 流媒体
 
-HTTP
----
 
 
+流媒体(Streaming Media)又叫流式媒体。是指采用流式传输技术在网络上连续实时播放的媒体格式，如音频、视频或多媒体文件，采用流媒体技术使得数据包得以像流水一样发送, 如果没有流媒体技术, 那么我们就要像以前用迅雷下电影一样, 下载整个影片才能观看。这样我们需要在漫长的等待之后（因为受限于带宽，下载通常要花上较长的时间），才可以看到或听到媒体传达的信息。令人欣慰的是，在流媒体技术出现之后，人们便无需再等待媒体完全下载完成了。
 
-HTTP 视频协议是在互联网普及之后在互联网上看视频的需求下形成的。最初的 HTTP 视频协议，没有任何特别之处，就是通用的 HTTP  文件渐进式下载，但是在这种情况下，视频无法快进或者跳转到文件尚未被下载到的部分，这就对 HTTP 协议提出了范围请求（Range  Request）的要求，目前几乎所有 HTTP 服务器都支持范围请求。所谓范围请求指的是请求文件的部分数据，这可以在 HTTP 请求头中通过  Range 字段设置偏移量来实现。
+所谓流媒体技术就是把连续的影像和声音信息经过压缩处理后放上网站服务器,由视频服务器向用户计算机顺序或实时地传送各个压缩包，让用户一边下载一边观看、收听，而不要等整个压缩文件下载到自己的计算机上才可以观看的网络传输技术。该技术先在使用者端的计算机上创建一个缓冲区，客户端在播放前并不需要下载整个媒体⽂文件，而是在将缓存区中已经收到的媒体数据进⾏行播放。同时，媒体流的剩余部分仍持续不断地从服务器递送到客户端，即所谓的“边下载，边播放”。
 
-这种方式应用于视频点播还可以，用于直播的话实时性较差，延迟也很高，于是，苹果公司又在 HTTP 协议的基础上推出了 HTTP Live Streaming（简称 HLS）这个流媒体传输协议。
+
+
+## 流媒体系统的组成
+
+通常，组成一个完整的流媒体系统包括以下5个部分:  
+
+- 一种用于创建、捕捉和编辑多媒体数据，形成流媒体格式的编码工具;
+
+- 流媒体数据;
+
+- 一个存放和控制流媒体数据的服务器;
+
+- 要有适合多媒体传输协议甚至是实时传输协议的网络;
+
+- 供客户端浏览流媒体文件的播放器。 
+
+
+
+## 流媒体技术的分类
+
+从传输方式上大致可以分为HTTP渐进式下载、实时流媒体传输、HTTP流式传输三大类。
+
+
+
+### HTTP顺序流(渐进)式传输(Progressive Streaming)
+
+顺序流式传输是顺序下载，在下载文件的同时用户可以观看，但是，用户的观看与服务器上的传输并不是同步进行的，用户是在一段延时后才能看到服务器上传出来的信息，或者说用户看到的总是服务器在若干时间以前传出来的信息。如YouTube、优酷等大型视频网站的点播分发。它的核心区别是媒体文件不分片，直接以完整文件形态进行分发，通过支持Seek,终端播放器可从没下载完成部分中任意选取一个时间点开始播放，如此来满足不用等整个文件下载完快速播放的需求，一般MP4和FLV格式文件支持较好，打开一个视频拖拽到中部，短暂缓冲即可播放，点击暂停后文件仍将被持续下载就是典型的渐进式下载。在这过程中，客户端需要在硬盘上缓存所有前⾯面已经下载的媒体数据，对本地存储空间的需求较⼤大。播放过程中⽤用户只能在前⾯面已经下载媒体数据的时间范围内进⾏行进度条搜索和快进、快退等操作，而无法在整个媒体⽂文件时间范围内执⾏行这些操作。顺序流式传输比较适合高质量的短片段，因为它可以较好地保证节目播放的最终质量。它适合于在网站上发布的供用户点播的音视频节目。
+
+- 应用场景
+    - 点播型应用
+- 协议
+    - HTTP
+
+
+
+### 实时流式传输(Realtime Streaming)
+
+在实时流式传输中，音视频信息可被实时观看到。
+实时流式传输必须匹配连接宽带，意味着以调制解调器速度连接时图像质量较差，而且由于出错丢失的信息被忽略掉，网络拥挤或者出现问题时候，视频质量很差，如欲保证视频质量，顺序流式传输也许更好，实时流式传输需要特定的服务器，如QuickTime Streaming Server/Real Server/Windows Media  Server这些服务器允许你对媒体发送进行更多级别的控制，因为而系统设置管理比HTTP服务器更复杂，实时流传输还需要特殊的网络协议，比如RTSP(Real time sreming protocol)或MMS(Microsoft Media  Server)这些协议在有防火墙的时候会出现问题，导致用户不能看到一些地点的实时内容。
+
+- 应用场景
+    - 直播型应用。直播服务模式下，用户只能观看播放的内容，无法进行控制。
+    - 会议型应用。会议型应用类似于直播型应用，但是两者有不同的要求，如双向通信等。这对一般双方都要有包括媒体采集的硬件和软件，还有流传输技术。会议型的应用有时候不需要很高的音/视频质量。
+- 协议
+    - RTSP
+    - RTMP
+
+### HTTP流式传输
+
+细分又可以分为: 伪HTTP流和HTTP流。
+
+
+
+**HLS类“伪”HTTP流**：HLS（Apple）、HDS(Adobe)、MSS(Microsoft)  、DASH（MPEG组织）均属于“伪”HTTP流，之所以说他们“伪”，是因为他们在体验上类似“流”，但本质上依然是HTTP文件下载。以上几个协议的原理都一样，就是将媒体数据（文件或者直播信号）进行切割分块，同时建立一个分块对应的索引表，一并存储在HTTP Web服务器中，客户端连续线性的请求这些分块小文件，以HTTP文件方式下载，顺序的进行解码播放，我们就得到了平滑无缝的“流”的体验。
+
+- 协议
+    - HLS
+    - HDS
+    - MSS
+    - DASH
+
+
+
+**HTTP流**: http-flv这样的使用类似RTMP流式协议的HTTP长连接，需由特定流媒体服务器分发的，是真正的HTTP流媒体传输方式，他在延时、首画等体验上跟RTMP等流式协议拥有完全一致的表现，同时继承了部分HTTP的优势。
+
+- 协议
+    - HTTP FLV
+
+- 应用场景
+    - 点播型应用
+    - 直播型应用
+
+
+
+接下来我们以上面传输方式的分类来简单介绍一下。
+
+## 相关协议
+
+### HTTP
+
+
+
+渐进下载流媒体播放采⽤用标准HTTP协议来在Web服务器和客户端之间递送媒体数据。
+
+互联网上最初只能传输一些文本类的数据，自从HTTP协议发明之后，就可以传输超文本的音频视频等等内容，这主要就是靠HTTP协议中的MIME。通过它，浏览器就会根据协议中的Content-Type header去选择相应的应用程序去处理相应的内容。如此，才使得流媒体内容通过HTTP协议传输成为可能。
+
+
+
+基于HTTP渐进式下载的流媒体播放仅能⽀持点播而不能支持直播，媒体流数据到达客户端的速率无法精确控制，客户端仍需维持一个与服务器上媒体文件同样大小的缓冲存储空间，在开始播放之前需要等待一段较长的缓冲时间从而导致实时性较差，播放过程中由于⽹网络带宽的波动或分组丢失可能会导致画面停顿或断续等待。为克服这些问题，需要引入专门的流媒体服务器以及相应的实时流媒体传输和控制协议来进行支持。所以就出现了接下来实时流媒体协议。RTSP/RTP实际上由一组在IETF 中标准化的协议所组成，包括RTSP (实时流媒体会话协议)，SDP(会话描述协议)，RTP (实时传输协议)，以及针对不同编解码标准的RTP净载格式等，共同协作来构成⼀一个流媒体协议栈。基于该协议栈的扩展已被 ISMA (互联⽹网流媒体联盟) 和 3GPP (第三代合作伙伴计划) 等组织采纳成为互联⽹网和 3G 移动互联⽹网的流媒体标准。
+
+
+
+4.分析与⽐比较作为最简单和原始的流媒体解决⽅方案，HTTP 渐进式下载唯⼀一显著的优点在于它仅需要维护⼀一个标准的 Web 服务器，⽽而这样的服务器基础设施在互联⽹网中已经普遍存在，其安装和维护的⼯工作量和复杂性⽐比起专门的流媒体服务器来说要简单和容易得多。然⽽而其缺点和不⾜足却也很多，⾸首先是仅适⽤用于点播⽽而不⽀支持直播，其次是缺乏灵活的会话控制功能和智能的流量调节机制，再次是客户端需要硬盘空间以缓存整个⽂文件⽽而不适合于移动设备等。基于 RTSP/RTP 的流媒体系统专门针对⼤大规模流媒体直播和点播等应⽤用⽽而设计，需要专门的流媒体服务器⽀支持，与 HTTP 渐进下载相⽐比主要具有如下优势：•流媒体播放的实时性。与 HTTP 渐进下载客户端需要先缓冲⼀一定数量媒体数据才能开始播放不同，基于 RTSP/RTP 的流媒体客户端⼏几乎在接收到第⼀一帧媒体数据的同时就可以启动播放。•⽀支持进度条搜索、快进、快退等⾼高级 VCR 控制功能。•平滑、流畅的⾳音视频播放体验。在基于 RTSP 的流媒体会话期间，客户端与服务器之间始终保持会话联系，服务器能够对来⾃自客户端的反馈信息动态做出响应。当因⽹网络拥塞等原因导致可⽤用带宽不⾜足时，服务器可通过适当降低帧率等⽅方式来智能调整发送速率。此外，UDP 传输协议的使⽤用使得客户端在检测到有丢包发⽣生时，可选择让服务器仅选择性地重传部分重要的数据（如关键帧），⽽而忽略其他优先级较低的数据，从⽽而保证在⽹网络不好的情况下客户端也仍能连续、流畅地进⾏行播放。尽管如此，基于 RTSP/RTP 的流媒体系统在实际的应⽤用部署特别是移动互联⽹网应⽤用中仍然遇到了不少问题，主要体现在：•与 Web 服务器相⽐比，流媒体服务器的安装、配置和维护都较为复杂，特别是对于已经建有 CDN（内容分发⽹网络）等基础设施的运营商来说，重新安装配置⽀支持RTSP/RTP 的流媒体服务器⼯工作量很⼤大。
+
+
+
+
+
+### RTSP
+
+#### RTP
+
+实时传输协议(Real-time Transport Protocol):是用于Internet上针对多媒体数据流的一种传输层协议，用于实际承载媒体数据并为具有实时特性的媒体数据交互提供端到端的传输服务，例如净载类型识别、序列号、时间戳和传输监控等。RTP是真正的实时传输协议，客户端仅需要维持一个很⼩小的解码缓冲区⽤于缓存视频解码所需的少数参考帧数据，从⽽⼤大缩短了起始播放时延，通常可控制在1秒之内。应⽤用程序通常选择在UDP之上来运⾏行RTP协议，以便利用UDP的复用和校验和等功能，并提高网络传输的有效吞吐量。当因为网络拥塞而发⽣RTP丢包时，服务器可以根据媒体编码特性智能的进行选择性重传，故意丢弃一些不重要的数据包；客户端也可以不必等待未按时到达的数据⽽继续向前播放，从⽽保证媒体播放的流畅性。
+
+#### RTCP
+
+Real-time Transport Control Protocol或RTP Control Protocol实时传输控制协议，是实时传输协议（RTP）的一个姐妹协议。RTCP为RTP媒体流提供信道外(out-of-band)控制。RTCP本身并不传输数据，但和RTP一起协作将多媒体数据打包和发送。RTCP定期在流多媒体会话参加者之间传输控制数据，它的主要功能是收集相关媒体链接的统计信息，并为RTP所提供的服务质量提供反馈。
+
+RTCP收集相关媒体连接的统计信息，例如：传输字节数，传输分组数，丢失分组数，jitter，单向和双向网络延迟等等。网络应用程序可以利用RTCP所提供的信息试图提高服务质量，比如限制信息流量或改用压缩比较小的编解码器。
+
+#### RTSP
+
+Real Time Streaming Protocol(实时流传输协议):由哥伦比亚大学、网景和Real Networks公司提交，是一种基于文本的应用层协议，在语法及一些消息参数等方面，RTSP协议与HTTP协议类似。⽤来建立和控制⼀一个或多个时间同步的连续⾳视频媒体流的会话协议。通过在客户机和服务器之间传递 RTSP 会话命令，可以完成诸如请求播放、开始、暂停、查找、快进和快退等VCR控制操作。RTSP 在体系结构上位于RTP和RTCP之上，它使用TCP或UDP完成数据传输。使用RTSP时，客户机和服务器都可以发出请求，即RTSP可以是双向的。允许同时多个串流需求控制，除了可以降低服务器端的网络用量，更进而支持多方视讯会议（Video Conference）。 
+
+
+
+RTSP在安防领域有广泛应用,一般传输的是ts/mp4格式的流。
+
+-  优点: 
+    - 延迟低，一般都能够做到500ms
+    - 带宽好，时效率高
+    - 倍速播放，主要是回放的时候提供的功能
+    - 控制精准，任意选择播放点
+- 缺点
+    - 服务端实现复杂
+    - 代理服务器弱：数量少，优化少
+    - 无路由器防火墙穿透
+    - 管流分离：需要1-3个通道
+
+#### SDP
+
+SDP协议⽤用来描述多媒体会话。SDP协议的主要作⽤用在于公告⼀一个多媒体会话中所有媒体流的相关描述信息，以使得接收者能够感知这些描述信息并根据这些描述参与到这个会话中来。SDP会话描述信息通常是通过 RTSP 命令交互来进⾏行传递的，其中携带的媒体类信息主要包括: 
+
+- 媒体的类型(视频，⾳音频等)
+
+- 传输协议(RTP/UDP/IP，RTP/TCP/IP 等)
+
+- 媒体编码格式(H.264 视频，AVS 视频等)
+
+- 流媒体服务器接收媒体流的IP地址和端⼝号
+
+    
+
+一次基本的RTSP操作过程是: 
+
+- 首先，客户端连接到流服务器并发送一个RTSP描述命令（DESCRIBE）。
+- 流服务器通过一个SDP描述来进行反馈，反馈信息包括流数量、媒体类型等信息。
+- 客户端再分析该SDP描述，并为会话中的每一个流发送一个RTSP建立命令(SETUP)，RTSP建立命令告诉服务器客户端用于接收媒体数据的端口。
+- 流媒体连接建立完成后，客户端发送一个播放命令(PLAY)，服务器就开始在UDP上传送媒体流（RTP包）到客户端。 
+- 在播放过程中客户端还可以向服务器发送命令来控制快进、快退和暂停等。
+- 最后，客户端可发送一个终止命令(TERADOWN)来结束流媒体会话
+
+#### RTSP协议与HTTP协议区别
+
+- RTSP引入了几种新的方法，比如DESCRIBE、PLAY、SETUP 等，并且有不同的协议标识符，RTSP为rtsp 1.0,HTTP为http 1.1；
+
+- HTTP是无状态的协议，而RTSP为每个会话保持状态；
+
+- RTSP协议的客户端和服务器端都可以发送Request请求，而在HTTPF协议中，只有客户端能发送Request请求。
+
+- 在RTSP协议中，载荷数据一般是通过带外方式来传送的(除了交织的情况)，及通过RTP协议在不同的通道中来传送载荷数据。而HTTP协议的载荷数据都是通过带内方式传送的，比如请求的网页数据是在回应的消息体中携带的。
+
+- 使用ISO10646(UTF-8) 而不是ISO 8859-1，以配合当前HTML的国际化；
+
+- RTSP使用URI请求时包含绝对URI。而由于历史原因造成的向后兼容性问题，HTTP/1.1只在请求中包含绝对路径，把主机名放入单独的标题域中；
+
+
+
+#### RTSP和RTP的关系
+
+RTP不象http和ftp可完整的下载整个影视文件，它是以固定的数据率在网络上发送数据，客户端也是按照这种速度观看影视文件，当影视画面播放过后，就不可以再重复播放，除非重新向服务器端要求数据
+
+RTSP与RTP最大的区别在于：RTSP是一种双向实时数据传输协议，是纯粹的传输控制协议，它允许客户端向服务器端发送请求，如回放、快进、倒退等操作。当然，RTSP可基于RTP来传送数据，还可以选择TCP、UDP、组播UDP等通道来发送数据，具有很好的扩展性。
+
+
+
+
+
+![img](https://img-blog.csdn.net/20130925235918343?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvdHR0eWQ=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
 
 
 
-RTP
----
 
-`Real-time Transport Protocol`(实时传输协议):是一种网络传输协议，运行在`UDP` 协议之上，`RTP`协议详细说明了在互联网上传递音频和视频的标准数据包格式。`RTP`协议常用于流媒体系统（配合`RTSP`协议）。
 
-RTCP
----
-`Real-time Transport Control Protocol`或`RTP Control Protocol`或简写`RTCP`，实时传输控制协议，是实时传输协议（`RTP`）的一个姐妹协议。`RTCP`为`RTP`媒体流提供信道外(`out-of-band`)控制。`RTCP`本身并不传输数据，但和`RTP`一起协作将多媒体数据打包和发送。`RTCP` 定期在流多媒体会话参加者之间传输控制数据。`RTCP`的主要功能是为`RTP`所提供的服务质量（`Quality of Service`）提供反馈。
 
-RTSP
----
-`Real Time Streaming Protocol`(实时流传输协议实时流传输协议):是用来控制声音或影像的多媒体串流协议，`RTSP`提供了一个可扩展框架，使实时数据，如音频与视频的受控、点播成为可能。该协议定义了一对多应用程序如何有效地通过`IP`网络传送多媒体数据。`RTSP` 在体系结构上位于`RTP`和`RTCP`之上，它使用`TCP`或`UDP`完成数据传输。使用`RTSP`时，客户机和服务器都可以发出请求，即`RTSP`可以是双向的。
-`RTSP`与`RTP`最大的区别在于：`RTSP`是一种双向实时数据传输协议，它允许客户端向服务器端发送请求，如回放、快进、倒退等操作。当然，`RTSP`可基于`RTP`来传送数据，还可以选择`TCP`、`UDP`、组播`UDP`等通道来发送数据，具有很好的扩展性。它时一种类似与`http`协议的网络应用层协议。
 
 RTMP
 ---
-`Real Time Messaging Protocol`(实时消息传送协议):是`Adobe Systems`公司为`Flash`播放器和服务器之间音频、视频和数据传输开发的开放协议。协议基于`TCP`，是一个协议族(默认端口1935)，包括`RTMP`基本协议及`RTMPT/RTMPS/RTMPE`等多种变种。`RTMP` 是一种设计用来进行实时数据通信的网络协议，主要用来在`Flash/AIR`平台和支持`RTMP`协议的流媒体/交互服务器之间进行音视频和数据通信。市面上绝大部分PC秀场使用的都是它，他有低延迟(2s左右)、稳定性高、技术完善、高支持度、编码兼容性高等特点。但是RTMP协议不使用标准的HTTP接口传输数据(TCP、UDP端口)，所以在一些特殊的网络环境下可能被防火墙屏蔽掉。
 
-RTMP的整体流程为:  
+Real Time Messaging Protocol(实时消息传送协议)基于FLV格式进行开发，是Adobe公司为Flash播放器和服务器之间音频、视频和数据传输开发的一种应用层的协议，用来解决多媒体数据传输流的多路复用（Multiplexing）和分包（packetizing）的问题。在基于传输层协议的链接建立完成后，RTMP协议也要客户端和服务器通过“握手”来建立基于传输层链接之上的RTMP Connection链接。协议基于TCP，是一个协议族(默认端口1935)，包括RTMP基本协议及RTMPT/RTMPS/RTMPE等多种变种。市面上绝大部分PC秀场使用的都是它，他有低延迟(2s左右)、稳定性高、技术完善、高支持度、编码兼容性高等特点。但是RTMP协议不使用标准的HTTP接口传输数据(TCP、UDP端口)，所以在一些特殊的网络环境下可能被防火墙屏蔽掉。
 
-视频采集器 -> 支持RTMP的视频编码器 -> 网络传输  -> 流媒体服务器 -> 网络 -> 客户端
+使用RTMP技术的流媒体系统有一个非常明显的特点：使用 Flash Player作为播放器客户端，而Flash Player 现在已经安装在了全世界将近99%的PC上，因此一般情况下收看RTMP流媒体系统的视音频是不需要安装插件的。用户只需要打开网页，就可以直接收看流媒体，十分方便。
 
+采用RTMP协议时，从采集推流端到流媒体服务器再到播放端是一条数据流，因此在服务器不会有落地文件。这样RTMP相对来说就有这些优点：
 
-FLV
----
-`Flash Video`:是Adobe公司推出的另一种视频格式，是一种在网络上传输的流媒体数据存储容器格式。其格式相对简单轻量，不需要很大的媒体头部信息。整个FLV由Header和Body以及其他Tag组成。因此加载速度极快。它是基于HTTP/80传输，可以避免被防火墙拦截的问题，除此之外，它可以通过 HTTP 302 跳转灵活调度/负载均衡，支持使用 HTTPS 加密传输，也能够兼容支持 Android，iOS 的移动端。但是由于它的传输特性，会让流媒体资源缓存在本地客户端，在保密性方面不够好，因为网络流量较大，它也不适合做拉流协议。
+- 实时性高：一般能做到3秒内。
+- 基于 TCP 长连接，不需要多次建连。
 
-HDS
+缺点就是:很多防火墙会墙掉RTMP，但是不会墙掉HTTP。 
+
+
+
+Flash Video:是Adobe公司推出的另一种视频格式，是一种在网络上传输的流媒体数据存储容器格式。其格式相对简单轻量，不需要很大的媒体头部信息。整个FLV由Header和Body以及其他Tag组成。因此加载速度极快。
+
+
+
+
+HTTP FLV
 ---
-`HTTP Dynamic Streaming`:是Adobe公司的传统流媒体解决方案RTMP+FLV的组合。
+类似RTMP流式协议的HTTP长连接，需由特定流媒体服务器分发的，是真正的HTTP流媒体传输方式，他在延时、首画等体验上跟RTMP等流式协议拥有完全一致的表现，同时继承了部分HTTP的优势。
+
+http+flv ，将音视频数据封装成FLV格式，然后通过HTTP协议传输给客户端。http_flv&rtmp这两个协议实际上传输数据是一样的，数据都是flv文件的tag。
+
+
+
+ HTTP协议中有个约定：content-length字段，用于描述HTTP消息实体的传输长度。服务器回复http请求的时候如果有这个字段，客户端就接收这个长度的数据然后就认为数据传输完成了，如果服务器回复http请求中没有这个字段，客户端就一直接收数据，直到服务器跟客户端的socket连接断开。http-flv直播就是利用第二个原理，服务器回复客户端请求的时候不加content-length字段，在回复了http内容之后，紧接着发送flv数据，客户端就一直接收数据了，http-flv这种流，服务器是不可能预先知道内容大小的，这时就可以使用Transfer-Encoding：chunk模式来传输数据了。
+
+ 相比RTMP，HTTP-FLV会生成一个非常大的http流，只能做拉流，RTMP可以做推流/拉流.
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/vs_no_background1.png)
+
+
+
+常用的流媒体协议主要有HTTP渐进式下载和基于RTSP/RTP的实时流媒体协议栈等等，这些流媒体协议⼤大多数可以平移到移动流媒体中继续应⽤用。然⽽而由于移动互联⽹网及其终端设备的⼀一些独有特性，传统流媒体协议在移动互联⽹网中的应⽤用在功能、性能的提供和⽤用户体验等⽅方⾯面都会受到不同程度的约束和限制，于是一些新的流媒体协议应运⽽而⽣生。例如，苹果公司的 HTTP Live Streaming 就是其中具有代表性且得到较为⼴广泛应⽤用的一个。 但是HLS（Apple）、HDS(Adobe)、MSS(Microsoft)  、DASH（MPEG组织）均属于“伪”HTTP流，之所以说他们“伪”，是因为他们在体验上类似“流”，但本质上依然是HTTP文件下载。以上几个协议的原理都一样，就是将媒体数据（文件或者直播信号）进行切割分块，同时建立一个分块对应的索引表，一并存储在HTTP Web服务器中，客户端连续线性的请求这些分块小文件，以HTTP文件方式下载，顺序的进行解码播放，我们就得到了平滑无缝的“流”的体验。
+
+
+
+•RTSP/RTP 协议栈的逻辑实现较为复杂，与 HTTP 相⽐比⽀支持 RTSP/RTP 的客户端软硬件实现难度较⼤大，特别是对于嵌⼊入式移动设备终端来说。•RT S P  协议使⽤用的⽹网络端⼜⼝口号(554)可能被部分⽤用户⽹网络中的防⽕火墙和NAT等封堵，导致⽆无法使⽤用。虽然有些流媒体服务器可通过隧道⽅方式将 RTSP 配置在HTTP 的 80 端⼜⼝口上承载，但实际部署起来并不是特别⽅方便。HTTP Live Streaming 正是为了解决这些问题应运⽽而⽣生的，其主要特点是：放弃专门的流媒体服务器，⽽而返回到使⽤用标准的 Web 服务器来递送媒体数据；将容量巨⼤大的连续媒体数据进⾏行分段，分割为数量众多的⼩小⽂文件进⾏行传递，迎合了 Web 服务器的⽂文件传输特性；采⽤用了⼀一个不断更新的轻量级索引⽂文件来控制分割后⼩小媒体⽂文件的下载和播放，可同时⽀支持直播和点播，以及 VCR 类会话控制操作。HTTP 协议的使⽤用降低了HTTP Live Streaming 系统的部署难度，同时也简化了客户端（特别是嵌⼊入式移动终端）软件的开发复杂度。此外，⽂文件分割和索引⽂文件的引⼊入也使得带宽⾃自适应的流间切换、服务器故障保护和媒体加密等变得更加⽅方便。与 RTSP/RTP 相⽐比，HTTP Live Streaming 的最⼤大缺点在于它并⾮非⼀一个真正的实时流媒体系统，在服务器和客户端都存在⼀一定的起始延迟。
+
+
 
 
 HLS
 ---
-`HTTP Live Streaming`:是苹果公司实现的基于`HTTP`的流媒体传输协议，可实现流媒体的直播和点播，主要应用在`IOS`系统，为`IOS`设备提供音视频直播和点播方案。`HLS`点播，基本上就是常见的分段`HTTP`点播，不同在于，它的分段非常小。相对于常见的流媒体直播协议，例如`RTMP`协议、`RTSP`协议、`MMS`协议等，`HLS`直播最大的不同在于，直播客户端获取到的，并不是一个完整的数据流。`HLS`协议在服务器端将
-直播数据流存储为连续的、很短时长的媒体文件（`MPEG-TS`格式），而客户端则不断的下载并播放这些小文件。因为服务器端总是会将最新的直播数据生成新的小文件，这样客户端只要不停的按顺序播放从服务器获取到的文件，就实现了直播。由此可见，基本上可以认为，`HLS`是以点播的技术方式来实现直播。由于数据通过`HTTP`协议传输，所以完全不用考虑防火墙或者代理的问题，而且分段文件的时长很短，客户端可以很快的选择和切换码率，以适应不同带宽条件下的播放。不过`HLS`的这种技术特点，决定了它的延迟一般总是会高于普通的流媒体直播协议。它也解决了RTMP协议存在的一些问题，例如RTMP协议不使用标准的HTTP接口传输数据(TCP、UDP端口)，所以在一些特殊的网络环境下可能被防火墙屏蔽掉，而HLS使用的是HTTP协议传输数据(80端口)，不会遇到被防火墙屏蔽的情况。
+HTTP Live Streaming:是苹果公司实现的基于HTTP的流媒体传输协议，可实现流媒体的直播和点播，HLS点播，基本上就是常见的分段HTTP点播，不同在于，它的分段非常小。相对于常见的流媒体直播协议，例如RTMP协议、RTSP协议等，HLS直播最大的不同在于，直播客户端获取到的，并不是一个完整的数据流。HLS协议在服务器端将直播数据流存储为连续的、很短时长的媒体文件（MPEG-TS格式），而客户端则不断的下载并播放这些小文件。因为服务器端总是会将最新的直播数据生成新的小文件，这样客户端只要不停的按顺序播放从服务器获取到的文件，就实现了直播。由此可见，基本上可以认为，HLS是以点播的技术方式来实现直播。由于数据通过HTTP协议传输，所以完全不用考虑防火墙或者代理的问题，而且分段文件的时长很短，客户端可以很快的选择和切换码率，以适应不同带宽条件下的播放。不过HLS的这种技术特点，决定了它的延迟一般总是会高于普通的流媒体直播协议。它也解决了RTMP协议存在的一些问题，例如RTMP协议不使用标准的HTTP接口传输数据(TCP、UDP端口)，所以在一些特殊的网络环境下可能被防火墙屏蔽掉，而HLS使用的是HTTP协议传输数据(80端口)，不会遇到被防火墙屏蔽的情况。
+
+HLS相比于http-flv的优点就是不需要任何插件，html5可以直播播放，safari，EDGE等浏览器都可以直接播放HLS的视频流。
+
+HLS requires that video is packaged in the M2TS transport stream; a  format that was designed for broadcast TV rather than for streaming  content over the internet. Conversely, both DASH and SmoothStreaming use the fragmented MP4 (fMP4) container format, which was designed  specifically with streaming content over the internet in mind. M2TS has  many inherent disadvantages compared to fMP4, both for servers and  clients, some of which are summarized by Timothy Siglin’s excellent [white paper](http://download.kennisportal.com/KP/Adobe/UnifyingGlobalVideoStrategies.pdf).
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/hls_suport_use.png)
+
+
 
 在开始一个流媒体会话时，客户端会下载一个包含元数据的extended M3U(m3u8) playlist文件，用于寻找可用的媒体流(将视频分为一个个视频小分片，然后用m3u8索引表进行管理，由于客户端下载到的视频都是5-10秒的完整数据，所以视频的流畅性很好，但是同样也引入了很大的延迟(一般延迟在10-30s左右))。
 
 上面提到了m3u8，那m3u8构成是？直播中m3u8、ts如何实时更新？      
 
 - 是一个索引地址/播放列表，通过FFmpeg将本地的xxx.mp4进行切片处理，生成m3u8播放列表（索引文件）和N多个 .ts文件，并将其（m3u8、N个ts）放置在本地搭建好的webServer服务器的指定目录下，我就可以得到一个可以实时播放的网址，我们把这个m3u8地址复制到 VLC 上就可以实时观看！
-在 HLS 流下，本地视频被分割成一个一个的小切片，一般10秒一个，这些个小切片被 m3u8管理，并且随着终端的FFmpeg 向本地拉流的命令而实时更新，影片进度随着拉流的进度而更新，播放过的片段不在本地保存，自动删除，直到该文件播放完毕或停止，ts 切片会相应的被删除，流停止，影片不会立即停止，影片播放会滞后于拉流一段时间
+  在 HLS 流下，本地视频被分割成一个一个的小切片，一般10秒一个，这些个小切片被 m3u8管理，并且随着终端的FFmpeg 向本地拉流的命令而实时更新，影片进度随着拉流的进度而更新，播放过的片段不在本地保存，自动删除，直到该文件播放完毕或停止，ts 切片会相应的被删除，流停止，影片不会立即停止，影片播放会滞后于拉流一段时间
+
+  
 
 HLS的整体流程为:   
 
 视频源文件 -> 服务器(编码器、流分割器) -> 分发器(索引文件、*.ts) -> 传输网络 -> 客户端
 
+
+
 [HLS的详细介绍](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE/HLS.md)
 
 HDS
 ---
-`Http Dynamic Streaming`:是一个由Adobe公司模仿HLS协议提出的另一个基于Http的流媒体传输协议。其模式与HLS类似，也是索引文件和媒体切片文件结合的下载方式，但是又要比HLS协议更复杂。
+`Http Dynamic Streaming`:是一个由Adobe公司模仿HLS协议提出的另一个基于Http的流媒体传输协议(传统流媒体解决方案RTMP+FLV的组合)。其模式与HLS类似，也是索引文件和媒体切片文件结合的下载方式，但是又要比HLS协议更复杂。
+
+Smooth Streaming
+---
+
+微软提供的一套解决方案，是IIS的媒体服务扩张，用于支持基于HTTP的自适应串流，它的文件切片为mp4，索引文件为ism/ismc。
+
+
+
+在基于HTTP提供流媒体的方面，到目前为止已经看到了三种方案，苹果的HLS，Adobe HTTP Dynamic Streaming (HDS)和Microsoft Smooth Streaming (MSS)，当然，各家用的协议，格式会不一样。于是MPEG呼吁大家做到一起，聊聊出一个统一的标准。
+
+
 
 DASH
 ---
 
-DASH(MPEG-DASH)全称为Dynamic Adaptive Streaming over HTTP。是国标标准组MPEG 2014年推出的技术标准，主要目标是形成IP网络承载单一格式的流媒体并提供高效与高质量服务的统一方案，解决多制式传输方案(HTTP Live Streaming, Microsoft Smooth Streaming, HTTP Dynamic Streaming)并存格局下的存储与服务能力浪费、运营高成本与复杂度、系统间互操作弱等问题。       
+DASH(MPEG-DASH)全称为Dynamic Adaptive Streaming over HTTP。是国标标准组MPEG( (Moving Picture Experts Group) 2014年推出的技术标准，主要目标是形成IP网络承载单一格式的流媒体并提供高效与高质量服务的统一方案，解决多制式传输方案(HTTP Live Streaming, Microsoft Smooth Streaming, HTTP Dynamic Streaming)并存格局下的存储与服务能力浪费、运营高成本与复杂度、系统间互操作弱等问题。       
 
-DASH是基于HTTP的动态自适应的比特率流技术，使用的传输协议是TCP(有些老的客户端直播会采用UDP协议直播, 例如YY, 齐齐视频等). 和HLS, HDS技术类似， 都是把视频分割成一小段一小段， 通过HTTP协议进行传输，客户端得到之后进行播放；不同的是MPEG-DASH支持MPEG-2 TS、MP4等多种格式, 可以将视频按照多种编码切割, 下载下来的媒体格式既可以是ts文件也可以是mp4文件, 所以当客户端加载视频时, 按照当前的网速和支持的编码加载相应的视频片段进行播放.          
+DASH是基于HTTP的动态自适应的比特率流技术，使用的传输协议是TCP，也是把视频分割成一小段一小段， 通过HTTP协议进行传输，客户端得到之后进行播放；不同的是MPEG-DASH支持MPEG-2 TS、MP4等多种格式, 可以将视频按照多种编码切割, 下载下来的媒体格式既可以是ts文件也可以是mp4文件, 所以当客户端加载视频时, 按照当前的网速和支持的编码加载相应的视频片段进行播放.          
 
 因为是分片的，客户端可以自由选择需要播放的媒体分片，可以实现`Adaptive Bitrate Streaming`技术，不同画质内容无缝切换，提供更好的播放体验。        
 
@@ -85,16 +302,32 @@ DASH的整个流程:
 
 内容生成服务器(编码模块、封装模块) -> 流媒体服务器(MPD、媒体文件、HTTP服务器) <-> DASH客户端(控制引擎、媒体引擎、HTTP接入容器)
 
+
+
 [DASH详细介绍](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE/DASH.md)
 
 
-Smooth Streaming
----
-微软提供的一套解决方案，是IIS的媒体服务扩张，用于支持基于HTTP的自适应串流，它的文件切片为mp4，索引文件为ism/ismc。
 
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/dash_compare2.png)
 
-***视频编码标准和音频编码标准是`H.264`和`AAC`，这两种标准分别是当今实际应用中编码效率最高的视频标准和音频标准。***
+
+
+![hls_hds_mss_dash](https://raw.githubusercontent.com/CharonChui/Pictures/master/hls_hds_mss_dash.png)
+
+这么多流媒体协议我该选用哪个？需要说明的是，各种流媒体协议都有其生存的理由，比如监控行业、电信行业IPTV就不能没有RTSP，因为这里面所有的监控应用程序太多基于RTSP；比如目前的直播主协议就是RTMP，主要是因为CDN对RTMP支持的最好；再比如Apple终端市场占有率太高，就不能够不去考虑HLS。
+
+ 每一种流媒体协议都有其应用场景，每一种流媒体协议都有其发展的历史原因，每一种流媒体协议都有其自身的优势和不足。所以，我们需要对各种协议的原理、构成、特性都有所了解，才能在自身应用场景中选择出最佳方案。
+
+
+
+参考:  
+
+- [MPEG-DASH vs. Apple HLS vs. Microsoft Smooth Streaming vs. Adobe HDS](https://bitmovin.com/mpeg-dash-vs-apple-hls-vs-microsoft-smooth-streaming-vs-adobe-hds/)
+- [A Survey on Quality of Experience ofHTTP Adaptive Streaming](http://www.comnet.informatik.uni-wuerzburg.de/publikationen/journal-articles/?tx_extbibsonomycsl_publicationlist%5BuserName%5D=uniwue_info3&tx_extbibsonomycsl_publicationlist%5BintraHash%5D=99067f2f003db1689d6ac3880a8e0c22&tx_extbibsonomycsl_publicationlist%5BfileName%5D=jour_126.pdf&tx_extbibsonomycsl_publicationlist%5Baction%5D=download&tx_extbibsonomycsl_publicationlist%5Bcontroller%5D=Document&cHash=92121b0e4d712ba4ccb918e8a1d82c34)
+- [渐进式、HLS、DASH、HDS、RTMP协议](http://www.4u4v.net/liu-mei-ti-xie-yi-hu-lian-wang-shi-pin-fen-fa-xie-yi-jie-shao-jian-jin-shi-hlsdashhdsrtmp-xie-yi.html)
+- [Real-Time Messaging Protocol](https://en.wikipedia.org/wiki/Real-Time_Messaging_Protocol)
+- [HTTP Live Streaming](https://en.wikipedia.org/wiki/HTTP_Live_Streaming)
+- [Streaming Protocols: Everything You Need to Know](https://www.wowza.com/blog/streaming-protocols)
 
 
 
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/FLV.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/FLV.md"
new file mode 100644
index 00000000..a404777d
--- /dev/null
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/FLV.md"
@@ -0,0 +1,21 @@
+FLV
+===
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/VideoDevelopment/MP4\346\240\274\345\274\217\350\257\246\350\247\243.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/MP4\346\240\274\345\274\217\350\257\246\350\247\243.md"
similarity index 57%
rename from "VideoDevelopment/MP4\346\240\274\345\274\217\350\257\246\350\247\243.md"
rename to "VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/MP4\346\240\274\345\274\217\350\257\246\350\247\243.md"
index 9c3c5a97..aa7cef68 100644
--- "a/VideoDevelopment/MP4\346\240\274\345\274\217\350\257\246\350\247\243.md"
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/MP4\346\240\274\345\274\217\350\257\246\350\247\243.md"
@@ -1,7 +1,29 @@
 MP4格式详解
 ===
 
-MP4是一套用于音频、视频信息的压缩编码标准，由国际标准化组织（ISO）和国际电工委员会（IEC）下属的“动态图像专家组”（Moving Picture Experts Group，即MPEG）制定。MPEG-4格式的主要用途在于网上流、光盘、语音发送（视频电话），以及电视广播，是一种常见的多媒体封装格式。
+MP4是一套用于音频、视频信息的压缩编码标准，由国际标准化组织（ISO）和国际电工委员会（IEC）下属的“动态图像专家组”（Moving Picture Experts Group，即MPEG）制定。MP4 实际代表的含义是MPEG-4 Part 14。它只是MPEG标准中的14部分。它主要参考ISO/IEC标准来制定的。MP4主要作用是可以实现快进快放，边下载边播放的效果。MPEG-4格式的主要用途在于网上流、光盘、语音发送（视频电话），以及电视广播，是一种常见的多媒体封装格式。
+
+MP4的格式稍微比FLV复杂一些，它是通过嵌的方式来实现整个数据的携带。换句话说，它的每一段内容，都可以变成一个对象，如果需要播放的话，只要得到相应的对象即可。
+
+
+
+
+
+P4视频文件封装格式是基于QuickTime容器格式定义的，因此参考QuickTime的格式定义对理解MP4文件格式很有帮助。MP4文件格式是一个十分开放的容器，几乎可以用来描述所有的媒体结构，MP4文件中的媒体描述与媒体数据是分开的，并且媒体数据的组织也很自由，不一定要按照时间顺序排列，甚至媒体数据可以直接引用其他文件。同时，MP4也支持流媒体。MP4目前被广泛用于封装h.264视频和AAC音频，是高清视频的代表。
+
+ 
+
+  现在我们就来看看MP4文件格式到底是什么样的。
+
+**1、概述**
+
+  MP4文件中的所有数据都装在box（QuickTime中为atom）中，也就是说MP4文件由若干个box组成，每个box有类型和长度，可以将box理解为一个数据对象块。box中可以包含另一个box，这种box称为container  box。一个MP4文件首先会有且只有一个“ftyp”类型的box，作为MP4格式的标志并包含关于文件的一些信息；之后会有且只有一个“moov”类型的box（Movie Box），它是一种container  box，子box包含了媒体的metadata信息；MP4文件的媒体数据包含在“mdat”类型的box（Midia Data  Box）中，该类型的box也是container  box，可以有多个，也可以没有（当媒体数据全部引用其他文件时），媒体数据的结构由metadata进行描述。
+
+
+
+
+
+
 
 
 MP4文件由若干称为Atom（或称为box）的数据对象组成，每个Atom的起首为四个字节的数据长度（Big Endian）和四个字节的类型标识，数据长度和类型标志都可以扩展，Atom的基本结构是:  
@@ -76,13 +98,48 @@ mvhd定义了整个movie的特性，通常包含媒体无关的信息，例如
 
 #### mdat(media data box)
 
-该box包含于文件层，可以有多个，也可以没有。用来存储媒体数据。
-
+该box包含于文件层，可以有多个，也可以没有。用来存储媒体数据。MP4文件的媒体数据存放在这里。mdat中的数据帧依次存放，每个帧的位置、时间、长度都由moov中的信息指定。 mdat Box 基本上占据了视频大小的 95% 以上，得益于 mp4 边下边播的效果，浏览器获取到了部分 mdat box，就可以进行播放。
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/mp4_stract.jpg?raw=true)
 
 
 
+**普通MP4文件播放时，ftyp与moov box需同时加载完成后，并下载部分mdat box的帧数据后，才能开始播放**。 那对于一些长视频，确实存在文件头过大，从而影响第一帧的加载速度问题。 另外，对于不是很规范的文件，例 `mp4视频文件举例`中moov box基本在文件最后的的MP4文件，还有可能存在视频文件基本下载完成后才能播放的问题。
+
+
+
+
+
+
+
+
+
+
+
+https://blog.csdn.net/qq_19923217/article/details/95049837
+
+
+
+https://www.villainhr.com/page/2017/08/21/%E5%AD%A6%E5%A5%BD%20MP4%EF%BC%8C%E8%AE%A9%E7%9B%B4%E6%92%AD%E6%9B%B4%E7%BB%99%E5%8A%9B#fragmented%20MP4
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/TS.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/TS.md"
new file mode 100644
index 00000000..451f6787
--- /dev/null
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/TS.md"
@@ -0,0 +1,94 @@
+TS
+===
+
+
+
+
+
+https://blog.csdn.net/qq_19923217/article/details/94200971
+
+
+
+
+
+TS 全称是 MPEG2-TS，MPEG2-TS 是一种标准容器格式，传输与存储音视频、节目与系统信息协议数据，广泛应用于数字广播系统，我们日常数字机顶盒接收到的就是 TS（Transport Stream，传输流）流。
+
+首先需要先分辨 TS 传输流中几个基本概念
+
+ES（Elementary Stream）：基本流，直接从编码器出来的数据流，可以是编码过的音频、视频或其他连续码流
+PES（Packetized Elementary Streams）：PES 流是 ES 流经过 PES 打包器处理后形成的数据流，在这个过程中完成了将 ES 流分组、加入包头信息 （PTS、DTS 等）操作。PES 流的基本单位是 PES 包，PES 包由包头和 payload 组成
+PS 流（Program Stream）：节目流，PS 流由 PS 包组成，而一个 PS 包又由若干个 PES 包组成。一个 PS 包由具有同一时间基准的一个或多个 PES 包复合合成。
+TS 流（Transport Stream）：传输流，TS 流由固定长度（188 字节）的 TS 包组成，TS 包是对 PES 包的另一种封装方式，同样由具有同一时间基准的一个或多个 PES 包复合合成。PS 包是不固定长度，而 TS 包为固定长度
+
+
+
+
+
+MPEG-2 标准中，有两种不同的码流可以输出到信号，一种是节目码流（PS Program Stream），一种是传输流（TS Transport Stream）。
+
+PS 流包结构长度可变，一旦某一 PS 包的同步信息丢失，接收机就无法确认下一包的同步位置，导致信息丢失，因此 PS 流适用于合理可靠的媒体，如光盘（DVD），PS 流的后缀名一般为 vob 或 evo。而 TS 传输流不同，TS 流的包结构为固定长度（一般为 188 字节），当传输误码破坏了某一 TS 包的同步信息时，接收机可在固定的位置检测它后面包中的同步信息，从而恢复同步，避免信息丢失，因此 TS 可适用于不太可靠的传输，即地面或卫星传播，TS 流的后缀一般为 ts、mpg、mpeg。
+
+
+
+由于 TS 码流具有较强的抵抗传输误码的能力，因此目前在传输媒体中进行传输的 MPEG-2 码流基本上都采用了 TS
+
+
+
+以电视数字信号为例：
+1) 原始音视频数据经过压缩编码得到基本流 ES 流
+
+生成的 ES 基本流比较大，并且只是 I、P、B 这些视频帧或音频取样信息。
+2) 对 ES 基本流 进行打包生成 PES 流
+
+通过 PES 打包器，首先对 ES 基本流进行分组打包，在每一个包前加上包头就构成了 PES 流的基本单位 —— PES 包，对视频 PES 来说，一般是一帧一个包，音频 PES 一般一个包不超过 64KB。
+
+PES 包头信息中加入了 PTS、DTS 信息，用与音视频的同步。
+3) 同一时间基准的 PES 包经过 TS 复用器生成 TS 传输包
+
+PES 包的长度通常都是远大于 TS 包的长度，一个 PES 包必须由整数个 TS 包来传送，没装满的 TS 包由填充字节填充。PES 包进行 TS 复用时，往往一个 PES 包会分存到多个 TS 包中
+
+将 PES 包内容分配到一系列固定长度的传输包（TS Packet）中。TS 流中 TS 传输包头加入了 PCR（节目参考时钟）与 PSI（节目专用信息），其中 PCR 用于解码器的系统时钟恢复。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/fMP4 vs ts.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/fMP4 vs ts.md"
new file mode 100644
index 00000000..f39c7036
--- /dev/null
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/fMP4 vs ts.md"	
@@ -0,0 +1,98 @@
+# fMP4 vs ts
+
+MP4，全称MPEG-4 Part  14，是一种使用MPEG-4的多媒体电脑档案格式，副档名为.mp4，以储存数码音讯及数码视讯为主。另外，MP4又可理解为MP4播放器，MP4播放器是一种集音频、视频、图片浏览、电子书、收音机等于一体的多功能播放器。TS是日本高清摄像机拍摄下进行的封装格式，先来简要介绍一下什么是MPEG2-TS吧。MPEG2格式大家都通过对DVD的接触而多多少少了解了一些，DVD节目中的MPEG2格式，确切地说是MPEG2-PS，全称是Program Stream，而TS的全称则是Transport  Stream。MPEG2-PS主要应用于存储的具有固定时长的节目，如DVD电影，而MPEG-TS则主要应用于实时传送的节目，比如实时广播的电视节目。这两种格式的主要区别是什么呢？简单地打个比喻说，你将DVD上的VOB文件的前面一截cut掉（或者干脆就是数据损坏），那么就会导致整个文件无法解码了，而电视节目是你任何时候打开电视机都能解码（收看）的，所以，MPEG2-TS格式的特点就是要求从视频流的任一片段开始都是可以独立解码的。
+
+
+
+## fMP4与ts的区别
+
+最主要的就是.ts文件不提供关于时长等信息，你无法在ts文件中去实现音视频的seek操作。fmp4不同于ts，它是提供了时长等信息，可以执行seek到指定位置。
+
+
+
+### 媒体数据与元数据的分离
+
+在mp4格式中，元数据可以和媒体数据很好地分开存储，后者都在mdat box中，而在ts中，诸多es流和header/metadata信息是复用在一起的。（TODO:介绍ts中的metadata信息怎么存储）。 
+元数据的分离允许我们在streaming中先读取各个流的元数据，知道他们的媒体内容的属性（比如不同的视频质量、不同的语言等），从而可以更好地在不同的media data之间做自适应切换。 
+当然，在更实际的应用场景中，比如在dash协议中会直接把这些元数据信息写在mpd中，player可以只读一个mpd就知道各个媒体数据的属性
+
+### 各个Track独立存储
+
+在fmp4中，不仅媒体数据和metadata相互独立的存储，音视频track的数据也可以分开存储，这里的“分开”已经不仅仅局限于box层面的分开，而是真的可以分开存储于不同的目录。在这种情况下，player只需要读一个记录了它们各自存储位置的manifest，即可去对应的位置download它们的分片，只要做好音视频分片之间的同步工作，就可以正常的播放。 
+举个例子，下面是一个dash中常见的mpd： 
+![这里写图片描述](https://www.itdaan.com/imgs/5/4/8/5/76/090fc502224c3e083760a2300d06e866.jpe)
+在这个mpd中我们看到视频的分片都是存储在video/1/这个目录下，而音频分片都存储在audio/und/mp4a/1这个目录下，而player还是可以将它们拼接到一起完成播放。 
+相对地，在streaming TS流时，音视频往往是复用在一起的，以HLS这个应用场景为例的话，server端一定还需要提前将TS切片做好，这样就会带来几个问题： 
+**1. 媒体文件存储成本和媒资管理成本增加** 
+假设server端将video track编码为三个质量级别V1, V2, V3，audio track也被编码为三个质量级别A1, A2,  A3，那么如果利用fmp4格式的特性，我们只需要存储这6份媒体文件，player在播放时再自主组合不同质量级别的音视频track即可。而对于TS，则不得不提前将3x3=9种不同的音视频复用情况对应的媒体文件都存储到server端，平白无故多出三份文件的存储成本。实际中，因为要考虑到大屏端、小屏端、移动端、桌面端、不同语言、不同字幕等各种情况，使用TS而造成的冗余成本将更加可观。同时，存储文件的增加也意味着媒资管理成本的增加。这也是包括Netflix在内的一些公司选择使用fmp4做streaming格式的原因。 
+**2. manifest文件更加复杂** 
+fmp4格式的特性可以确保每一个单独的媒体分片都是可解密可解码的（当然player需要先从moov box中读到它们的编解码等信息），这意味着server端甚至根本不需要真的存储一大堆分片，player可以直接利用byte range  request技术从一个大文件中准确地读出一个分片对应的media data，这也使得对应manifest(mpd)文件可以更加简洁，如下： 
+![这里写图片描述](https://www.itdaan.com/imgs/2/0/5/0/35/0e7a66325da9f454b13b32692004c33d.jpe)
+针对不同语言的音频，都只需要存一个大文件就够了。 
+相对地，在streaming TS流时，不得不在manifest（m3u8）文件中把成百上千个ts分片文件全都老老实实地记录下来。 
+**3.服务器的cache效率会降低** 
+实际的streaming应用场景中，往往需要cdn的支持，经常会被client请求的媒体分片就会存在距离client最近的edge server上。对于fmp4 streaming的情况，因为需要的文件更少，cache命中率也就更高，举个例子：可能某一个audio  track会和其他各种video track组合，那么就可以将这个audio track放在edge server上，而不用每次都跟origin server去请求。 
+相对地，在streaming TS流时，因为每一个音视频组合的都需要以复用文件的形式存储，组合数又非常多，相当于分母大了，edge server就会有很大的几率没有缓存需要的组合而要去向orgin server请求。
+
+### 对Trick-play的支持
+
+所谓Trick-play，就是快进、快退、直接跳到章节起点、慢动作播放这些“花式”播放功能。支持这些功能往往意味着要快速找到播放流中的关键帧，以快进播放为例，如果利用fmp4格式的特点，可以通过只读取每个媒体分片的moof加上mdat的起始（包含了关键帧图像）部分即可，说白了就是通过只显示关键帧的方法达到“快进”的视觉效果。因为fmp4格式中可以保证每一个分片一定是以IDR帧开始的，这就使得上述的方案实现起来非常方便。 
+相对地，在streaming TS流时，没有办法保证关键帧一定在什么位置，所以你可能需要解析一大堆TS packets才能找到关键帧的位置。
+
+### 无缝码流切换
+
+无缝码流切换实现的关键在于：当第一个码流播放结束时，也就是发生切换的时间，第二个码流一定要以关键帧开始播放。在streaming TS流时，因为不能保证每一个TS  chunk一定以关键帧开始，做码流切换时就意味着要同时download两个码流的相应分片，同时解析两个码流，然后找到关键帧对应的位置，才能切换。同时下载、解析两个码流的媒体内容对网络带宽以及设备性能都形成了挑战。而且有意思的是，如果当前网络环境不佳，player想要切换到低码率码流，结果还要在本来就不好的网络环境下同时进行两个码流的下载，可谓是雪上加霜。 
+而在fmp4中，除了保证各个分片一定以IDR帧开始外，还能保证不同码流的分片之间在时间线上是对齐的。而且streaming fmp4流时因为不要求音视频复用存储，也就意味着视频和音频的同步点可以不一样，视频可以全都以GOP边界作为同步点，音频可以都以sync frame作为同步点，这都使得无缝码流切换更简单。 
+TODO:介绍在分片中间进行切换的情况
+
+### 与DRM的集成
+
+所谓DRM即数字版权管理，说白了就是对流进行加密，这东西在国内用的不多，但是在国外可是每一个内容提供商必须要有的东西。和编码标准一样，业界也存在很多DRM方案，为了避免每采用一个新的加密方案就要重新编一个码流，MPEG推出了通用加密（CENC）标准（23001-7 - Common Encryption）。使用这一标准的码流，就可以将一个码流应用于各种不同的DRM方案。在DASH  spec中，也定义了Content Protection字段来对应这种加密方案。 
+
+CENC使用的就是fMP4格式，这是利用了fMP4中音视频可以不复用同时还能提供独立于media data存储的metadata的特点。TS流就享受不了这样的好处了。TODO:介绍TS应用DRM的方法。
+
+
+
+
+
+
+
+MPEG-TS is designed for live streaming of events over DVB, UDP multicast, but also over HTTP.  It divides the stream in elementary streams, which are segmented in small chunks. System information is sent at regular intervals, so the receiver can start playing the stream any time.
+
+MPEG-TS isn't good for streaming files, because it doesn't provide info about the  duration of the movie or song, as well as the points you can seek to.
+
+
+
+## 主要说了以下几点:
+
+- .ts文件不提供关于时长等信息，你无法在ts文件里去实现音视频的seek操作
+- .mp4不同于ts，是提供了时长等信息，可以执行seek到指定位置
+- .ts文件一般用于m3u8中, 或者提供了流媒体基础信息的前提下使用
+- .mp4文件可以在不下载完全媒体文件的前提下进行seek操作;因为其头部记录moov信息(`moov box 中包含编码、分辨率、码率、帧率、时长、音频采样率等等媒体信息`)
+
+
+
+
+
+https://www.itdaan.com/blog/2018/06/09/8e4ec0afb362459fc6abe8112e82a789.html
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/fMP4\346\240\274\345\274\217\350\257\246\350\247\243.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/fMP4\346\240\274\345\274\217\350\257\246\350\247\243.md"
new file mode 100644
index 00000000..232f8b0e
--- /dev/null
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/fMP4\346\240\274\345\274\217\350\257\246\350\247\243.md"
@@ -0,0 +1,58 @@
+fMP4格式详解
+===
+
+MP4文件的基本单元是“box”，这些box既可以包括data，也可以包括metadata。MP4文件标准允许多种方式来组织data box和metadata box。将metadata放在data之前，客户端应用程序可以在播放video/audio之前获得更多的关于video/audio的信息，因此这种方式在大多数的多媒体应用场景都是比较有用的。但是，在流媒体应用场景，不可能预先保存关于整个流数据的metadata信息，因为不可能提前完全知道。而且，预先保存的metadata越少就意味着越少的开销，因此也可以缩短启动时间。
+
+MP4 ISO Base Media文件格式标准允许以fragmented方式组织box，这也就意味着MP4文件可以组织成这样的结构，由一系列的短的metadata/data box对组成，而不是一个长的metadata/data对。Fragmented MP4文件结构如图1所示，图中只给出了两个fragments。
+
+
+fmp4 是基于 MPEG-4 Part 12 的**流媒体格式**。与普通MP4相比：
+
+- fmp4不需要一个 moov Box 来进行 initialization
+- fmp4 的 moov Box 只包含了一些 track 信息
+- fmp4 的 视频/音频 metadata 信息与数据都存在一个个 moof、mdat 中，它是一个流式的封装格式
+
+
+
+![img](https://bitmovin.com/wp-content/uploads/2019/07/image7.png)
+
+https://bitmovin.com/wp-content/uploads/2019/07/image7.png
+
+
+
+
+
+
+
+![](https://upload-images.jianshu.io/upload_images/9570401-03569f6101ecfeea.png?imageMogr2/auto-orient/strip|imageView2/2/w/520)
+
+
+
+Fragmented MP4 以 Fragment 的方式存储视频信息。每个 Fragment 由一个 moof box 和一个 mdat box 组成。
+
+（2）‘mdat’（media data box）
+
+和普通MP4文件的‘mdat’一样，用于存放媒体数据，不同的是普通MP4文件只有一个‘mdat’box，而Fragmented MP4文件中，每个fragment都会有一个‘mdat’类型的box。
+
+（3）‘moof’（movie fragment box）
+
+该类型的box存放的是fragment-level的metadata信息，用于描述所在的fragment。该类型的box在普通的MP4文件中是不存在的，而在Fragmented MP4文件中，每个fragment都会有一个‘moof’类型的box。
+
+一个‘moof’和一个‘mdat’组成Fragmented MP4文件的一个fragment，这个fragment包含一个video track或audio track，并且包含足够的metadata以保证这部分数据可以单独解码。
+
+A fragment consists of a Movie Fragment  Box (moof), which is very similar to a Movie Box (moov). It contains the information about the media streams contained in one single fragment.  E.g. it contains the timestamp information for the 10 seconds of video,  which are stored in the fragment. Each fragment has its own Media Data  (mdat) box. 
+
+
+
+
+
+Fragmented MP4 中的 moov box 只存储文件级别的媒体信息，因此 moov box 的体积比传统的 MP4 中的 moov box 体积要小很多。
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217.md"
new file mode 100644
index 00000000..79860fd7
--- /dev/null
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217.md"
@@ -0,0 +1,195 @@
+视频封装格式
+===
+
+音视频组成
+一个完整的视频文件，包括音频、视频和基础元信息，我们常见的视频文件如mp4、mov、flv、avi、rmvb等视频文件，就是一个容器的封装，里面包含了音频和视频两部分，并且都是通过一些特定的编码算法，进行编码压缩过后的。
+H264、Xvid等就是视频编码格式，MP3、AAC等就是音频编码格式。例如：将一个Xvid视频编码文件和一个MP3音频编码文件按AVI封装标准封装以后，就得到一个AVI后缀的视频文件。
+因此，视频转换需要设置的本质就是
+
+设置需要的视频编码
+设置需要的音频编码
+选择需要的容器封装
+
+一个完整的视频转换设置都至少包括了上面3个步骤。
+
+
+
+编码格式
+音频编码格式
+音频编码格式有如下
+
+AAC
+AMR
+PCM
+ogg(ogg vorbis音频)
+AC3(DVD 专用音频编码)
+DTS(DVD 专用音频编码)
+APE(monkey’s 音频)
+AU(sun 格式)
+WMA
+
+音频编码方案之间音质比较（AAC，MP3，WMA等）结果： AAC+ > MP3PRO > AAC> RealAudio > WMA > MP3
+目前最常见的音频格式有 Mp3、AC-3、ACC，MP3最广泛的支持最多，AC-3是杜比公司的技术，ACC是MPEG-4中的音频标准，ACC是目前比较先进和具有优势的技术。对应入门，知道有这几种最常见的音频格式足以。
+视频编码格式
+视频编码标准有两大系统： MPEG 和ITU-T，国际上制定视频编解码技术的组织有两个，一个是“国际电联（ITU-T）”，它制定的标准有H.261、H.263、H.263+、H.264等，另一个是“国际标准化组织（ISO）”它制定的标准有MPEG-1、MPEG-2、MPEG-4等。
+常见编码格式有：
+
+Xvid(MPEG4)
+H264 （目前最常用编码格式）
+H263
+MPEG1，MPEG2
+AC-1
+RM，RMVB
+H.265（目前用的不够多）
+
+目前最常见的视频编码方式的大致性能排序基本是： MPEG-1/-2 < WMV/7/8 < RM/RMVB < Xvid/Divx < AVC/H.264（由低到高，可能不完全准确）。
+在H.265出来之前，H264是压缩率最高的视频压缩格式，其优势有:
+
+低码率（Low Bit Rate）：和MPEG2和MPEG4 ASP等压缩技术相比，在同等图像质量下，采用H.264技术压缩后的数据量只有MPEG2的1/8，MPEG4的1/3。
+高质量的图象 ：H.264能提供连续、流畅的高质量图象（DVD质量）。
+容错能力强   ：H.264提供了解决在不稳定网络环境下容易发生的丢包等错误的必要工具。
+网络适应性强 ：H.264提供了网络抽象层（Network Abstraction Layer），使得H.264的文件能容易地在不同网络上传输（例如互联网，CDMA，GPRS，WCDMA，CDMA2000等）。
+
+H.264最大的优势是具有很高的数据压缩比率，在同等图像质量的条件下，H.264的压缩比是MPEG-2的2倍以上，是MPEG-4的1.5～2倍。举个例子，原始文件的大小如果为88GB，采用MPEG-2压缩标准压缩后变成3.5GB，压缩比为25∶1，而采用H.264压缩标准压缩后变为879MB，从88GB到879MB，H.264的压缩比达到惊人的102∶1。低码率（Low Bit Rate）对H.264的高的压缩比起到了重要的作用，和MPEG-2和MPEG-4 ASP等压缩技术相比，H.264压缩技术将大大节省用户的下载时间和数据流量收费。尤其值得一提的是，H.264在具有高压缩比的同时还拥有高质量流畅的图像，正因为如此，经过H.264压缩的视频数据，在网络传输过程中所需要的带宽更少，也更加经济。
+目前这些常见的视频编码格式实际上都属于有损压缩，包括H264和H265，也是有损编码，有损编码才能在质量得以保证的前提下得到更高的压缩率和更小体积
+存储封装格式
+目前市面常见的存储封装格式有如下：
+
+AVI (.avi)
+ASF（.asf)
+WMV (.wmv)
+QuickTime ( .mov)
+MPEG (.mpg / .mpeg)
+MP4 (.mp4)
+m2ts （.m2ts / .mts )
+Matroska （.mkv / .mks / .mka )
+RM ( .rm / .rmvb)
+TS/PS
+
+
+
+## 常见格式
+
+
+
+[AVI](https://baike.baidu.com/item/AVI/213655)：微软在90年代初创立的封装标准，是当时为对抗quicktime格式（mov）而推出的，只能支持固定[CBR](https://baike.baidu.com/item/CBR/1022793)[恒定比特率](https://baike.baidu.com/item/恒定比特率/5926922)编码的声音文件。
+
+[FLV](https://baike.baidu.com/item/FLV/6623513)：针对于[h.263](https://baike.baidu.com/item/h.263/2539746)家族的格式。
+
+MKV：万能封装器，有良好的兼容和跨平台性、纠错性，可带 [外挂字幕](https://baike.baidu.com/item/外挂字幕)。
+
+MOV：MOV是Quicktime封装。
+
+MP4：主要应用于mpeg4的封装 。
+
+RM/[RMVB](https://baike.baidu.com/item/RMVB/229903)：Real Video，由[RealNetworks](https://baike.baidu.com/item/RealNetworks/1987003)开发的应用于[rmvb](https://baike.baidu.com/item/rmvb/229903)和rm 。
+
+TS/PS：PS封装只能在HDDVD原版。
+
+[WMV](https://baike.baidu.com/item/WMV/1195900)：微软推出的，作为市场竞争。
+
+
+
+Q:[b]为什么把flv叫做流式文件格式？ 和mp4，avi不是一样都是音视频的容器吗？ 有什么区别？[/b]
+一下是我收集的几种解释,每个人有不同的理解,把这些都看一遍,你会理解的更加清晰
+
+[quote]通常说的流式文件是可以边传边解的，开始不需要整个文件。特点是有文件头信息（这个不是必需的）和中间打包了，可以直接解析分包，而且文件可以任意大小，而不需要通过索引分包。FLV，MPEG，RMVB等都可以直接依次分包解析，而MP4，AVI一定要依赖索引表才行，而且开始就要固定位置好，如果索引表在尾部，还没办法解析。[/quote]
+
+
+[quote]流媒体文件是指多媒体文件边下载可以边观看的文件。而传统的视频文件需下载完成才能观看，而流媒体主要是下载一部分文件到缓存区，然后再从缓存区里面拿数据~而能作为这种流媒体文件的只有经过特殊编码的格式才适合，而flv、rmvb、mov、asf等格式文件才属于流媒体格式文件~[/quote]
+
+[quote]对于HTTP协议，流式文件可以使用HTTP分段下载，由于在前面的先播放，所以可以一边下载一边播放，但是对于容器格式的文件，由于客户端不知道如何对文件解析(必须拿到整个文件才能解析)，所以不能边下载边播放。
+要实现对容器格式的文件的在线播放，必须要服务器支持流式播放接口，例如RTSP协议[/quote]
+
+
+
+
+
+```
+1、mkv：mkv不等同于音频或视频编码格式，它只是为这些进行过音视频编码的数据提供了一个封装的格式，简单的说就是指定音视频数据在文件中如何排列放置。
+MKV最大的特点就是能容纳多种不同类型编码的视频、音频及字幕流，俗称万能媒体容器。
+MKV加入AVI所没有的EDC错误检测代码，这意味着即使是没有下载完毕的MKV文件也可以顺利回放，这些对AVI来说完全是不可想象的。虽然MKV加入了错误检测代码，但由于采用了新的更高效的组织结构，用MKV封装后的电影还是比AVI源文件要小了约1%，这就是说即使加上了多个字幕，MKV文件的体积也不可能比AVI文件大。
+MKV支持可变帧率，它可在动态画面中使用较大的帧率，而在静态画面中使用较小的帧率，这样可以有效的减少视频文件的体积，并改善动态画面的质量。它的作用比目前广泛使用的VBR（可变码率）更为明显。
+
+2、avi   可容纳多种类型的音频和视频流，他的封装格式比较老了，在功能上不能像mkv那样满足更多的需求
+
+3、rmvb  是rm的升级版本，vb代表变比特率，意思是在画面平缓的时候采用低比特率，画面变化剧烈的时候采用高比特率，有效降低文件尺寸，又不影响太多画质。一般来说，一个700MB的 DVDrip 采用平均比特率为450Kbps的压缩率，生成的 RMVB 大小仅为400MB，但是画质并没有太大变化。但是由于编码器的关系，在画质上还是略输于h.264，所以现在压缩高清视频时更偏重于使用mkv封装。
+
+4、mp4   视频MP4格式实际上指的是使用MPEG-4编码格式、或使用MPEG-4衍生出来的编码格式进行编码的文件，比如DivX、XviD、H.263、H.264、 MS MPEG-4 3688 、 Microsoft Video1 、Microsoft RLE，此种文件格式功能不如mkv丰富。
+
+5、flv    FLV文件体积小巧，清晰的FLV视频1分钟在1MB左右，一部电影在100MB左右，是普通视频文件体积的1/3。再加上CPU占有率低、视频质量良好等特点使其在网络上盛行，目前网上的几家著名视频共享网站均采用FLV格式文件提供视频
+
+6、wmv   WMV是微软推出的一种流媒体格式，它是在“同门”的ASF（AdvancedStreamFormat）格式升级延伸来得。在同等视频质量下，WMV格式的文件可以边下载边播放，因此很适合在网上播放和传输。
+可是由于微软本身的局限性其WMV的应用发展并不顺利。第一, WM9是微软的产品它必定要依赖着Windows，Windows 意味着解码部分也要有PC，起码要有PC机的主板。这就大大增加了机顶盒的造价，从而影响了视频广播点播的普及。第二，WMV技术的视频传输延迟非常大，通常要10几秒钟，正是由于这种局限性，目前WMV也仅限于在计算机上浏览WM9视频文件。
+```
+
+
+
+
+
+对于相同的音视频内容，使用三种不同的封装格式，则文件体积从大到小依次为
+
+TS -> MP4 -> FLV
+
+ FLV和MP4封装格式的文件大小基本相等。
+
+例如：对于同一个文件，采用相同的编码设置，封装为不同的格式
+
+[root@localhost ffmpeg-2.1.1]# ffmpeg -i test_wei.flv -t 10 -vcodec libx264 -x264opts keyint=24 -acodec libfaac -r 24 -y output10s.ts
+
+ 
+
+ 
+
+[root@localhost ffmpeg-2.1.1]# ffmpeg -i test_wei.flv -t 10 -vcodec libx264 -x264opts keyint=24 -acodec libfaac -r 24 -y output10s.flv
+
+ 
+
+[root@localhost ffmpeg-2.1.1]# ffmpeg -i test_wei.flv -t 10 -vcodec libx264 -x264opts keyint=24 -acodec libfaac -r 24 -y output10s.mp4
+
+ 
+
+ 
+
+[root@localhost ffmpeg-2.1.1]# ll
+
+-rw-r--r-- 1 root root **1354272** Apr 18 11:06 output10s.flv
+
+-rw-r--r-- 1 root root **1355649** Apr 18 11:07 output10s.mp4
+
+-rw-r--r-- 1 root root **1492156** Apr 18 11:04 output10s.ts
+
+
+
+
+
+## 封装格式与编码方式的对应
+
+
+
+AVI：可用[MPEG-2](https://baike.baidu.com/item/MPEG-2/214322), DIVX, XVID, WMV3, WMV4, WMV9, H.264
+
+WMV：可用WMV3, WMV4, WMV9
+
+RM/[RMVB](https://baike.baidu.com/item/RMVB/229903)：可用RV40, RV50, RV60, RM8, RM9, RM10
+
+MOV：可用MPEG-2, MPEG4-ASP([XVID](https://baike.baidu.com/item/XVID/567063)), H.264
+
+MKV：可用所有[视频编码](https://baike.baidu.com/item/视频编码)方案
+
+
+
+
+
+参考: 
+
+- [Digital container format](https://en.wikipedia.org/wiki/Digital_container_format)
+- [Comparison of video container formats](https://en.wikipedia.org/wiki/Comparison_of_video_container_formats)
+- [**Supported** Video Formats](https://www.encoding.com/formats/)
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file

From 546203d2782b43bf607c2228cddd48dd98e25174 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 11 Jun 2020 20:24:25 +0800
Subject: [PATCH 022/213] add notes

---
 .../DASH.md"                                  |  49 ++-
 .../HLS.md"                                   |  56 ++-
 .../HTTP FLV.md"                              |  25 +-
 .../RTMP.md"                                  | 110 ++++-
 ...22\344\275\223\345\215\217\350\256\256.md" | 413 ++++++++++++++++++
 ...32\344\277\241\345\215\217\350\256\256.md" | 337 --------------
 .../FLV.md"                                   |  82 ++++
 ...74\345\274\217\350\257\246\350\247\243.md" |  38 +-
 .../TS.md"                                    |  48 +-
 .../fMP4 vs ts.md"                            |  30 +-
 ...74\345\274\217\350\257\246\350\247\243.md" |  26 +-
 ...01\350\243\205\346\240\274\345\274\217.md" | 191 +++-----
 12 files changed, 808 insertions(+), 597 deletions(-)
 create mode 100644 "VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256.md"
 delete mode 100644 "VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/\346\265\201\345\252\222\344\275\223\351\200\232\344\277\241\345\215\217\350\256\256.md"

diff --git "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/DASH.md" "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/DASH.md"
index 21743f4a..e96493fa 100644
--- "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/DASH.md"
+++ "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/DASH.md"
@@ -10,6 +10,10 @@ MPEG-DASH是一种自适应比特率流技术，可根据实时网络状况实
 
 ![dash_compare](https://raw.githubusercontent.com/CharonChui/Pictures/master/dash_compare.png)
 
+HLS在16年支持了fmp4，在17年支持了4K。
+
+
+
 ## 思想
 
 ![dash_main_idea](https://raw.githubusercontent.com/CharonChui/Pictures/master/dash_main_idea.png)
@@ -26,8 +30,6 @@ DASH的整个流程:
 
 ![image-20200406164238038](https://raw.githubusercontent.com/CharonChui/Pictures/master/mpd_hierarchical_data.png)
 
-
-
 ```xml
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <MPD id="0564e940-122b-42bb-9d56-98f3def67247" profiles="urn:mpeg:dash:profile:isoff-main:2011" type="static" availabilityStartTime="2016-01-14T09:30:35.000Z" publishTime="2016-01-14T09:31:33.000Z" mediaPresentationDuration="P0Y0M0DT0H2M17.000S" minBufferTime="P0Y0M0DT0H0M1.000S" bitmovin:version="1.6.0" xmlns:ns2="http://www.w3.org/1999/xlink" xmlns="urn:mpeg:dash:schema:mpd:2011" xmlns:bitmovin="http://www.bitmovin.net/mpd/2015">
@@ -60,19 +62,19 @@ DASH中的重要概念
 
 ### Period
 
-MPD文件包含一个或者多个片段(Period)，它表示时间轴上的一段时间，每个片段都有一个起始时间和结束时间，并且包含了一个或者多个适配集合(Adaptation Set)。每个适配集合提供了一个或者多个媒体组件的信息，并包含了多种不同的码率。每个适配集合又是由多个呈现(Representation)组成，每个呈现就是同一个视频的不同特征的版本，如码率、分辨率等特征。由于每个的视频都要被切成固定长度的切片，因此每个呈现包括多个视频切片(Segment)，每个视频切片都有一个URL地址，这样客户端就可以通过这个地址向服务器发送HTTP GET请求获取该片段。同一个Period内，意味着可用的媒体内容及其各个可用码率（Representation）不会发生变更。直播情况下，“可能”需要周期地去服务器更新MPD文件，服务器可能会移除旧的已经过时的Period,或是添加新的Period。新的Period中可能会添加新的可用码率或去掉上一个Period中存在的某些码率(Representation)。
+标注了视频的时长信息，也可以看做是更新mpd文件的最长时长，MPD文件包含一个或者多个片段(Period)，它表示时间轴上的一段时间，每个片段都有一个起始时间和结束时间，并且包含了一个或者多个适配集合(Adaptation Set)。每个适配集合提供了一个或者多个媒体组件的信息，并包含了多种不同的码率。每个适配集合又是由多个呈现(Representation)组成，每个呈现就是同一个视频的不同特征的版本，如码率、分辨率等特征。由于每个的视频都要被切成固定长度的切片，因此每个呈现包括多个视频切片(Segment)，每个视频切片都有一个URL地址，这样客户端就可以通过这个地址向服务器发送HTTP GET请求获取该片段。同一个Period内，意味着可用的媒体内容及其各个可用码率（Representation）不会发生变更。直播情况下，“可能”需要周期地去服务器更新MPD文件，服务器可能会移除旧的已经过时的Period,或是添加新的Period。新的Period中可能会添加新的可用码率或去掉上一个Period中存在的某些码率(Representation)。
 
 ### Adaptation Set
 
- 一个Period由一个或者多个Adaptationset组成。Adaptationset由一组可供切换的不同码率的码流（Representation)组成，这些码流中可能包含一个（ISO profile)或者多个(TS profile)media content components，因为ISO profile的mp4或者fmp4 segment中通常只含有一个视频或者音频内容，而TS profile中的TS segment同时含有视频和音频内容，当同时含有多个media component content时，每个被复用的media content component将被单独描述
+包含了媒体呈现的形式，（视频/音频/字幕）。 一个Period由一个或者多个Adaptationset组成。Adaptationset由一组可供切换的不同码率的码流（Representation)组成，这些码流中可能包含一个（ISO profile)或者多个(TS profile)media content components，因为ISO profile的mp4或者fmp4 segment中通常只含有一个视频或者音频内容，而TS profile中的TS segment同时含有视频和音频内容，当同时含有多个media component content时，每个被复用的media content component将被单独描述
 
 ### Representation
 
-每个Adaptationset包含了一个或者多个Representations,一个Representation包含一个或者多个media streams，每个media stream对应一个media content component。为了适应不同的网络带宽，dash客户端可能会从一个Representation切换到另外一个Representation，如果不支持某个Representation的编码格式，在切换时可以忽略之。
+包含不同的码率、编码方式、帧率信息等。每个Adaptationset包含了一个或者多个Representations,一个Representation包含一个或者多个media streams，每个media stream对应一个media content component。为了适应不同的网络带宽，实际播放的时候，视频会在一个AdaptationSet中的不同Representaiton 之间切换码率，可能会从一个Representation切换到另外一个Representation，会依次请求该Representaiton下不同Segment序列。
 
 ### Segments
 
-Segments可以包含任何媒体数据，关于容器，官方提供了两种建议: ISO base media file format(比如MP4文件格式)和MPEG-2 Transport Stream。
+每一个具体的片段。（1,2,4,6,10s …） Segments可以包含任何媒体数据，关于容器，官方提供了两种建议: ISO base media file format(比如MP4文件格式)和MPEG-2 Transport Stream。
 
 每个Representation会划分为多个Segment。Segment分为4类，其中，最重要的是：Initialization Segment（每个Representation都包含1个Init Seg），Media Segment（每个Representation的媒体内容包含若干Media Seg）
 
@@ -83,6 +85,28 @@ Segments可以包含任何媒体数据，关于容器，官方提供了两种建
 - Subsegment
 
    Segment可能进一步划分为subsegment，每个subsegment由数个Acess Unit组成，Segment index提供了subsegment相对于Segment的字节范围和presentation time range 。客户端可以先下载Segment index。
+   
+   
+   
+   `*_init.mp4`: 初始的mp4文件，相当于视频头，在这个头文件中包含了完整的视频元信息(moov)，具体的可以使用 `MP4Box  -info` 查看。
+   
+   `*.m4s`: 即上面提到的Segments文件，每个m4s仅包含媒体信息 (moof + mdat)，而播放器是不能直接播放这个文件的，需要用支持DASH的播放器从init文件开始播放。
+
+
+
+确切的说，当Adaptation set的属性@segmentAlignment为真（true）时，同一个Adaptation  set中的多个Representation之中的媒体段是对齐的，因此，当从一个Representation  A切换到另一个Representation B时，若Representation  A的第N个媒体段已经下载完成，切换时可直接下载Representation B的第N+1个媒体段。
+
+DASH对媒体段定义了三种方式：
+
+BaseURL：单段表示
+
+SegmentList：段列表
+
+SegmentTemplate：段模板
+
+单段表示是最简单的：每个Representation只有一个媒体段。用BaseURL表示。举例如下：
+
+
 
 ### SAP和无缝切换以及SEEK
 
@@ -139,7 +163,17 @@ Segments可以包含任何媒体数据，关于容器，官方提供了两种建
 - 插入广告: 通常，可以在HLS和DASH的实时流中插入广告。为此，只需交换单个视频块。 DASH为此提供了一种有效的方法：标准化的界面允许有效地插入广告。
 - 快速频道切换: 您可以在各个通道之间切换的速度取决于最大的子段（块）。块越小，通道更改速度越快。正如引言中已经提到的，HLS块通常长约10秒，而DASH块通常长2至4秒。因此，DASH在这方面领先一步。小块还具有降低代码效率的缺点。具有较小块的播放列表必须比具有较大块的播放列表更频繁地更新。这意味着包含较短视频片段的播放列表必须通过HTTP更频繁地更新。
 
+# **结构与编码**
+
+MPEG-DASH支持TS和MP4 / ISO BMFF媒体段。HLS只支持MPEG-2 TS。DASH媒体段通常比HLS短，2至4秒比较常见。DASH不需要特定的编解码器。视频可以使用H264编码，也可以用其他编码，VP9和H265也是比较受欢迎的编码。
 
+一般而言，与HLS相比，DASH可以提供实质上更低的端对端延迟。这对于现场直播的工作流程很重要。此外， MPEG-DASH的基于模板的MPD不需要更新，可以在网络边缘服务器进行缓存，HLS则需要周期性地更新传播多次。
+
+DASH支持索引和基于时间的模版，播放器能够基于公开的时钟，如NTPS，进行同步。这对于多相机的情况下，多个播放器之间同步会比较容易。
+
+# **DRM**
+
+DASH和HLS之间的另一个关键区别是它支持DRM。可是，在DASH中不存在一个单一通用的DRM解决方案。例如，Google的Chrome支持Widevine，而Microsoft的Internet  Explorer支持PlayReady。然而，通过使用MPEG-CENC（MPEG通用加密）结合加密媒体扩展（EME），视频流内容可以仅被加密一次。HLS支持AES-128加密，以及苹果自己的DRM，Fairplay。
 
 
 
@@ -164,10 +198,9 @@ Segments可以包含任何媒体数据，关于容器，官方提供了两种建
 参考:  
 
 - [HLS，MPEG-DASH - What is ABR?](http://telestreamblog.telestream.net/2017/05/what-is-abr/)
-
 - [B站我们为什么使用DASH](https://www.bilibili.com/read/cv855111)
-
 - [Adaptive HTTP Streaming Technologies: HLS vs. DASH](https://strivecast.io/hls-vs-mpeg-dash/)
+- [自适应流媒体传输](https://blog.csdn.net/nonmarking/article/details/86351147)
 
 
 
diff --git "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HLS.md" "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HLS.md"
index acfeaf00..ed214e94 100644
--- "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HLS.md"
+++ "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HLS.md"
@@ -4,7 +4,7 @@
 
 HLS协议规定:  
 
-- 视频的封装格式是ts(16年发布也支持了fMP4)
+- 视频的封装格式是ts(WWDC2016年发布也支持了fMP4)
 - 视频的编码格式为H264、H265、VP9(17年支持H265、VP9)，音频编码格式为MP3、AAC或者AC-3
 - 除了TS视频文件本身，还定义了用来控制播放的m3u8文件(文本文件)
 
@@ -18,6 +18,18 @@ HLS点播，基本上就是常见的分段HTTP点播，不同在于，它的分
 
 
 
+## 使用
+
+- [Google](https://en.wikipedia.org/wiki/Google) added HTTP Live Streaming support in [Android](https://en.wikipedia.org/wiki/Android_(operating_system)) 3.0 (Honeycomb).[[17\]](https://en.wikipedia.org/wiki/HTTP_Live_Streaming#cite_note-17)
+- [HP](https://en.wikipedia.org/wiki/Hewlett-Packard) added HTTP Live Streaming support in [webOS](https://en.wikipedia.org/wiki/Webos) 3.0.5.[[18\]](https://en.wikipedia.org/wiki/HTTP_Live_Streaming#cite_note-18)
+- Microsoft added support for HTTP Live Streaming in EdgeHTML rendering engine in Windows 10 in 2015.[[19\]](https://en.wikipedia.org/wiki/HTTP_Live_Streaming#cite_note-19)
+- Microsoft added support for HTTP Live Streaming in IIS Media Services 4.0.[[20\]](https://en.wikipedia.org/wiki/HTTP_Live_Streaming#cite_note-IISMS4-20)
+- [Yospace](https://en.wikipedia.org/wiki/Yospace) added HTTP Live Streaming support in Yospace HLS Player and SDK for flash version 1.0.[*[citation needed](https://en.wikipedia.org/wiki/Wikipedia:Citation_needed)*]
+- [Sling Media](https://en.wikipedia.org/wiki/Sling_Media) added HTTP Live Streaming support to its [Slingboxes](https://en.wikipedia.org/wiki/Slingbox) and its SlingPlayer apps.[[21\]](https://en.wikipedia.org/wiki/HTTP_Live_Streaming#cite_note-21)
+- In 2014/15, the [BBC](https://en.wikipedia.org/wiki/BBC) introduced HLS-AAC streams for its live internet radio and on-demand audio services, and supports those streams with its [iPlayer Radio](https://en.wikipedia.org/wiki/IPlayer_Radio) clients.[[22\]](https://en.wikipedia.org/wiki/HTTP_Live_Streaming#cite_note-22)
+
+
+
 ### HLS架构
 
 HLS的架构分为三部分：Server，CDN，Client 。即服务器、分发组件和客户端。
@@ -139,6 +151,36 @@ cctv1hd-1585920074000.ts
 
 
 
+#### 直播流 
+
+```xml
+#EXTM3U
+#EXT-X-VERSION:3
+#EXT-X-MEDIA-SEQUENCE:396078
+#EXT-X-TARGETDURATION:10
+#EXTINF:10.000,
+cctv1hd-1591683975000.ts
+#EXTINF:10.000,
+cctv1hd-1591683985000.ts
+#EXTINF:10.000,
+cctv1hd-1591683995000.ts
+#EXTINF:10.000,
+cctv1hd-1591684005000.ts
+#EXTINF:10.000,
+cctv1hd-1591684015000.ts
+#EXTINF:10.000,
+cctv1hd-1591684025000.ts
+```
+
+直播流是没有#EXT-X-ENDLIST标签的，也就是说播放器在播放完一个.ts文件后会向服务器再次发送请求m3u8文件的请求。
+
+live m3u8文件列表需要不断更新，更新规则：
+
+1. 移除一个文件播放列表中靠前的（认为已播放的）文件
+2. 不断更新`EXT-X-MEDIA-SEQUENCE`标签，以**步长为1**进行递增
+
+
+
 
 
 ## HLS 的优势
@@ -150,7 +192,7 @@ cctv1hd-1585920074000.ts
 
 ## HLS 的劣势
 
-- 相比 RTMP 这类长连接协议, 延时较高, 难以用到互动直播场景.HLS 理论延时 = 1 个切片的时长 + 0-1个 td (td 是 EXT-X-TARGETDURATION, 可简单理解为播放器取片的间隔时间) + 0-n 个启动切片(苹果官方建议是请求到 3 个片之后才开始播放) + 播放器最开始请求的片的网络延时(网络连接耗时)。为了追求低延时效果, 可以将切片切的更小, 取片间隔做的更小, 播放器未取到 3 个片就启动播放. 但是, 这些优化方式都会增加 HLS 不稳定和出现错误的风险.通常 HLS 直播延时会达到 20-30s，而高延时对于需要实时互动体验的直播来说是不可接受的。
+- 相比 RTMP 这类长连接协议, 延时较高, 难以用到互动直播场景.HLS 理论延时 = 1 个切片的时长 + 0-1个 td (td 是 EXT-X-TARGETDURATION, 可简单理解为播放器取片的间隔时间) + 0-n 个启动切片(苹果官方建议是请求到 3 个片之后才开始播放) + 播放器最开始请求的片的网络延时(网络连接耗时)。为了追求低延时效果, 可以将切片切的更小, 取片间隔做的更小, 播放器未取到 3 个片就启动播放. 但是, 这些优化方式都会增加 HLS 不稳定和出现错误的风险.通常 HLS 直播延时会达到 20-30s，而高延时对于需要实时互动体验的直播来说是不可接受的。Apple在WWDC2019发布了新的解决方案，可以将延迟从8秒降低到1至2秒。
 - 对于点播服务来说, 由于 TS 切片通常较小, 海量碎片在文件分发, 一致性缓存, 存储等方面都有较大挑战.
 - HLS 基于短连接 HTTP，HTTP 是基于 TCP 的，这就意味着 HLS 需要不断地与服务器建立连接，TCP 每次建立连接时的三次握手、慢启动过程、断开连接时的四次挥手都会产生消耗。
 
@@ -158,6 +200,8 @@ cctv1hd-1585920074000.ts
 
 
 
+#### 测试地址:
+
 CCTV1高清：http://ivi.bupt.edu.cn/hls/cctv1hd.m3u8
 CCTV3高清：http://ivi.bupt.edu.cn/hls/cctv3hd.m3u8
 CCTV5高清：http://ivi.bupt.edu.cn/hls/cctv5hd.m3u8
@@ -166,6 +210,14 @@ CCTV6高清：http://ivi.bupt.edu.cn/hls/cctv6hd.m3u8
 
 
 
+#### 参考:
+
+- [HTTP Live Streaming Overview](https://developer.apple.com/library/archive/documentation/NetworkingInternet/Conceptual/StreamingMediaGuide/Introduction/Introduction.html#//apple_ref/doc/uid/TP40008332-CH1-SW1)
+
+
+
+
+
 
 
 
diff --git "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HTTP FLV.md" "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HTTP FLV.md"
index 2ac14110..0f90bba7 100644
--- "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HTTP FLV.md"	
+++ "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HTTP FLV.md"	
@@ -1,29 +1,21 @@
 HTTP FLV
 ===
 
-先看看HTTP-FLV长成什么样子：http://ip:port/live/livestream.flv，协议头是http,另外”.flv”这个尾巴是它最明显的特征。
-
-HttpFlv 就是 http+flv ，将音视频数据封装成FLV格式，然后通过 HTTP 协议传输给客户端。
-
-
-
-下的直播平台中大部分的主线路使用的都是HTTP-FLV协议，备线路多为RTMP。小编随便在Safari中打开几个直播平台房间，一抓包就不难发现使用HTTP-FLV协议的身影：熊猫、斗鱼、虎牙、B站。
+在说HTTP-FLV之前，我们有必要对FLV adobe 官方标准有个认识，因为HTTP-FLV协议中封装格式使用的是FLV。FLV文件格式标准是写F4V/FLV fileformat spec v10.1的附录E里面的FLVFile Format。
 
 
 
+FLV（Flash  Video）是Adobe公司设计开发的一种流行的流媒体格式，其格式相对简单轻量，不需要很大的媒体头部信息。整个FLV由Header和Body以及其他Tag组成。因此加载速度极快。它是基于HTTP/80传输，可以避免被防火墙拦截的问题，除此之外，它可以通过 HTTP 302 跳转灵活调度/负载均衡，支持使用 HTTPS 加密传输，也能够兼容支持 Android，iOS 的移动端。但是由于它的传输特性，会让流媒体资源缓存在本地客户端，在保密性方面不够好，因为网络流量较大，它也不适合做拉流协议。此外，FLV可以使用Flash Player进行播放，而Flash  Player插件已经安装在绝大部分浏览器上，这使得通过网页播放FLV视频十分容易。FLV封装格式的文件后缀通常为“.flv”。
 
 
-FLV（Flash  Video）是Adobe公司设计开发的一种流行的流媒体格式，由于其视频文件体积轻巧、封装简单等特点，使其很适合在互联网上进行应用。此外，FLV可以使用Flash Player进行播放，而Flash  Player插件已经安装在绝大部分浏览器上，这使得通过网页播放FLV视频十分容易。FLV封装格式的文件后缀通常为“.flv”。
-
-在说HTTP-FLV之前，我们有必要对FLV adobe 官方标准有个认识，因为HTTP-FLV协议中封装格式使用的是FLV。
-
-FLV文件格式标准是写F4V/FLV fileformat spec v10.1的附录E里面的FLVFile Format。
 
+先看看HTTP-FLV长成什么样子：http://ip:port/live/livestream.flv，协议头是http,另外”.flv”这个尾巴是它最明显的特征。
 
+HttpFlv 就是 http+flv ，将音视频数据封装成FLV格式，然后通过 HTTP 协议传输给客户端。
 
-Flash Video`:是Adobe公司推出的另一种视频格式，是一种在网络上传输的流媒体数据存储容器格式。其格式相对简单轻量，不需要很大的媒体头部信息。整个FLV由Header和Body以及其他Tag组成。因此加载速度极快。它是基于HTTP/80传输，可以避免被防火墙拦截的问题，除此之外，它可以通过 HTTP 302 跳转灵活调度/负载均衡，支持使用 HTTPS 加密传输，也能够兼容支持 Android，iOS 的移动端。但是由于它的传输特性，会让流媒体资源缓存在本地客户端，在保密性方面不够好，因为网络流量较大，它也不适合做拉流协议。
 
 
+下的直播平台中大部分的主线路使用的都是HTTP-FLV协议，备线路多为RTMP。小编随便在Safari中打开几个直播平台房间，一抓包就不难发现使用HTTP-FLV协议的身影：熊猫、斗鱼、虎牙、B站。
 
 
 
@@ -37,7 +29,14 @@ HTTP FLV伪流：支持SEEK，可从未下载的部分开始播放。
 
 HTTP-FLV流：拥有和流式协议RTMP一样的特征，长连接，流式数据。
 
+#### 4 优点：
+
+- 服务器兼容性好：基于 HTTP 协议。
+- 低延迟：直接传输 FLV 流，而且基于 HTTP 长链接。
+
+#### 5 缺点：
 
+- 播放端兼容性不好：需要 Flash 支持，不支持多音视频流，不便于 Seek。
 
 ▣  HTTP-FLV技术实现
 
diff --git "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/RTMP.md" "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/RTMP.md"
index e3918a9d..ed3d7a1a 100644
--- "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/RTMP.md"
+++ "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/RTMP.md"
@@ -3,21 +3,123 @@ RTMP
 
 
 
+Real Time Messaging Protocol(实时消息传送协议):是Adobe Systems公司为Flash播放器和服务器之间音频、视频和数据传输开发的开放协议。协议基于`TCP`，是一个协议族(默认端口1935)，包括RTMP基本协议及RTMPT/RTMPS/RTMPE等多种变种。RTMP 是一种设计用来进行实时数据通信的网络协议，主要用来在Flash/AIR平台和支持RTMP协议的流媒体/交互服务器之间进行音视频和数据通信。市面上绝大部分PC秀场使用的都是它，他有低延迟(2s左右)、稳定性高、技术完善、高支持度、编码兼容性高等特点。但是RTMP协议不使用标准的HTTP接口传输数据(TCP、UDP端口)，所以在一些特殊的网络环境下可能被防火墙屏蔽掉。默认端口号：1935
 
+RTMP的整体流程为:  
 
-http://billchan.me/2019/04/27/livestreamprotocol/
+视频采集器 -> 支持RTMP的视频编码器 -> 网络传输  -> 流媒体服务器 -> 网络 -> 客户端
 
 
 
-Real Time Messaging Protocol(实时消息传送协议):是Adobe Systems公司为`Flash`播放器和服务器之间音频、视频和数据传输开发的开放协议。协议基于`TCP`，是一个协议族(默认端口1935)，包括`RTMP`基本协议及`RTMPT/RTMPS/RTMPE`等多种变种。`RTMP` 是一种设计用来进行实时数据通信的网络协议，主要用来在`Flash/AIR`平台和支持`RTMP`协议的流媒体/交互服务器之间进行音视频和数据通信。市面上绝大部分PC秀场使用的都是它，他有低延迟(2s左右)、稳定性高、技术完善、高支持度、编码兼容性高等特点。但是RTMP协议不使用标准的HTTP接口传输数据(TCP、UDP端口)，所以在一些特殊的网络环境下可能被防火墙屏蔽掉。
+#### 2 握手流程：
 
-RTMP的整体流程为:  
+以下为简单握手的流程
 
-视频采集器 -> 支持RTMP的视频编码器 -> 网络传输  -> 流媒体服务器 -> 网络 -> 客户端
+[![Arb6TU.jpg](https://s2.ax1x.com/2019/03/31/Arb6TU.jpg)](https://imgchr.com/i/Arb6TU)
+
+#### 2.1 包格式：
+
+![img](https://upload-images.jianshu.io/upload_images/1720840-23c7fd9d1b1f0fd3.png?imageMogr2/auto-orient/)
+
+#### 2.2 流程说明：
+
+##### Step 1：C0 + C1
+
+`C0 + C1` 一起发送，其中 C0 为 `1` 个字节，固定为 `0x03`，C1 为 `1536` 个字节，所以包总长度为：`1 + 1535 = 1537`。
+
+C0 标记着客户端 RTMP 的版本号，目前用到 RTMP 为第三版，所以为 03。
+
+> In C0, this field identifies the RTMP version requested by the client. In S0, this field identifies the RTMP version selected by the server. **The version defined by this specification is 3**. 0-2 are deprecated values used by earlier proprietary products; 4-31 are reserved for future implementations; 32-255 are not allowed (to allow distinguishing RTMP from text-based protocols, which always start with a printable character).
+
+##### Step 2：S0 + S1 + S2
+
+`S0 + S1 + S2` 一起发送，其中 S0 为 `1` 个字节，固定为 `0x03`，S1 和 S2 都为 `1536` 个字节，所以包总长度为：`1 + 1536 + 1536 = 3073`。
+
+S0 标记着服务端 RTMP 的版本号，目前用到 RTMP 为第三版，所以为 03。
+
+##### Step 3：C2
+
+C2 为 `1536` 个字节，`RTMP Server` 接收到 `C2` 意味着**握手成功结束**。
+
+#### 3 消息格式（Message）
+
+握手成功后当然就是进行消息通讯，在 RTMP 中的消息都是切分块（Chunk）来发消息的，而 Chunk 发送时必须遵循在一个 Chunk 发送完成之后才能开始发送下一个 Chunk，每个 Chunk 中带有 MessageId 来代表属于哪个 Message，接受端也会按照这个  id 来将 Chunk 组装成 Message。
+
+> 为什么 RTMP要将 Message 拆分成不同的 Chunk 呢？
+>
+> 通过拆分数据量较大的 Message 可以被拆分成较小的  Message，这样就可以避免优先级低的消息持续发送阻塞优先级高的数据，比如在视频的传输过程中，会包括视频帧，音频帧和 RTMP  控制信息，如果持续发送音频数据或者控制数据的话可能就会造成视频帧的阻塞，然后就会造成看视频时最烦人的卡顿现象。同时对于数据量较小的  Message，可以通过对 Chunk Header 的字段来压缩信息，从而减少信息的传输量。
+
+Chunk 的默认大小是 128 字节，在传输过程中，通过一个叫做 Set Chunk Size 的控制信息可以设置 Chunk  数据量的最大值，在发送端和接受端会各自维护一个Chunk Size，可以分别设置这个值来改变自己这一方发送的 Chunk 的最大大小。
+
+大一点的 Chunk 减少了计算每个 Chunk 的时间从而减少了 CPU  的占用率，但是它会占用更多的时间在发送上，尤其是在低带宽的网络情况下，很可能会阻塞后面更重要信息的传输。小一点的 Chunk  可以减少这种阻塞问题，但小的 Chunk 会引入过多额外的信息（Chunk 中的  Header），少量多次的传输也可能会造成发送的间断导致不能充分利用高带宽的优势，因此并不适合在高比特率的流中传输。
+
+在实际发送时应对要发送的数据用不同的 Chunk Size 去尝试，通过抓包分析等手段得出合适的 Chunk 大小，并且在传输过程中可以根据当前的带宽信息和实际信息的大小动态调整 Chunk 的大小，从而尽量提高 CPU 的利用率并减少信息的阻塞机率。
+
+#### 3.1 块格式：
+
+![img](https://s2.ax1x.com/2019/04/27/EKy8Fx.png)
+
+#### 3.1.1 Basic Header：
+
+Basic Header 包含两个字段：
+
+- **chunk stream id**（流通道id）：占用字节不固定，一共有 3 种情况( `3 字节 - type`、`2 字节 - type` 或 `1 字节 - type`）。支持用户自定义 `［3，65599］` 之间的 id，其中0，1，2 由协议保留表示特殊信息。
+- **chunk type**（类型）：占用 2 位，固定长度。
+
+Basic Header 的长度可能是 1，2，或 3 个字节，其中 type 的长度是固定的（占 2 位），Basic Header  的长度取决于 id 的大小，在足够存储这两个字段的前提下最好用尽量少的字节从而减少由于引入 Header 增加的数据量，还有 type  决定了后面 Message Header 的格式。
+
+#### 3.1.2 Message Header：
+
+Message Header 有可能包含以下四个字段：
+
+- timestamp（时间戳）：占用 3 个字节，因此它最多能表示到 `16777215=0xFFFFFF=224-1`，当它的值超过这个最大值时，这三个字节都置为1，这样实际的 timestamp 会转存到 Extended Timestamp 字段中，接受端在判断 timestamp 字段 24 个位都为 1  时就会去 Extended timestamp中 解析实际的时间戳。
+- message  length（消息数据的长度）：占用3个字节，表示实际发送的消息的数据如音频帧、视频帧等数据的长度，单位是字节。注意这里是 Message  的长度，也就是 Chunk 属于的 Message 的总数据长度，而不是 Chunk 本身 Data 的数据的长度。
+- message type id（消息的类型id）：占用 1 个字节，表示实际发送的数据的类型，如 8 代表音频数据、9 代表视频数据。
+- message stream id（消息的流id）：占用 4 个字节，表示该 Chunk 所在的流的id
+
+Message Header 的格式和长度取决于 Basic Header 的 type，共有 4 种不同的格式：
+
+##### 当 chunk type = 0 时 ：
+
+Message Header 占用 11 个字节，分别有 timestamp、message length、message type id 和 message stream id。
+
+##### 当 chunk type = 1 时 ：
+
+Message Header 占用 7 个字节，分别有 timestamp、message length 和 message type id。
+
+- 去掉 msg stream id 的 4个字节，表示此 Chunk 和上一次发的 Chunk 所在的流相同，如果在发送端只和对端有一个流链接的时候可以尽量去采取这种格式。
+- timestamp 和 type＝0 时不同，存储的是和上一个 Chunk 的时间差，当它的值超过 3  个字节所能表示的最大值时，3 个字节都置为 1，实际的时间戳差值就会转存到 Extended Timestamp  字段中，接受端在判断timestamp 字段 24 个位都为 1 时就会去 Extended timestamp  中解析时机的与上次时间戳的差值。
+
+##### 当 chunk type = 2 时 ：
+
+Message Header 占用 3 个字节，只有 timestamp，和上一个 Chunk 的时间差。
+
+相对于type＝1 格式又去掉了表示消息长度的 3 个字节和表示消息类型 1 个字节，表示此 Chunk 和上一次发送的 Chunk 所在的流、消息的长度和消息的类型都相同。
+
+##### 当 chunk type = 3 时 ：
+
+Message Header 占用 0 个字节
+
+它表示这个 Chunk 的 Message Header 和上一个是完全相同的。
+
+#### 3.1.3 Extended Timestamp（扩展时间戳）：
+
+上面我们提到在 Chunk 中会有时间戳 timestamp 和时间戳差 timestamp delta，并且它们不会同时存在，只有这两者之一大于 3 个字节能表示的最大数值 `0xFFFFFF＝16777215` 时，才会用这个字段来表示真正的时间戳，否则这个字段为 0。扩展时间戳占 4 个字节，能表示的最大数值就是 `0xFFFFFFFF＝4294967295`。
+
+当扩展时间戳启用时，timestamp 字段或者 timestamp delta  要全置为1，表示应该去扩展时间戳字段来提取真正的时间戳或者时间戳差。注意扩展时间戳存储的是完整值，而不是减去时间戳或者时间戳差的值。(注：这里大概是在讲 extended timestamp 存放的扩展时间戳和扩展时间戳差的区别吧)
+
+#### 3.1.4 Chunk Data：
+
+用户层面上真正想要发送的与协议无关的数据，长度在 (0, chunkSize] 之间。
 
+#### 4 优点：
 
+- 延迟低：1. 从采集推流端到流媒体服务器再到播放端是一条数据流，因此在服务器不会有落地文件。2. 基于 TCP 长连接，不需要多次建连
 
+#### 5 缺点：
 
+- 服务器兼容性差：使用非常规 80 端口，需要额外支持。
+- 播放端兼容性不好：需要 Flash 支持。
 
 
 
diff --git "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256.md" "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256.md"
new file mode 100644
index 00000000..fd8ed21d
--- /dev/null
+++ "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256.md"
@@ -0,0 +1,413 @@
+流媒体协议
+===
+
+
+
+## 流媒体
+
+
+
+流媒体(Streaming Media)又叫流式媒体。是指把连续的影像和声音信息经过压缩处理后放上网站服务器,由视频服务器向用户计算机顺序或实时地传送各个压缩包，让用户一边下载一边观看、收听，而不要等整个压缩文件下载到自己的计算机上才可以观看的网络传输技术。该技术先在使用者端的计算机上创建一个缓冲区，客户端在播放前并不需要下载整个媒体⽂文件，而是在将缓存区中已经收到的媒体数据进⾏行播放。同时，媒体流的剩余部分仍持续不断地从服务器递送到客户端，即所谓的“边下载，边播放”。采用流媒体技术使得数据包得以像流水一样发送, 如果没有流媒体技术, 那么我们就要像以前用迅雷下电影一样, 下载整个影片才能观看。这样我们需要在漫长的等待之后（因为受限于带宽，下载通常要花上较长的时间），才可以看到或听到媒体传达的信息。令人欣慰的是，在流媒体技术出现之后，人们便无需再等待媒体完全下载完成了。
+
+
+
+## 流媒体系统的组成
+
+通常，组成一个完整的流媒体系统包括以下5个部分:  
+
+- 一种用于创建、捕捉和编辑多媒体数据，形成流媒体格式的编码工具;
+
+- 流媒体数据;
+
+- 一个存放和控制流媒体数据的服务器;
+
+- 要有适合多媒体传输协议甚至是实时传输协议的网络;
+
+- 供客户端浏览流媒体文件的播放器。 
+
+
+
+## 流媒体技术的分类
+
+从传输方式上大致可以分为HTTP渐进式下载、实时流媒体传输、HTTP流式传输三大类。
+
+
+
+### HTTP顺序流(渐进)式传输(Progressive Streaming)
+
+顺序流式传输是顺序下载，在下载文件的同时用户可以观看，但是，用户的观看与服务器上的传输并不是同步进行的，用户是在一段延时后才能看到服务器上传出来的信息，或者说用户看到的总是服务器在若干时间以前传出来的信息。如YouTube、优酷等大型视频网站的点播分发。它的核心区别是媒体文件不分片，直接以完整文件形态进行分发，通过支持Seek,终端播放器可从没下载完成部分中任意选取一个时间点开始播放，如此来满足不用等整个文件下载完快速播放的需求，一般MP4和FLV格式文件支持较好，打开一个视频拖拽到中部，短暂缓冲即可播放，点击暂停后文件仍将被持续下载就是典型的渐进式下载。在这过程中，客户端需要在硬盘上缓存所有前⾯已经下载的媒体数据，对本地存储空间的需求较⼤大。播放过程中⽤用户只能在前⾯面已经下载媒体数据的时间范围内进行进度条搜索和快进、快退等操作，而无法在整个媒体文件时间范围内执⾏行这些操作。顺序流式传输比较适合高质量的短片段，因为它可以较好地保证节目播放的最终质量。它适合于在网站上发布的供用户点播的音视频节目。
+
+- 应用场景
+    - 点播型应用
+- 协议
+    - 基于HTTP协议，HTTP协议并不是流媒体协议
+
+
+
+### 实时流式传输(Realtime Streaming)
+
+在实时流式传输中，音视频信息可被实时观看到。
+实时流式传输必须匹配连接宽带，意味着以调制解调器速度连接时图像质量较差，而且由于出错丢失的信息被忽略掉，网络拥挤或者出现问题时候，视频质量很差，如欲保证视频质量，顺序流式传输也许更好，实时流式传输需要特定的服务器，如QuickTime Streaming Server/Real Server/Windows Media  Server这些服务器允许你对媒体发送进行更多级别的控制，因为而系统设置管理比HTTP服务器更复杂，实时流传输还需要特殊的网络协议，比如RTSP(Real time sreming protocol)或MMS(Microsoft Media  Server)这些协议在有防火墙的时候会出现问题，导致用户不能看到一些地点的实时内容。
+
+- 应用场景
+    - 直播型应用。直播服务模式下，用户只能观看播放的内容，无法进行控制。
+    - 会议型应用。会议型应用类似于直播型应用，但是两者有不同的要求，如双向通信等。这对一般双方都要有包括媒体采集的硬件和软件，还有流传输技术。会议型的应用有时候不需要很高的音/视频质量。
+- 协议
+    - RTSP
+    - RTMP
+
+### HTTP流式传输
+
+细分又可以分为: 伪HTTP流和HTTP流。
+
+#### HTTP流
+
+http-flv这样的使用类似RTMP流式协议的HTTP长连接，需由特定流媒体服务器分发的，是真正的HTTP流媒体传输方式，他在延时、首画等体验上跟RTMP等流式协议拥有完全一致的表现，同时继承了部分HTTP的优势。
+
+- 协议
+    - HTTP FLV
+
+- 应用场景
+    - 点播型应用
+    - 直播型应用
+
+
+
+#### HLS类“伪”HTTP流
+
+HLS（Apple）、HDS(Adobe)、MSS(Microsoft)  、DASH（MPEG组织）均属于“伪”HTTP流，之所以说他们“伪”，是因为他们在体验上类似“流”，但本质上依然是HTTP文件下载。以上几个协议的原理都一样，就是将媒体数据（文件或者直播信号）进行切割分块，同时建立一个分块对应的索引表，一并存储在HTTP Web服务器中，客户端连续线性的请求这些分块小文件，以HTTP文件方式下载，顺序的进行解码播放，我们就得到了平滑无缝的“流”的体验。
+
+- 协议
+    - HLS
+    - HDS
+    - MSS
+    - DASH
+
+
+
+接下来我们以上面传输方式的分类来简单介绍一下。
+
+
+
+## 相关协议
+
+### HTTP
+
+渐进下载流媒体播放采⽤用标准HTTP协议来在Web服务器和客户端之间递送媒体数据。
+
+互联网上最初只能传输一些文本类的数据，自从HTTP协议发明之后，就可以传输超文本的音频视频等等内容，这主要就是靠HTTP协议中的MIME。通过它，浏览器就会根据协议中的Content-Type header去选择相应的应用程序去处理相应的内容。如此，才使得流媒体内容通过HTTP协议传输成为可能。
+
+
+
+基于HTTP渐进式下载的流媒体播放仅能⽀持点播而不能支持直播，媒体流数据到达客户端的速率无法精确控制，客户端仍需维持一个与服务器上媒体文件同样大小的缓冲存储空间，在开始播放之前需要等待一段较长的缓冲时间从而导致实时性较差，播放过程中由于⽹网络带宽的波动或分组丢失可能会导致画面停顿或断续等待。为克服这些问题，需要引入专门的流媒体服务器以及相应的实时流媒体传输和控制协议来进行支持。所以就出现了接下来实时流媒体协议。
+
+RTSP/RTP实际上由一组在IETF 中标准化的协议所组成，包括RTSP (实时流媒体会话协议)，SDP(会话描述协议)，RTP (实时传输协议)，以及针对不同编解码标准的RTP净载格式等，共同协作来构成⼀一个流媒体协议栈。基于该协议栈的扩展已被 ISMA (互联⽹网流媒体联盟) 和 3GPP (第三代合作伙伴计划) 等组织采纳成为互联⽹网和 3G 移动互联⽹网的流媒体标准。
+
+
+
+### RTSP
+
+#### RTP
+
+实时传输协议(Real-time Transport Protocol):是用于Internet上针对多媒体数据流的一种传输层协议，用于实际承载媒体数据并为具有实时特性的媒体数据交互提供端到端的传输服务，例如净载类型识别、序列号、时间戳和传输监控等。RTP是真正的实时传输协议，客户端仅需要维持一个很⼩小的解码缓冲区⽤于缓存视频解码所需的少数参考帧数据，从⽽⼤大缩短了起始播放时延，通常可控制在1秒之内。应⽤用程序通常选择在UDP之上来运⾏行RTP协议，以便利用UDP的复用和校验和等功能，并提高网络传输的有效吞吐量。当因为网络拥塞而发⽣RTP丢包时，服务器可以根据媒体编码特性智能的进行选择性重传，故意丢弃一些不重要的数据包；客户端也可以不必等待未按时到达的数据⽽继续向前播放，从⽽保证媒体播放的流畅性。RTP在组建IP网络(managed IP  networks)中有良好的表现。但是，目前网络应用已经基本转移到CDN上，CDN大多数都不支持RTP流；此外，RTP包很容易被防火墙拦截；另外，RTP流要求服务端与每一个客户端都保持独立的长连接，这对服务端负载造成巨大的压力。
+
+#### RTCP
+
+Real-time Transport Control Protocol或RTP Control Protocol实时传输控制协议，是实时传输协议（RTP）的一个姐妹协议。RTCP为RTP媒体流提供信道外(out-of-band)控制。RTCP本身并不传输数据，但和RTP一起协作将多媒体数据打包和发送。RTCP定期在流多媒体会话参加者之间传输控制数据，它的主要功能是收集相关媒体链接的统计信息，并为RTP所提供的服务质量提供反馈。
+
+RTCP收集相关媒体连接的统计信息，例如：传输字节数，传输分组数，丢失分组数，jitter，单向和双向网络延迟等等。网络应用程序可以利用RTCP所提供的信息试图提高服务质量，比如限制信息流量或改用压缩比较小的编解码器。
+
+#### RTSP
+
+Real Time Streaming Protocol(实时流传输协议):由哥伦比亚大学、网景和Real Networks公司提交，是一种基于文本的应用层协议，在语法及一些消息参数等方面，RTSP协议与HTTP协议类似。⽤来建立和控制⼀个或多个时间同步的连续⾳视频媒体流的会话协议。通过在客户机和服务器之间传递RTSP会话命令，可以完成诸如请求播放、开始、暂停、查找、快进和快退等VCR控制操作。RTSP 在体系结构上位于RTP和RTCP之上，它使用TCP或UDP完成数据传输。使用RTSP时，客户机和服务器都可以发出请求，即RTSP可以是双向的。允许同时多个串流需求控制，除了可以降低服务器端的网络用量，更进而支持多方视讯会议（Video Conference）或者安防。
+
+由于安防行业非常多程序都已经是写的RTSP协议支持，要改就要改平台，要么就换支持RTSP协议的设备，那么你做为摄像机厂商，你究竟是支持还是不支持RTSP呢？千千万万的开发商和集成商程序都写好了，默认都是依照你设备支持RTSP的标准做的平台，你设备不支持，就会导致没人买。然后还是要支持RTSP。
+
+
+
+基于 RTSP/RTP 的流媒体系统专门针对大规模流媒体直播和点播等应⽤用⽽设计，需要专门的流媒体服务器支持，与 HTTP 渐进下载相比主要具有如下优势：
+
+- 流媒体播放的实时性。与HTTP渐进下载客户端需要先缓冲一定数量媒体数据才能开始播放不同，基于RTSP/RTP的流媒体客户端几乎在接收到第一帧媒体数据的同时就可以启动播放。
+
+- ⽀持进度条搜索、快进、快退等高级VCR控制功能。
+
+- 平滑、流畅的⾳视频播放体验。
+
+    在基于RTSP的流媒体会话期间，客户端与服务器之间始终保持会话联系，服务器能够对来自客户端的反馈信息动态做出响应。当因⽹络拥塞等原因导致可用带宽不足时，服务器可通过适当降低帧率等⽅式来智能调整发送速率。此外，UDP 传输协议的使用使得客户端在检测到有丢包发生时，可选择让服务器仅选择性地重传部分重要的数据（如关键帧），而忽略其他优先级较低的数据，从而保证在⽹络不好的情况下客户端也仍能连续、流畅地进行播放。
+
+尽管如此，基于RTSP/RTP的流媒体系统在实际的应用部署特别是移动互联⽹应用中仍然遇到了不少问题，主要体现在: 
+
+- 与 Web 服务器相比，流媒体服务器的安装、配置和维护都较为复杂，另外一个方面，目前的CDN都是基于RTMP的，顺势而为吧，特别是对于已经建有CDN内容分发⽹络）等基础设施的运营商来说，重新安装配置支持RTSP/RTP的流媒体服务器⼯作量很大。RTSP+RTP在UDP传输，实际上公网环境下大量的UDP包，容易被防火墙block住。
+- RTSP协议使⽤用的⽹网络端⼜⼝口号(554)可能被部分⽤用户⽹网络中的防⽕火墙和NAT等封堵，导致⽆无法使⽤用。虽然有些流媒体服务器可通过隧道⽅式将RTSP配置在HTTP的80端口上承载，但实际部署起来并不是特别⽅便。
+
+
+
+RTSP在安防领域有广泛应用,一般传输的是ts/mp4格式的流。
+
+-  优点: 
+    - 延迟低，一般都能够做到500ms
+    - 带宽好，时效率高
+    - 倍速播放，主要是回放的时候提供的功能
+    - 控制精准，任意选择播放点
+- 缺点
+    - 服务端实现复杂
+    - 代理服务器弱：数量少，优化少
+    - 无路由器防火墙穿透
+    - 管流分离：需要1-3个通道
+
+#### SDP
+
+SDP协议⽤用来描述多媒体会话。SDP协议的主要作⽤用在于公告⼀一个多媒体会话中所有媒体流的相关描述信息，以使得接收者能够感知这些描述信息并根据这些描述参与到这个会话中来。SDP会话描述信息通常是通过 RTSP 命令交互来进⾏行传递的，其中携带的媒体类信息主要包括: 
+
+- 媒体的类型(视频，⾳音频等)
+
+- 传输协议(RTP/UDP/IP，RTP/TCP/IP 等)
+
+- 媒体编码格式(H.264 视频，AVS 视频等)
+
+- 流媒体服务器接收媒体流的IP地址和端⼝号
+
+    
+
+一次基本的RTSP操作过程是: 
+
+- 首先，客户端连接到流服务器并发送一个RTSP描述命令（DESCRIBE）。
+- 流服务器通过一个SDP描述来进行反馈，反馈信息包括流数量、媒体类型等信息。
+- 客户端再分析该SDP描述，并为会话中的每一个流发送一个RTSP建立命令(SETUP)，RTSP建立命令告诉服务器客户端用于接收媒体数据的端口。
+- 流媒体连接建立完成后，客户端发送一个播放命令(PLAY)，服务器就开始在UDP上传送媒体流（RTP包）到客户端。 
+- 在播放过程中客户端还可以向服务器发送命令来控制快进、快退和暂停等。
+- 最后，客户端可发送一个终止命令(TERADOWN)来结束流媒体会话
+
+#### RTSP协议与HTTP协议区别
+
+- RTSP引入了几种新的方法，比如DESCRIBE、PLAY、SETUP 等，并且有不同的协议标识符，RTSP为rtsp 1.0,HTTP为http 1.1；
+
+- HTTP是无状态的协议，而RTSP为每个会话保持状态；
+
+- RTSP协议的客户端和服务器端都可以发送Request请求，而在HTTPF协议中，只有客户端能发送Request请求。
+
+- 在RTSP协议中，载荷数据一般是通过带外方式来传送的(除了交织的情况)，及通过RTP协议在不同的通道中来传送载荷数据。而HTTP协议的载荷数据都是通过带内方式传送的，比如请求的网页数据是在回应的消息体中携带的。
+
+- 使用ISO10646(UTF-8) 而不是ISO 8859-1，以配合当前HTML的国际化；
+
+- RTSP使用URI请求时包含绝对URI。而由于历史原因造成的向后兼容性问题，HTTP/1.1只在请求中包含绝对路径，把主机名放入单独的标题域中；
+
+
+
+#### RTSP和RTP的关系
+
+RTP不象http和ftp可完整的下载整个影视文件，它是以固定的数据率在网络上发送数据，客户端也是按照这种速度观看影视文件，当影视画面播放过后，就不可以再重复播放，除非重新向服务器端要求数据
+
+RTSP与RTP最大的区别在于：RTSP是一种双向实时数据传输协议，是纯粹的传输控制协议，它允许客户端向服务器端发送请求，如回放、快进、倒退等操作。当然，RTSP可基于RTP来传送数据，还可以选择TCP、UDP、组播UDP等通道来发送数据，具有很好的扩展性。
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/rtsp_rtp_rtcp.jpeg)
+
+
+
+
+
+RTMP
+---
+
+Real Time Messaging Protocol(实时消息传送协议)基于FLV格式进行开发，最初由Macromedia开发，后被Adobe收购，是Adobe公司为Flash播放器和服务器之间音频、视频和数据传输开发的一种应用层的协议，用来解决多媒体数据传输流的多路复用（Multiplexing）和分包（packetizing）的问题。在基于传输层协议的链接建立完成后，RTMP协议也要客户端和服务器通过“握手”来建立基于传输层链接之上的RTMP Connection链接。协议基于TCP，是一个协议族(默认端口1935)，包括RTMP基本协议及RTMPT/RTMPS/RTMPE等多种变种。市面上绝大部分PC秀场使用的都是它，他有低延迟(2s左右)、稳定性高、技术完善、高支持度、编码兼容性高等特点。但是RTMP协议不使用标准的HTTP接口传输数据(TCP、UDP端口)，所以在一些特殊的网络环境下可能被防火墙屏蔽掉。
+
+之前的时候使用RTMP技术的流媒体系统有一个非常明显的特点：使用 Flash Player作为播放器客户端，而Flash Player 现在已经安装在了全世界将近99%的PC上，因此一般情况下收看RTMP流媒体系统的视音频是不需要安装插件的。用户只需要打开网页，就可以直接收看流媒体，十分方便。
+
+采用RTMP协议时，从采集推流端到流媒体服务器再到播放端是一条数据流，因此在服务器不会有落地文件。这样RTMP相对来说就有这些优点：
+
+- 实时性高：一般能做到3秒内。
+- 基于 TCP 长连接，不需要多次建连。
+
+缺点就是： 
+
+- 很多防火墙会墙掉RTMP，但是不会墙掉HTTP。 
+
+- RTMP协议是Adobe的私有协议,未完全公开，RTSP协议和HTTP协议是共有协议，并有专门机构做维护。
+
+非常多非常多年前，移动互联网还没那么火。还没有H5。Flash视频和应用非常火的时候，RTMP成为了WEB平台直播的唯一方法，于是各大CDN就开始支持RTMP这个协议，经过了非常多年的发展和磨合，非常多cdn已经对rtmp这个协议非常完美的支持了，这个稳定的过程都是多少运维人员熬夜熬出来的，rtmp的势能惯性，会在中国持续未来非常长的时间。cdn不会对稳定盈利的系统轻易做出变化，相同，越来越多的公司来用rtmp。那么就造成cdn更要做rtmp了。这就是一个循环过程，一般的cdn公司不会轻易去打破，除非你是行业巨头。所以现在RTMP用的很多。
+
+
+
+
+HTTP FLV
+---
+类似RTMP流式协议的HTTP长连接，RTMP封装在HTTP协议之上的，可以更好的穿透防火墙等,需由特定流媒体服务器分发的，是真正的HTTP流媒体传输方式，他在延时、首画等体验上跟RTMP等流式协议拥有完全一致的表现，同时继承了部分HTTP的优势。
+
+http+flv ，将音视频数据封装成FLV格式，然后通过HTTP协议传输给客户端。http_flv&rtmp这两个协议实际上传输数据是一样的，数据都是flv文件的tag。相比RTMP，HTTP-FLV会生成一个非常大的http流，只能做拉流，RTMP可以做推流/拉流.所以目前直播常用的方案就是RTMP推流，HTTP-FLV播放。
+
+
+
+HTTP协议中有个约定：content-length字段，用于描述HTTP消息实体的传输长度。服务器回复http请求的时候如果有这个字段，客户端就接收这个长度的数据然后就认为数据传输完成了，如果服务器回复http请求中没有这个字段，客户端就一直接收数据，直到服务器跟客户端的socket连接断开。http-flv直播就是利用第二个原理，服务器回复客户端请求的时候不加content-length字段，在回复了http内容之后，紧接着发送flv数据，客户端就一直接收数据了，http-flv这种流，服务器是不可能预先知道内容大小的，这时就可以使用Transfer-Encoding：chunk模式来传输数据了。
+
+
+
+#### rtmp和http-flv比较：
+
+- RTMP: 基于TCP长链接，不需要多次建立链接，延时小，另外小数据包支持加密，隐私性好。
+
+- HTTP-FLV: HTTP长链接，将收到的数据立即转发，延时小，使用上只需要在大的音视频数据块头部加一些标记头信息，很简单，在延迟表现和大规模并发上比较成熟，手机端 app 使用很合适，实现方式上分为基于文件和基于包，基于包更实时，基于文件可以看回放。
+
+- 穿墙：很多防火墙会墙掉RTMP，但是不会墙HTTP，因此HTTP FLV出现奇怪问题的概率很小。
+- 调度：RTMP也有个302，可惜是播放器as中支持的，HTTP FLV流就支持302方便CDN纠正DNS的错误。
+- 容错：SRS的HTTP FLV回源时可以回多个，和RTMP一样，可以支持多级热备。
+- 简单：FLV是最简单的流媒体封装，HTTP是最广泛的协议，这两个组合在一起维护性更高，比RTMP简单多了。
+  
+
+Flash Video:是Adobe公司推出的另一种视频格式，是一种在网络上传输的流媒体数据存储容器格式。其格式相对简单轻量，不需要很大的媒体头部信息。整个FLV由Header和Body以及其他Tag组成。因此加载速度极快。
+
+说到这里不得不说一下Adobe。
+
+Adobe于2020年停止开发和分发Flash浏览器插件。我们先来简单回顾一下Flash的一生。
+
+九十年代的互联网，由于网速的限制，大部分的网站基本上只有纯文本和简单的图片，基本上不能显示太多的图片和视频。当时主流的多媒体制作软件是Macromedia Director，人们可以用它做一些图片视频，它也是现在Adobe Director的前身。并通过Macromedia  Shockwave（现为Adobe Shockware）发布到互联网上，人们可以在装有Shockwave的浏览器上浏览这些多媒体信息。
+
+由于带宽的限制，人们对于图片的使用还是很谨慎的，这样做可以让Shockwave文件小一些，但这样做出来的东西也很一般。那个时候使用的格式都是GIF和JPEG，而这样的格式浪费了大量的存储空间。
+
+这时，FutureWave出品的FutureSplash Animator出现了，它和Macromedia  Director很类似，不过它的图片是基于矢量存储的，这些的格式可扩展性都非常强，分辨率也很高，存储空间却很小，这是因为矢量图的生成可以通过cpu做到，而当时网速很慢，cpu处理速度越来越快，这样做真的很聪明。后来，FutureWave打算卖给Adobe，但被拒绝了，最后Macromedia 收购了这家公司。FutureSplash Animator也重新定名为Macromedia Flash 1.0。它由两部分组成：图形及动画编辑器，媒体播放器。
+
+随着网速的提升，人们开始使用Flash来播放视频。1999年到2005年之间是Flash发展的黄金时期，无论是Java，RealNetworks，QuickTime，Windows Media Player，所有的媒体播放器在装机量上都远不及它。
+
+Macromedia 对Flash 服务的重视和持续投入改进更加促进了它的增长，后期加入的MovieClips也让它从一个媒体创造平台转型成为了一个网络平台。
+
+2005年，Adobe收购了Macromedia之后，继续开发Flash，业务开始涵盖影片、音乐、游戏等诸多领域，许多电脑都已经预装了Flash，而且增加了边下边播的功能，这样用户就可以在文件刚下载时播放视频，Flash也逐渐成为了“行业标准”。
+
+上世纪90年代，大多数的浏览器还不支持css，而Flash的出现，人们可以在浏览器上播放动画，火柴人，爆笑三国，神啊救救我吧，等无数的的视频，对老网民来说，留下了无数的回忆。超高压占比的格式，矢量图，边下边播，节省带宽的格式，也给人们留下了深刻的印象。那个时候，人们可以不用考虑代码实现就可以通过Flash做出一些炫酷的动画。
+
+业界现在普遍认为，Flash的下坡路是从和苹果的决裂开始的。尤其是乔布斯在2010年发布的一篇《[thoughts-on-flash](https://www.apple.com/hotnews/thoughts-on-flash/)》的文章。乔布斯在里面写下了于Flash的一点看法，说明自己为什么不使用Flash，谈到关于Flash的一些问题，比如开放性，安全性，对于设备续航的影响，不利于触摸屏，等等。最重要的原因。让一个第三方软件插足于开发者和平台之间，只会带来不合标准的应用，阻碍平台的改善与发展，我们不能被第三方的决定所左右。苹果从一开始就作为平台级别的绝对掌控者，从一开始就建立了app store这样的封闭系统策略，Flash 作为一个第三方插件，很难进入苹果自己的平台争利。
+
+移动端的乏力并不是Flash唯一的问题，在PC方面，Flash也遇到了大麻烦，2015年谷歌旗下的Youtube开始将视频格式全部转为html5，甚至还推出了工具Swiffy，可以将Flash转换成html5.
+
+不仅如此，Google旗下的Chrome占据了浏览器市场上的大部分份额，然而Chrome也慢慢把支持Flash变成非默认的选项，用户一般不会主动打开Flash，只有在遇到需要Flash的网站时，Chrome才会提醒用户需不需要打开它。
+
+而Firefox，Safari这些也占有一定份额的浏览器，也开始站在了Flash的对立面上，Pc端和移动端的双面乏力，加速了Flash的衰亡。
+
+真正的致命一击还是来自html5，它是最新一代的web标准，用户不需要安装额外的插件就可以访问视频和玩游戏，因为几乎所有的主流浏览器都支持新的html5标准。之后又由于flv.js的出现，加速了flash时代的结束。
+
+Adobe宣布将于2020年停止对Flash的支持，很快GitHub之上出现一则请愿，请求Adobe将Flash开源。芬兰开发者 Juha  Lindstedt  在请愿中提到：Flash是互联网历史上重要的一笔，消灭Flash意味着将来的一代就看不到以前的东西了。这样一来，很多游戏、体验和网站就会被遗忘；所以请求Adobe对Flash进行开源或部分开源，这样一来开源社区就能对Flash插件进行支持，或者至少打造可将swf/fla文件转换至HTML5、WebAssembly代码的工具。
+
+
+
+
+
+常用的流媒体协议主要有HTTP渐进式下载和基于RTSP/RTP的实时流媒体协议栈等等，这些流媒体协议大多数可以平移到移动流媒体中继续应用。然⽽由于移动互联⽹网及其终端设备的一些独有特性，传统流媒体协议在移动互联⽹中的应⽤用在功能、性能的提供和⽤户体验等⽅方⾯面都会受到不同程度的约束和限制，以及Apple和Adobe的关系，于是一些新的流媒体协议应运而生。例如，苹果公司的 HTTP Live Streaming 就是其中具有代表性且得到较为⼴广泛应⽤用的一个。 但是HLS（Apple）、HDS(Adobe)、MSS(Microsoft)  、DASH（MPEG组织）均属于“伪”HTTP流，之所以说他们“伪”，是因为他们在体验上类似“流”，但本质上依然是HTTP文件下载。以上几个协议的原理都一样，就是将媒体数据（文件或者直播信号）进行切割分块，同时建立一个分块对应的索引表，一并存储在HTTP Web服务器中，客户端连续线性的请求这些分块小文件，以HTTP文件方式下载，顺序的进行解码播放，我们就得到了平滑无缝的“流”的体验。其主要特点是：放弃专门的流媒体服务器，而返回到使用标准的 Web服务器来递送媒体数据；将容量巨大的连续媒体数据进⾏分段，分割为数量众多的小⽂件进行传递，迎合了 Web服务器的⽂件传输特性；采⽤用了⼀个不断更新的轻量级索引⽂件来控制分割后⼩媒体文件的下载和播放，可同时⽀持直播和点播，以及VCR类会话控制操作。HTTP协议的使⽤用降低了HTTP Live Streaming 系统的部署难度，同时也简化了客户端（特别是嵌⼊入式移动终端）软件的开发复杂度。此外，⽂件分割和索引文件的引入也使得带宽⾃适应的流间切换、服务器故障保护和媒体加密等变得更加方便。与RTSP/RTP相比，HTTP Live Streaming的最⼤缺点在于它并非一个真正的实时流媒体系统，在服务器和客户端都存在一定的起始延迟。
+
+
+
+
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/vs_no_background1.png)
+
+
+
+
+HLS
+---
+HTTP Live Streaming:是苹果公司实现的基于HTTP的流媒体传输协议，可实现流媒体的直播和点播，HLS点播，基本上就是常见的分段HTTP点播，不同在于，它的分段非常小。相对于常见的流媒体直播协议，例如RTMP协议、RTSP协议等，HLS直播最大的不同在于，直播客户端获取到的，并不是一个完整的数据流。HLS协议在服务器端将直播数据流存储为连续的、很短时长的媒体文件（MPEG-TS格式），而客户端则不断的下载并播放这些小文件。因为服务器端总是会将最新的直播数据生成新的小文件，这样客户端只要不停的按顺序播放从服务器获取到的文件，就实现了直播。由此可见，基本上可以认为，HLS是以点播的技术方式来实现直播。由于数据通过HTTP协议传输，所以完全不用考虑防火墙或者代理的问题，而且分段文件的时长很短，客户端可以很快的选择和切换码率，以适应不同带宽条件下的播放。不过HLS的这种技术特点，决定了它的延迟一般总是会高于普通的流媒体直播协议。它也解决了RTMP协议存在的一些问题，例如RTMP协议不使用标准的HTTP接口传输数据(TCP、UDP端口)，所以在一些特殊的网络环境下可能被防火墙屏蔽掉，而HLS使用的是HTTP协议传输数据(80端口)，不会遇到被防火墙屏蔽的情况。
+
+HLS相比于http-flv的优点就是不需要任何插件，html5可以直播播放，safari，EDGE等浏览器都可以直接播放HLS的视频流。
+
+
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/hls_suport_use.png)
+
+
+
+在开始一个流媒体会话时，客户端会下载一个包含元数据的extended M3U(m3u8) playlist文件，用于寻找可用的媒体流(将视频分为一个个视频小分片，然后用m3u8索引表进行管理，由于客户端下载到的视频都是5-10秒的完整数据，所以视频的流畅性很好，但是同样也引入了很大的延迟(一般延迟在10-30s左右))。
+
+上面提到了m3u8，那m3u8构成是？直播中m3u8、ts如何实时更新？      
+
+- 是一个索引地址/播放列表，通过FFmpeg将本地的xxx.mp4进行切片处理，生成m3u8播放列表（索引文件）和N多个 .ts文件，并将其（m3u8、N个ts）放置在本地搭建好的webServer服务器的指定目录下，我就可以得到一个可以实时播放的网址，我们把这个m3u8地址复制到 VLC 上就可以实时观看！
+  在 HLS 流下，本地视频被分割成一个一个的小切片，一般10秒一个，这些个小切片被 m3u8管理，并且随着终端的FFmpeg 向本地拉流的命令而实时更新，影片进度随着拉流的进度而更新，播放过的片段不在本地保存，自动删除，直到该文件播放完毕或停止，ts 切片会相应的被删除，流停止，影片不会立即停止，影片播放会滞后于拉流一段时间
+
+  
+
+HLS的整体流程为:   
+
+视频源文件 -> 服务器(编码器、流分割器) -> 分发器(索引文件、*.ts) -> 传输网络 -> 客户端
+
+HLS的最大缺点就是延迟高，但Apple在WWDC2019发布了新的解决方案，可以将延迟从8秒降低到1至2秒。
+
+[HLS的详细介绍](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE/HLS.md)
+
+HDS
+---
+`Http Dynamic Streaming`:是一个由Adobe公司模仿HLS协议提出的另一个基于Http的流媒体传输协议(传统流媒体解决方案RTMP+FLV的组合)。
+
+Flash Player 和 Flash Media Server 的最新版支持传统的 [RTMP](https://zh.wikipedia.org/w/index.php?title=Real_Time_Messaging_Protocol&action=edit&redlink=1) 协议和 [HTTP](https://zh.wikipedia.org/wiki/Hypertext_Transfer_Protocol) 协议。它是RTMP的后继产品，也增加了对自适应流的支持。其模式与HLS类似，也是索引文件和媒体切片文件结合的下载方式，但是又要比HLS协议更复杂。
+
+基于HTTP的流的优势是：
+
+- 不需要防火墙开普通web浏览器所需端口以外的任何端口
+- 允许视频切片在浏览器、网关和CDN的缓存，从而显著降低源服务器的负载。
+
+HDS 的文件格式为 FLV/F4V/MP4，索引文件为 f4m，同时支持直播和时移。
+
+
+
+
+
+Smooth Streaming
+---
+
+微软提供的一套解决方案，是IIS的媒体服务扩张，用于支持基于HTTP的自适应串流，它的文件切片为mp4，索引文件为ism/ismc。
+
+
+
+在基于HTTP提供流媒体的方面，到目前为止已经看到了三种方案，苹果的HLS，Adobe HTTP Dynamic Streaming (HDS)和Microsoft Smooth Streaming (MSS)，当然，各家用的协议，格式会不一样。于是MPEG呼吁大家做到一起，聊聊出一个统一的标准。
+
+
+
+DASH
+---
+
+DASH(MPEG-DASH)全称为Dynamic Adaptive Streaming over HTTP。是国标标准组MPEG( (Moving Picture Experts Group) 2014年推出的技术标准，主要目标是形成IP网络承载单一格式的流媒体并提供高效与高质量服务的统一方案，解决多制式传输方案(HTTP Live Streaming, Microsoft Smooth Streaming, HTTP Dynamic Streaming)并存格局下的存储与服务能力浪费、运营高成本与复杂度、系统间互操作弱等问题。       
+
+DASH是基于HTTP的动态自适应的比特率流技术，使用的传输协议是TCP，也是把视频分割成一小段一小段， 通过HTTP协议进行传输，客户端得到之后进行播放；不同的是MPEG-DASH支持MPEG-2 TS、MP4等多种格式, 可以将视频按照多种编码切割, 下载下来的媒体格式既可以是ts文件也可以是mp4文件, 所以当客户端加载视频时, 按照当前的网速和支持的编码加载相应的视频片段进行播放.          
+
+因为是分片的，客户端可以自由选择需要播放的媒体分片，可以实现Adaptive Bitrate Streaming技术，不同画质内容无缝切换，提供更好的播放体验。        
+
+YouTube采用DASH！其网页端及移动端APP都使用了DASH。
+
+DASH的整个流程:        
+
+内容生成服务器(编码模块、封装模块) -> 流媒体服务器(MPD、媒体文件、HTTP服务器) <-> DASH客户端(控制引擎、媒体引擎、HTTP接入容器)
+
+
+
+[DASH详细介绍](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE/DASH.md)
+
+
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/dash_compare2.png)
+
+
+
+![hls_hds_mss_dash](https://raw.githubusercontent.com/CharonChui/Pictures/master/hls_hds_mss_dash.png)
+
+这么多流媒体协议我该选用哪个？需要说明的是，各种流媒体协议都有其生存的理由，比如监控行业、电信行业IPTV就不能没有RTSP，因为这里面所有的监控应用程序太多基于RTSP；比如目前的直播主协议就是RTMP，主要是因为CDN对RTMP支持的最好；再比如Apple终端市场占有率太高，就不能够不去考虑HLS。
+
+ 每一种流媒体协议都有其应用场景，每一种流媒体协议都有其发展的历史原因，每一种流媒体协议都有其自身的优势和不足。所以，我们需要对各种协议的原理、构成、特性都有所了解，才能在自身应用场景中选择出最佳方案。
+
+
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/live_video_player.png)
+
+
+
+
+
+参考:  
+
+- [MPEG-DASH vs. Apple HLS vs. Microsoft Smooth Streaming vs. Adobe HDS](https://bitmovin.com/mpeg-dash-vs-apple-hls-vs-microsoft-smooth-streaming-vs-adobe-hds/)
+- [A Survey on Quality of Experience ofHTTP Adaptive Streaming](http://www.comnet.informatik.uni-wuerzburg.de/publikationen/journal-articles/?tx_extbibsonomycsl_publicationlist%5BuserName%5D=uniwue_info3&tx_extbibsonomycsl_publicationlist%5BintraHash%5D=99067f2f003db1689d6ac3880a8e0c22&tx_extbibsonomycsl_publicationlist%5BfileName%5D=jour_126.pdf&tx_extbibsonomycsl_publicationlist%5Baction%5D=download&tx_extbibsonomycsl_publicationlist%5Bcontroller%5D=Document&cHash=92121b0e4d712ba4ccb918e8a1d82c34)
+- [渐进式、HLS、DASH、HDS、RTMP协议](http://www.4u4v.net/liu-mei-ti-xie-yi-hu-lian-wang-shi-pin-fen-fa-xie-yi-jie-shao-jian-jin-shi-hlsdashhdsrtmp-xie-yi.html)
+- [Real-Time Messaging Protocol](https://en.wikipedia.org/wiki/Real-Time_Messaging_Protocol)
+- [HTTP Live Streaming](https://en.wikipedia.org/wiki/HTTP_Live_Streaming)
+- [Streaming Protocols: Everything You Need to Know](https://www.wowza.com/blog/streaming-protocols)
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/\346\265\201\345\252\222\344\275\223\351\200\232\344\277\241\345\215\217\350\256\256.md" "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/\346\265\201\345\252\222\344\275\223\351\200\232\344\277\241\345\215\217\350\256\256.md"
deleted file mode 100644
index 402a87e7..00000000
--- "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/\346\265\201\345\252\222\344\275\223\351\200\232\344\277\241\345\215\217\350\256\256.md"
+++ /dev/null
@@ -1,337 +0,0 @@
-流媒体通信协议
-===
-
-
-
-## 流媒体
-
-
-
-流媒体(Streaming Media)又叫流式媒体。是指采用流式传输技术在网络上连续实时播放的媒体格式，如音频、视频或多媒体文件，采用流媒体技术使得数据包得以像流水一样发送, 如果没有流媒体技术, 那么我们就要像以前用迅雷下电影一样, 下载整个影片才能观看。这样我们需要在漫长的等待之后（因为受限于带宽，下载通常要花上较长的时间），才可以看到或听到媒体传达的信息。令人欣慰的是，在流媒体技术出现之后，人们便无需再等待媒体完全下载完成了。
-
-所谓流媒体技术就是把连续的影像和声音信息经过压缩处理后放上网站服务器,由视频服务器向用户计算机顺序或实时地传送各个压缩包，让用户一边下载一边观看、收听，而不要等整个压缩文件下载到自己的计算机上才可以观看的网络传输技术。该技术先在使用者端的计算机上创建一个缓冲区，客户端在播放前并不需要下载整个媒体⽂文件，而是在将缓存区中已经收到的媒体数据进⾏行播放。同时，媒体流的剩余部分仍持续不断地从服务器递送到客户端，即所谓的“边下载，边播放”。
-
-
-
-## 流媒体系统的组成
-
-通常，组成一个完整的流媒体系统包括以下5个部分:  
-
-- 一种用于创建、捕捉和编辑多媒体数据，形成流媒体格式的编码工具;
-
-- 流媒体数据;
-
-- 一个存放和控制流媒体数据的服务器;
-
-- 要有适合多媒体传输协议甚至是实时传输协议的网络;
-
-- 供客户端浏览流媒体文件的播放器。 
-
-
-
-## 流媒体技术的分类
-
-从传输方式上大致可以分为HTTP渐进式下载、实时流媒体传输、HTTP流式传输三大类。
-
-
-
-### HTTP顺序流(渐进)式传输(Progressive Streaming)
-
-顺序流式传输是顺序下载，在下载文件的同时用户可以观看，但是，用户的观看与服务器上的传输并不是同步进行的，用户是在一段延时后才能看到服务器上传出来的信息，或者说用户看到的总是服务器在若干时间以前传出来的信息。如YouTube、优酷等大型视频网站的点播分发。它的核心区别是媒体文件不分片，直接以完整文件形态进行分发，通过支持Seek,终端播放器可从没下载完成部分中任意选取一个时间点开始播放，如此来满足不用等整个文件下载完快速播放的需求，一般MP4和FLV格式文件支持较好，打开一个视频拖拽到中部，短暂缓冲即可播放，点击暂停后文件仍将被持续下载就是典型的渐进式下载。在这过程中，客户端需要在硬盘上缓存所有前⾯面已经下载的媒体数据，对本地存储空间的需求较⼤大。播放过程中⽤用户只能在前⾯面已经下载媒体数据的时间范围内进⾏行进度条搜索和快进、快退等操作，而无法在整个媒体⽂文件时间范围内执⾏行这些操作。顺序流式传输比较适合高质量的短片段，因为它可以较好地保证节目播放的最终质量。它适合于在网站上发布的供用户点播的音视频节目。
-
-- 应用场景
-    - 点播型应用
-- 协议
-    - HTTP
-
-
-
-### 实时流式传输(Realtime Streaming)
-
-在实时流式传输中，音视频信息可被实时观看到。
-实时流式传输必须匹配连接宽带，意味着以调制解调器速度连接时图像质量较差，而且由于出错丢失的信息被忽略掉，网络拥挤或者出现问题时候，视频质量很差，如欲保证视频质量，顺序流式传输也许更好，实时流式传输需要特定的服务器，如QuickTime Streaming Server/Real Server/Windows Media  Server这些服务器允许你对媒体发送进行更多级别的控制，因为而系统设置管理比HTTP服务器更复杂，实时流传输还需要特殊的网络协议，比如RTSP(Real time sreming protocol)或MMS(Microsoft Media  Server)这些协议在有防火墙的时候会出现问题，导致用户不能看到一些地点的实时内容。
-
-- 应用场景
-    - 直播型应用。直播服务模式下，用户只能观看播放的内容，无法进行控制。
-    - 会议型应用。会议型应用类似于直播型应用，但是两者有不同的要求，如双向通信等。这对一般双方都要有包括媒体采集的硬件和软件，还有流传输技术。会议型的应用有时候不需要很高的音/视频质量。
-- 协议
-    - RTSP
-    - RTMP
-
-### HTTP流式传输
-
-细分又可以分为: 伪HTTP流和HTTP流。
-
-
-
-**HLS类“伪”HTTP流**：HLS（Apple）、HDS(Adobe)、MSS(Microsoft)  、DASH（MPEG组织）均属于“伪”HTTP流，之所以说他们“伪”，是因为他们在体验上类似“流”，但本质上依然是HTTP文件下载。以上几个协议的原理都一样，就是将媒体数据（文件或者直播信号）进行切割分块，同时建立一个分块对应的索引表，一并存储在HTTP Web服务器中，客户端连续线性的请求这些分块小文件，以HTTP文件方式下载，顺序的进行解码播放，我们就得到了平滑无缝的“流”的体验。
-
-- 协议
-    - HLS
-    - HDS
-    - MSS
-    - DASH
-
-
-
-**HTTP流**: http-flv这样的使用类似RTMP流式协议的HTTP长连接，需由特定流媒体服务器分发的，是真正的HTTP流媒体传输方式，他在延时、首画等体验上跟RTMP等流式协议拥有完全一致的表现，同时继承了部分HTTP的优势。
-
-- 协议
-    - HTTP FLV
-
-- 应用场景
-    - 点播型应用
-    - 直播型应用
-
-
-
-接下来我们以上面传输方式的分类来简单介绍一下。
-
-## 相关协议
-
-### HTTP
-
-
-
-渐进下载流媒体播放采⽤用标准HTTP协议来在Web服务器和客户端之间递送媒体数据。
-
-互联网上最初只能传输一些文本类的数据，自从HTTP协议发明之后，就可以传输超文本的音频视频等等内容，这主要就是靠HTTP协议中的MIME。通过它，浏览器就会根据协议中的Content-Type header去选择相应的应用程序去处理相应的内容。如此，才使得流媒体内容通过HTTP协议传输成为可能。
-
-
-
-基于HTTP渐进式下载的流媒体播放仅能⽀持点播而不能支持直播，媒体流数据到达客户端的速率无法精确控制，客户端仍需维持一个与服务器上媒体文件同样大小的缓冲存储空间，在开始播放之前需要等待一段较长的缓冲时间从而导致实时性较差，播放过程中由于⽹网络带宽的波动或分组丢失可能会导致画面停顿或断续等待。为克服这些问题，需要引入专门的流媒体服务器以及相应的实时流媒体传输和控制协议来进行支持。所以就出现了接下来实时流媒体协议。RTSP/RTP实际上由一组在IETF 中标准化的协议所组成，包括RTSP (实时流媒体会话协议)，SDP(会话描述协议)，RTP (实时传输协议)，以及针对不同编解码标准的RTP净载格式等，共同协作来构成⼀一个流媒体协议栈。基于该协议栈的扩展已被 ISMA (互联⽹网流媒体联盟) 和 3GPP (第三代合作伙伴计划) 等组织采纳成为互联⽹网和 3G 移动互联⽹网的流媒体标准。
-
-
-
-4.分析与⽐比较作为最简单和原始的流媒体解决⽅方案，HTTP 渐进式下载唯⼀一显著的优点在于它仅需要维护⼀一个标准的 Web 服务器，⽽而这样的服务器基础设施在互联⽹网中已经普遍存在，其安装和维护的⼯工作量和复杂性⽐比起专门的流媒体服务器来说要简单和容易得多。然⽽而其缺点和不⾜足却也很多，⾸首先是仅适⽤用于点播⽽而不⽀支持直播，其次是缺乏灵活的会话控制功能和智能的流量调节机制，再次是客户端需要硬盘空间以缓存整个⽂文件⽽而不适合于移动设备等。基于 RTSP/RTP 的流媒体系统专门针对⼤大规模流媒体直播和点播等应⽤用⽽而设计，需要专门的流媒体服务器⽀支持，与 HTTP 渐进下载相⽐比主要具有如下优势：•流媒体播放的实时性。与 HTTP 渐进下载客户端需要先缓冲⼀一定数量媒体数据才能开始播放不同，基于 RTSP/RTP 的流媒体客户端⼏几乎在接收到第⼀一帧媒体数据的同时就可以启动播放。•⽀支持进度条搜索、快进、快退等⾼高级 VCR 控制功能。•平滑、流畅的⾳音视频播放体验。在基于 RTSP 的流媒体会话期间，客户端与服务器之间始终保持会话联系，服务器能够对来⾃自客户端的反馈信息动态做出响应。当因⽹网络拥塞等原因导致可⽤用带宽不⾜足时，服务器可通过适当降低帧率等⽅方式来智能调整发送速率。此外，UDP 传输协议的使⽤用使得客户端在检测到有丢包发⽣生时，可选择让服务器仅选择性地重传部分重要的数据（如关键帧），⽽而忽略其他优先级较低的数据，从⽽而保证在⽹网络不好的情况下客户端也仍能连续、流畅地进⾏行播放。尽管如此，基于 RTSP/RTP 的流媒体系统在实际的应⽤用部署特别是移动互联⽹网应⽤用中仍然遇到了不少问题，主要体现在：•与 Web 服务器相⽐比，流媒体服务器的安装、配置和维护都较为复杂，特别是对于已经建有 CDN（内容分发⽹网络）等基础设施的运营商来说，重新安装配置⽀支持RTSP/RTP 的流媒体服务器⼯工作量很⼤大。
-
-
-
-
-
-### RTSP
-
-#### RTP
-
-实时传输协议(Real-time Transport Protocol):是用于Internet上针对多媒体数据流的一种传输层协议，用于实际承载媒体数据并为具有实时特性的媒体数据交互提供端到端的传输服务，例如净载类型识别、序列号、时间戳和传输监控等。RTP是真正的实时传输协议，客户端仅需要维持一个很⼩小的解码缓冲区⽤于缓存视频解码所需的少数参考帧数据，从⽽⼤大缩短了起始播放时延，通常可控制在1秒之内。应⽤用程序通常选择在UDP之上来运⾏行RTP协议，以便利用UDP的复用和校验和等功能，并提高网络传输的有效吞吐量。当因为网络拥塞而发⽣RTP丢包时，服务器可以根据媒体编码特性智能的进行选择性重传，故意丢弃一些不重要的数据包；客户端也可以不必等待未按时到达的数据⽽继续向前播放，从⽽保证媒体播放的流畅性。
-
-#### RTCP
-
-Real-time Transport Control Protocol或RTP Control Protocol实时传输控制协议，是实时传输协议（RTP）的一个姐妹协议。RTCP为RTP媒体流提供信道外(out-of-band)控制。RTCP本身并不传输数据，但和RTP一起协作将多媒体数据打包和发送。RTCP定期在流多媒体会话参加者之间传输控制数据，它的主要功能是收集相关媒体链接的统计信息，并为RTP所提供的服务质量提供反馈。
-
-RTCP收集相关媒体连接的统计信息，例如：传输字节数，传输分组数，丢失分组数，jitter，单向和双向网络延迟等等。网络应用程序可以利用RTCP所提供的信息试图提高服务质量，比如限制信息流量或改用压缩比较小的编解码器。
-
-#### RTSP
-
-Real Time Streaming Protocol(实时流传输协议):由哥伦比亚大学、网景和Real Networks公司提交，是一种基于文本的应用层协议，在语法及一些消息参数等方面，RTSP协议与HTTP协议类似。⽤来建立和控制⼀一个或多个时间同步的连续⾳视频媒体流的会话协议。通过在客户机和服务器之间传递 RTSP 会话命令，可以完成诸如请求播放、开始、暂停、查找、快进和快退等VCR控制操作。RTSP 在体系结构上位于RTP和RTCP之上，它使用TCP或UDP完成数据传输。使用RTSP时，客户机和服务器都可以发出请求，即RTSP可以是双向的。允许同时多个串流需求控制，除了可以降低服务器端的网络用量，更进而支持多方视讯会议（Video Conference）。 
-
-
-
-RTSP在安防领域有广泛应用,一般传输的是ts/mp4格式的流。
-
--  优点: 
-    - 延迟低，一般都能够做到500ms
-    - 带宽好，时效率高
-    - 倍速播放，主要是回放的时候提供的功能
-    - 控制精准，任意选择播放点
-- 缺点
-    - 服务端实现复杂
-    - 代理服务器弱：数量少，优化少
-    - 无路由器防火墙穿透
-    - 管流分离：需要1-3个通道
-
-#### SDP
-
-SDP协议⽤用来描述多媒体会话。SDP协议的主要作⽤用在于公告⼀一个多媒体会话中所有媒体流的相关描述信息，以使得接收者能够感知这些描述信息并根据这些描述参与到这个会话中来。SDP会话描述信息通常是通过 RTSP 命令交互来进⾏行传递的，其中携带的媒体类信息主要包括: 
-
-- 媒体的类型(视频，⾳音频等)
-
-- 传输协议(RTP/UDP/IP，RTP/TCP/IP 等)
-
-- 媒体编码格式(H.264 视频，AVS 视频等)
-
-- 流媒体服务器接收媒体流的IP地址和端⼝号
-
-    
-
-一次基本的RTSP操作过程是: 
-
-- 首先，客户端连接到流服务器并发送一个RTSP描述命令（DESCRIBE）。
-- 流服务器通过一个SDP描述来进行反馈，反馈信息包括流数量、媒体类型等信息。
-- 客户端再分析该SDP描述，并为会话中的每一个流发送一个RTSP建立命令(SETUP)，RTSP建立命令告诉服务器客户端用于接收媒体数据的端口。
-- 流媒体连接建立完成后，客户端发送一个播放命令(PLAY)，服务器就开始在UDP上传送媒体流（RTP包）到客户端。 
-- 在播放过程中客户端还可以向服务器发送命令来控制快进、快退和暂停等。
-- 最后，客户端可发送一个终止命令(TERADOWN)来结束流媒体会话
-
-#### RTSP协议与HTTP协议区别
-
-- RTSP引入了几种新的方法，比如DESCRIBE、PLAY、SETUP 等，并且有不同的协议标识符，RTSP为rtsp 1.0,HTTP为http 1.1；
-
-- HTTP是无状态的协议，而RTSP为每个会话保持状态；
-
-- RTSP协议的客户端和服务器端都可以发送Request请求，而在HTTPF协议中，只有客户端能发送Request请求。
-
-- 在RTSP协议中，载荷数据一般是通过带外方式来传送的(除了交织的情况)，及通过RTP协议在不同的通道中来传送载荷数据。而HTTP协议的载荷数据都是通过带内方式传送的，比如请求的网页数据是在回应的消息体中携带的。
-
-- 使用ISO10646(UTF-8) 而不是ISO 8859-1，以配合当前HTML的国际化；
-
-- RTSP使用URI请求时包含绝对URI。而由于历史原因造成的向后兼容性问题，HTTP/1.1只在请求中包含绝对路径，把主机名放入单独的标题域中；
-
-
-
-#### RTSP和RTP的关系
-
-RTP不象http和ftp可完整的下载整个影视文件，它是以固定的数据率在网络上发送数据，客户端也是按照这种速度观看影视文件，当影视画面播放过后，就不可以再重复播放，除非重新向服务器端要求数据
-
-RTSP与RTP最大的区别在于：RTSP是一种双向实时数据传输协议，是纯粹的传输控制协议，它允许客户端向服务器端发送请求，如回放、快进、倒退等操作。当然，RTSP可基于RTP来传送数据，还可以选择TCP、UDP、组播UDP等通道来发送数据，具有很好的扩展性。
-
-
-
-
-
-![img](https://img-blog.csdn.net/20130925235918343?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvdHR0eWQ=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
-
-
-
-
-
-
-
-RTMP
----
-
-Real Time Messaging Protocol(实时消息传送协议)基于FLV格式进行开发，是Adobe公司为Flash播放器和服务器之间音频、视频和数据传输开发的一种应用层的协议，用来解决多媒体数据传输流的多路复用（Multiplexing）和分包（packetizing）的问题。在基于传输层协议的链接建立完成后，RTMP协议也要客户端和服务器通过“握手”来建立基于传输层链接之上的RTMP Connection链接。协议基于TCP，是一个协议族(默认端口1935)，包括RTMP基本协议及RTMPT/RTMPS/RTMPE等多种变种。市面上绝大部分PC秀场使用的都是它，他有低延迟(2s左右)、稳定性高、技术完善、高支持度、编码兼容性高等特点。但是RTMP协议不使用标准的HTTP接口传输数据(TCP、UDP端口)，所以在一些特殊的网络环境下可能被防火墙屏蔽掉。
-
-使用RTMP技术的流媒体系统有一个非常明显的特点：使用 Flash Player作为播放器客户端，而Flash Player 现在已经安装在了全世界将近99%的PC上，因此一般情况下收看RTMP流媒体系统的视音频是不需要安装插件的。用户只需要打开网页，就可以直接收看流媒体，十分方便。
-
-采用RTMP协议时，从采集推流端到流媒体服务器再到播放端是一条数据流，因此在服务器不会有落地文件。这样RTMP相对来说就有这些优点：
-
-- 实时性高：一般能做到3秒内。
-- 基于 TCP 长连接，不需要多次建连。
-
-缺点就是:很多防火墙会墙掉RTMP，但是不会墙掉HTTP。 
-
-
-
-Flash Video:是Adobe公司推出的另一种视频格式，是一种在网络上传输的流媒体数据存储容器格式。其格式相对简单轻量，不需要很大的媒体头部信息。整个FLV由Header和Body以及其他Tag组成。因此加载速度极快。
-
-
-
-
-HTTP FLV
----
-类似RTMP流式协议的HTTP长连接，需由特定流媒体服务器分发的，是真正的HTTP流媒体传输方式，他在延时、首画等体验上跟RTMP等流式协议拥有完全一致的表现，同时继承了部分HTTP的优势。
-
-http+flv ，将音视频数据封装成FLV格式，然后通过HTTP协议传输给客户端。http_flv&rtmp这两个协议实际上传输数据是一样的，数据都是flv文件的tag。
-
-
-
- HTTP协议中有个约定：content-length字段，用于描述HTTP消息实体的传输长度。服务器回复http请求的时候如果有这个字段，客户端就接收这个长度的数据然后就认为数据传输完成了，如果服务器回复http请求中没有这个字段，客户端就一直接收数据，直到服务器跟客户端的socket连接断开。http-flv直播就是利用第二个原理，服务器回复客户端请求的时候不加content-length字段，在回复了http内容之后，紧接着发送flv数据，客户端就一直接收数据了，http-flv这种流，服务器是不可能预先知道内容大小的，这时就可以使用Transfer-Encoding：chunk模式来传输数据了。
-
- 相比RTMP，HTTP-FLV会生成一个非常大的http流，只能做拉流，RTMP可以做推流/拉流.
-
-![](https://raw.githubusercontent.com/CharonChui/Pictures/master/vs_no_background1.png)
-
-
-
-常用的流媒体协议主要有HTTP渐进式下载和基于RTSP/RTP的实时流媒体协议栈等等，这些流媒体协议⼤大多数可以平移到移动流媒体中继续应⽤用。然⽽而由于移动互联⽹网及其终端设备的⼀一些独有特性，传统流媒体协议在移动互联⽹网中的应⽤用在功能、性能的提供和⽤用户体验等⽅方⾯面都会受到不同程度的约束和限制，于是一些新的流媒体协议应运⽽而⽣生。例如，苹果公司的 HTTP Live Streaming 就是其中具有代表性且得到较为⼴广泛应⽤用的一个。 但是HLS（Apple）、HDS(Adobe)、MSS(Microsoft)  、DASH（MPEG组织）均属于“伪”HTTP流，之所以说他们“伪”，是因为他们在体验上类似“流”，但本质上依然是HTTP文件下载。以上几个协议的原理都一样，就是将媒体数据（文件或者直播信号）进行切割分块，同时建立一个分块对应的索引表，一并存储在HTTP Web服务器中，客户端连续线性的请求这些分块小文件，以HTTP文件方式下载，顺序的进行解码播放，我们就得到了平滑无缝的“流”的体验。
-
-
-
-•RTSP/RTP 协议栈的逻辑实现较为复杂，与 HTTP 相⽐比⽀支持 RTSP/RTP 的客户端软硬件实现难度较⼤大，特别是对于嵌⼊入式移动设备终端来说。•RT S P  协议使⽤用的⽹网络端⼜⼝口号(554)可能被部分⽤用户⽹网络中的防⽕火墙和NAT等封堵，导致⽆无法使⽤用。虽然有些流媒体服务器可通过隧道⽅方式将 RTSP 配置在HTTP 的 80 端⼜⼝口上承载，但实际部署起来并不是特别⽅方便。HTTP Live Streaming 正是为了解决这些问题应运⽽而⽣生的，其主要特点是：放弃专门的流媒体服务器，⽽而返回到使⽤用标准的 Web 服务器来递送媒体数据；将容量巨⼤大的连续媒体数据进⾏行分段，分割为数量众多的⼩小⽂文件进⾏行传递，迎合了 Web 服务器的⽂文件传输特性；采⽤用了⼀一个不断更新的轻量级索引⽂文件来控制分割后⼩小媒体⽂文件的下载和播放，可同时⽀支持直播和点播，以及 VCR 类会话控制操作。HTTP 协议的使⽤用降低了HTTP Live Streaming 系统的部署难度，同时也简化了客户端（特别是嵌⼊入式移动终端）软件的开发复杂度。此外，⽂文件分割和索引⽂文件的引⼊入也使得带宽⾃自适应的流间切换、服务器故障保护和媒体加密等变得更加⽅方便。与 RTSP/RTP 相⽐比，HTTP Live Streaming 的最⼤大缺点在于它并⾮非⼀一个真正的实时流媒体系统，在服务器和客户端都存在⼀一定的起始延迟。
-
-
-
-
-HLS
----
-HTTP Live Streaming:是苹果公司实现的基于HTTP的流媒体传输协议，可实现流媒体的直播和点播，HLS点播，基本上就是常见的分段HTTP点播，不同在于，它的分段非常小。相对于常见的流媒体直播协议，例如RTMP协议、RTSP协议等，HLS直播最大的不同在于，直播客户端获取到的，并不是一个完整的数据流。HLS协议在服务器端将直播数据流存储为连续的、很短时长的媒体文件（MPEG-TS格式），而客户端则不断的下载并播放这些小文件。因为服务器端总是会将最新的直播数据生成新的小文件，这样客户端只要不停的按顺序播放从服务器获取到的文件，就实现了直播。由此可见，基本上可以认为，HLS是以点播的技术方式来实现直播。由于数据通过HTTP协议传输，所以完全不用考虑防火墙或者代理的问题，而且分段文件的时长很短，客户端可以很快的选择和切换码率，以适应不同带宽条件下的播放。不过HLS的这种技术特点，决定了它的延迟一般总是会高于普通的流媒体直播协议。它也解决了RTMP协议存在的一些问题，例如RTMP协议不使用标准的HTTP接口传输数据(TCP、UDP端口)，所以在一些特殊的网络环境下可能被防火墙屏蔽掉，而HLS使用的是HTTP协议传输数据(80端口)，不会遇到被防火墙屏蔽的情况。
-
-HLS相比于http-flv的优点就是不需要任何插件，html5可以直播播放，safari，EDGE等浏览器都可以直接播放HLS的视频流。
-
-HLS requires that video is packaged in the M2TS transport stream; a  format that was designed for broadcast TV rather than for streaming  content over the internet. Conversely, both DASH and SmoothStreaming use the fragmented MP4 (fMP4) container format, which was designed  specifically with streaming content over the internet in mind. M2TS has  many inherent disadvantages compared to fMP4, both for servers and  clients, some of which are summarized by Timothy Siglin’s excellent [white paper](http://download.kennisportal.com/KP/Adobe/UnifyingGlobalVideoStrategies.pdf).
-
-![](https://raw.githubusercontent.com/CharonChui/Pictures/master/hls_suport_use.png)
-
-
-
-在开始一个流媒体会话时，客户端会下载一个包含元数据的extended M3U(m3u8) playlist文件，用于寻找可用的媒体流(将视频分为一个个视频小分片，然后用m3u8索引表进行管理，由于客户端下载到的视频都是5-10秒的完整数据，所以视频的流畅性很好，但是同样也引入了很大的延迟(一般延迟在10-30s左右))。
-
-上面提到了m3u8，那m3u8构成是？直播中m3u8、ts如何实时更新？      
-
-- 是一个索引地址/播放列表，通过FFmpeg将本地的xxx.mp4进行切片处理，生成m3u8播放列表（索引文件）和N多个 .ts文件，并将其（m3u8、N个ts）放置在本地搭建好的webServer服务器的指定目录下，我就可以得到一个可以实时播放的网址，我们把这个m3u8地址复制到 VLC 上就可以实时观看！
-  在 HLS 流下，本地视频被分割成一个一个的小切片，一般10秒一个，这些个小切片被 m3u8管理，并且随着终端的FFmpeg 向本地拉流的命令而实时更新，影片进度随着拉流的进度而更新，播放过的片段不在本地保存，自动删除，直到该文件播放完毕或停止，ts 切片会相应的被删除，流停止，影片不会立即停止，影片播放会滞后于拉流一段时间
-
-  
-
-HLS的整体流程为:   
-
-视频源文件 -> 服务器(编码器、流分割器) -> 分发器(索引文件、*.ts) -> 传输网络 -> 客户端
-
-
-
-[HLS的详细介绍](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE/HLS.md)
-
-HDS
----
-`Http Dynamic Streaming`:是一个由Adobe公司模仿HLS协议提出的另一个基于Http的流媒体传输协议(传统流媒体解决方案RTMP+FLV的组合)。其模式与HLS类似，也是索引文件和媒体切片文件结合的下载方式，但是又要比HLS协议更复杂。
-
-Smooth Streaming
----
-
-微软提供的一套解决方案，是IIS的媒体服务扩张，用于支持基于HTTP的自适应串流，它的文件切片为mp4，索引文件为ism/ismc。
-
-
-
-在基于HTTP提供流媒体的方面，到目前为止已经看到了三种方案，苹果的HLS，Adobe HTTP Dynamic Streaming (HDS)和Microsoft Smooth Streaming (MSS)，当然，各家用的协议，格式会不一样。于是MPEG呼吁大家做到一起，聊聊出一个统一的标准。
-
-
-
-DASH
----
-
-DASH(MPEG-DASH)全称为Dynamic Adaptive Streaming over HTTP。是国标标准组MPEG( (Moving Picture Experts Group) 2014年推出的技术标准，主要目标是形成IP网络承载单一格式的流媒体并提供高效与高质量服务的统一方案，解决多制式传输方案(HTTP Live Streaming, Microsoft Smooth Streaming, HTTP Dynamic Streaming)并存格局下的存储与服务能力浪费、运营高成本与复杂度、系统间互操作弱等问题。       
-
-DASH是基于HTTP的动态自适应的比特率流技术，使用的传输协议是TCP，也是把视频分割成一小段一小段， 通过HTTP协议进行传输，客户端得到之后进行播放；不同的是MPEG-DASH支持MPEG-2 TS、MP4等多种格式, 可以将视频按照多种编码切割, 下载下来的媒体格式既可以是ts文件也可以是mp4文件, 所以当客户端加载视频时, 按照当前的网速和支持的编码加载相应的视频片段进行播放.          
-
-因为是分片的，客户端可以自由选择需要播放的媒体分片，可以实现`Adaptive Bitrate Streaming`技术，不同画质内容无缝切换，提供更好的播放体验。        
-
-YouTube采用DASH！其网页端及移动端APP都使用了DASH。
-
-DASH的整个流程:        
-
-内容生成服务器(编码模块、封装模块) -> 流媒体服务器(MPD、媒体文件、HTTP服务器) <-> DASH客户端(控制引擎、媒体引擎、HTTP接入容器)
-
-
-
-[DASH详细介绍](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE/DASH.md)
-
-
-
-![](https://raw.githubusercontent.com/CharonChui/Pictures/master/dash_compare2.png)
-
-
-
-![hls_hds_mss_dash](https://raw.githubusercontent.com/CharonChui/Pictures/master/hls_hds_mss_dash.png)
-
-这么多流媒体协议我该选用哪个？需要说明的是，各种流媒体协议都有其生存的理由，比如监控行业、电信行业IPTV就不能没有RTSP，因为这里面所有的监控应用程序太多基于RTSP；比如目前的直播主协议就是RTMP，主要是因为CDN对RTMP支持的最好；再比如Apple终端市场占有率太高，就不能够不去考虑HLS。
-
- 每一种流媒体协议都有其应用场景，每一种流媒体协议都有其发展的历史原因，每一种流媒体协议都有其自身的优势和不足。所以，我们需要对各种协议的原理、构成、特性都有所了解，才能在自身应用场景中选择出最佳方案。
-
-
-
-参考:  
-
-- [MPEG-DASH vs. Apple HLS vs. Microsoft Smooth Streaming vs. Adobe HDS](https://bitmovin.com/mpeg-dash-vs-apple-hls-vs-microsoft-smooth-streaming-vs-adobe-hds/)
-- [A Survey on Quality of Experience ofHTTP Adaptive Streaming](http://www.comnet.informatik.uni-wuerzburg.de/publikationen/journal-articles/?tx_extbibsonomycsl_publicationlist%5BuserName%5D=uniwue_info3&tx_extbibsonomycsl_publicationlist%5BintraHash%5D=99067f2f003db1689d6ac3880a8e0c22&tx_extbibsonomycsl_publicationlist%5BfileName%5D=jour_126.pdf&tx_extbibsonomycsl_publicationlist%5Baction%5D=download&tx_extbibsonomycsl_publicationlist%5Bcontroller%5D=Document&cHash=92121b0e4d712ba4ccb918e8a1d82c34)
-- [渐进式、HLS、DASH、HDS、RTMP协议](http://www.4u4v.net/liu-mei-ti-xie-yi-hu-lian-wang-shi-pin-fen-fa-xie-yi-jie-shao-jian-jin-shi-hlsdashhdsrtmp-xie-yi.html)
-- [Real-Time Messaging Protocol](https://en.wikipedia.org/wiki/Real-Time_Messaging_Protocol)
-- [HTTP Live Streaming](https://en.wikipedia.org/wiki/HTTP_Live_Streaming)
-- [Streaming Protocols: Everything You Need to Know](https://www.wowza.com/blog/streaming-protocols)
-
-
-
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/FLV.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/FLV.md"
index a404777d..8cf22ef6 100644
--- "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/FLV.md"
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/FLV.md"
@@ -3,15 +3,97 @@ FLV
 
 
 
+FLV封装格式是由一个文件头（FLV header）和很多tag组成（FLV body）组成的二进制文件。Tag中包含了音频数据以及视频数据。FLV的结构如下图所示。
 
+![img](https://img-blog.csdn.net/20160118103525777)
 
+tag又可以分成三类:audio,video,script，分别代表音频流，视频流，脚本流，而每个tag又由tag header和tag data组成。
 
 
 
+#### FLV整体结构图：
 
+![img](https:////upload-images.jianshu.io/upload_images/9078032-4d1e3f09df181782.png?imageMogr2/auto-orient/strip|imageView2/2/w/843)
 
 
 
+#### FLV文件头结构图
+
+   
+
+![img](https:////upload-images.jianshu.io/upload_images/9078032-b0bab07d69f55262.png?imageMogr2/auto-orient/strip|imageView2/2/w/624)
+
+
+
+​    FLV文件头由9bytes组成，前3个bytes是文件类型，总是“FLV”，也就是（0x46 0x4C 0x56）。第4btye是版本号，目前一般是0x01。第5byte是流的信息，倒数第一bit是1表示有视频（0x01），倒数第三bit是1表示有音频（0x4），有视频又有音频就是0x01 | 0x04（0x05），其他都应该是0。最后4bytes表示FLV 头的长度，3+1+1+4 = 9。
+
+２、 FLV body结构分析
+
+​    FLV body由若干个tag 组成。每一个tag第一部分是tag header，tag header长度为11bytes，但是每个tag header前面有4bytes记录着上一个tag的长度。
+
+​    tag结构图：
+
+![img](https:////upload-images.jianshu.io/upload_images/9078032-24c834de3b517f60.png?imageMogr2/auto-orient/strip|imageView2/2/w/853)
+
+​    tag header：
+
+​    １）第1个byte为记录着tag的类型，音频（0x8），视频（0x9），脚本（0x12）；
+
+​    ２）第2到4bytes是数据区的长度，也就是tag data的长度；
+
+​    ３）再后面3个bytes是时间戳，单位是毫秒，类型为0x12则时间戳为0，时间戳控制着文件播放的速度，可以根据音视频的帧率类设置；
+
+​    ４）时间戳后面一个byte是扩展时间戳，时间戳不够长的时候用；
+
+​    ５）最后3bytes是streamID，但是总为0，再后面就是数据区了（tag data），也即是h264的裸流；
+
+​    ６）tag header 长度为1+3+3+1+3=11。
+
+​    音频TagData结构分析：
+
+![img](https:////upload-images.jianshu.io/upload_images/9078032-2339809cce2f8ab0.png?imageMogr2/auto-orient/strip|imageView2/2/w/852)
+
+​    音频参数中各字段的值及其意义如下表所示：
+
+![img](https:////upload-images.jianshu.io/upload_images/9078032-7265d2aa76864647.png?imageMogr2/auto-orient/strip|imageView2/2/w/654)
+
+ 音频参数对照表
+
+​    视频TagData结构：
+
+![img](https:////upload-images.jianshu.io/upload_images/9078032-78db278c8115b2a8.png?imageMogr2/auto-orient/strip|imageView2/2/w/851)
+
+
+
+​    Script TagData结构
+
+​    Script Tag通常被称为Metadata Tag，会放一些关于FLV视频和音频的元数据信息如：duration、width、height等。通常此类型Tag会跟在File Header后面作为第一个Tag出现，而且只有一个。
+
+![img](https:////upload-images.jianshu.io/upload_images/9078032-52b10dcecd85efe9.png?imageMogr2/auto-orient/strip|imageView2/2/w/843)
+
+
+
+​    第一个AMF包：
+
+​    第1个字节表示AMF包类型，一般总是0x02，表示字符串。第2-3个字节为UI16类型值，标识字符串的长度，一般总是 0x000A（“onMetaData”长度）。后面字节为具体的字符串，一般  为“onMetaData”（6F,6E,4D,65,74,61,44,61,74,61）。
+
+所以第一个AMF包总共占13字节。
+
+​    第二个AMF包结构图：
+
+![img](https:////upload-images.jianshu.io/upload_images/9078032-023c79ab3f1c9f83.png?imageMogr2/auto-orient/strip|imageView2/2/w/842)
+
+ 第二个AMF包结构图
+
+​    第1个字节表示AMF包类型，一般总是0x08，表示数组。第2-5个字节为UI32类型值，表示数组元素的个数，后面即为各数组元素的封装。数组元素为元素名称和值组成的对。“数组元素结构”部分是推测，已经确认适用于duration、width、height等常见元素，但并不确认适用于所有元素。常见的数组元素如下表所示。
+
+![img](https:////upload-images.jianshu.io/upload_images/9078032-ca0f9296f78d19e6?imageMogr2/auto-orient/strip|imageView2/2/w/407)
+
+
+
+参考: 
+
+- [flv/video_file_format_spec_v10](https://www.adobe.com/content/dam/acom/en/devnet/flv/video_file_format_spec_v10.pdf)
 
 
 
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/MP4\346\240\274\345\274\217\350\257\246\350\247\243.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/MP4\346\240\274\345\274\217\350\257\246\350\247\243.md"
index aa7cef68..f5021cd2 100644
--- "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/MP4\346\240\274\345\274\217\350\257\246\350\247\243.md"
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/MP4\346\240\274\345\274\217\350\257\246\350\247\243.md"
@@ -7,9 +7,7 @@ MP4的格式稍微比FLV复杂一些，它是通过嵌的方式来实现整个
 
 
 
-
-
-P4视频文件封装格式是基于QuickTime容器格式定义的，因此参考QuickTime的格式定义对理解MP4文件格式很有帮助。MP4文件格式是一个十分开放的容器，几乎可以用来描述所有的媒体结构，MP4文件中的媒体描述与媒体数据是分开的，并且媒体数据的组织也很自由，不一定要按照时间顺序排列，甚至媒体数据可以直接引用其他文件。同时，MP4也支持流媒体。MP4目前被广泛用于封装h.264视频和AAC音频，是高清视频的代表。
+MP4视频文件封装格式是基于QuickTime容器格式定义的，因此参考QuickTime的格式定义对理解MP4文件格式很有帮助。MP4文件格式是一个十分开放的容器，几乎可以用来描述所有的媒体结构，MP4文件中的媒体描述与媒体数据是分开的，并且媒体数据的组织也很自由，不一定要按照时间顺序排列，甚至媒体数据可以直接引用其他文件。同时，MP4也支持流媒体。MP4目前被广泛用于封装h.264视频和AAC音频，是高清视频的代表。
 
  
 
@@ -22,10 +20,6 @@ P4视频文件封装格式是基于QuickTime容器格式定义的，因此参考
 
 
 
-
-
-
-
 MP4文件由若干称为Atom（或称为box）的数据对象组成，每个Atom的起首为四个字节的数据长度（Big Endian）和四个字节的类型标识，数据长度和类型标志都可以扩展，Atom的基本结构是:  
 ```
 [4bytes atom size] [4bytes atom type] [8bytes largesize, if size ==1] [contents of the atom, if any]
@@ -110,36 +104,6 @@ mvhd定义了整个movie的特性，通常包含媒体无关的信息，例如
 
 
 
-
-
-
-
-
-
-https://blog.csdn.net/qq_19923217/article/details/95049837
-
-
-
-https://www.villainhr.com/page/2017/08/21/%E5%AD%A6%E5%A5%BD%20MP4%EF%BC%8C%E8%AE%A9%E7%9B%B4%E6%92%AD%E6%9B%B4%E7%BB%99%E5%8A%9B#fragmented%20MP4
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/TS.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/TS.md"
index 451f6787..e258a1a9 100644
--- "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/TS.md"
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/TS.md"
@@ -3,36 +3,27 @@ TS
 
 
 
-
-
-https://blog.csdn.net/qq_19923217/article/details/94200971
-
-
-
-
-
 TS 全称是 MPEG2-TS，MPEG2-TS 是一种标准容器格式，传输与存储音视频、节目与系统信息协议数据，广泛应用于数字广播系统，我们日常数字机顶盒接收到的就是 TS（Transport Stream，传输流）流。
 
 首先需要先分辨 TS 传输流中几个基本概念
 
-ES（Elementary Stream）：基本流，直接从编码器出来的数据流，可以是编码过的音频、视频或其他连续码流
-PES（Packetized Elementary Streams）：PES 流是 ES 流经过 PES 打包器处理后形成的数据流，在这个过程中完成了将 ES 流分组、加入包头信息 （PTS、DTS 等）操作。PES 流的基本单位是 PES 包，PES 包由包头和 payload 组成
-PS 流（Program Stream）：节目流，PS 流由 PS 包组成，而一个 PS 包又由若干个 PES 包组成。一个 PS 包由具有同一时间基准的一个或多个 PES 包复合合成。
-TS 流（Transport Stream）：传输流，TS 流由固定长度（188 字节）的 TS 包组成，TS 包是对 PES 包的另一种封装方式，同样由具有同一时间基准的一个或多个 PES 包复合合成。PS 包是不固定长度，而 TS 包为固定长度
-
-
-
-
+    ES（Elementary Stream）：基本流，直接从编码器出来的数据流，可以是编码过的音频、视频或其他连续码流
+    PES（Packetized Elementary Streams）：PES 流是 ES 流经过 PES 打包器处理后形成的数据流，在这个过程中完成了将 ES 流分组、加入包头信息 （PTS、DTS 等）操作。PES 流的基本单位是 PES 包，PES 包由包头和 payload 组成
+    PS 流（Program Stream）：节目流，PS 流由 PS 包组成，而一个 PS 包又由若干个 PES 包组成。一个 PS 包由具有同一时间基准的一个或多个 PES 包复合合成。
+    TS 流（Transport Stream）：传输流，TS 流由固定长度（188 字节）的 TS 包组成，TS 包是对 PES 包的另一种封装方式，同样由具有同一时间基准的一个或多个 PES 包复合合成。PS 包是不固定长度，而 TS 包为固定长度。
+    
+    为便于传输，实现时分复用，基本流 ES 必须打包，就是将顺序连续、连续传输的数据流按一定的时间长度进行分割，分割的小段叫做包，因此打包也被称为分组。
 
 MPEG-2 标准中，有两种不同的码流可以输出到信号，一种是节目码流（PS Program Stream），一种是传输流（TS Transport Stream）。
 
 PS 流包结构长度可变，一旦某一 PS 包的同步信息丢失，接收机就无法确认下一包的同步位置，导致信息丢失，因此 PS 流适用于合理可靠的媒体，如光盘（DVD），PS 流的后缀名一般为 vob 或 evo。而 TS 传输流不同，TS 流的包结构为固定长度（一般为 188 字节），当传输误码破坏了某一 TS 包的同步信息时，接收机可在固定的位置检测它后面包中的同步信息，从而恢复同步，避免信息丢失，因此 TS 可适用于不太可靠的传输，即地面或卫星传播，TS 流的后缀一般为 ts、mpg、mpeg。
 
+    由于 TS 码流具有较强的抵抗传输误码的能力，因此目前在传输媒体中进行传输的 MPEG-2 码流基本上都采用了 TS
 
+2 基本流程
+2.1 TS 流形成过程
 
-由于 TS 码流具有较强的抵抗传输误码的能力，因此目前在传输媒体中进行传输的 MPEG-2 码流基本上都采用了 TS
-
-
+image
 
 以电视数字信号为例：
 1) 原始音视频数据经过压缩编码得到基本流 ES 流
@@ -49,10 +40,29 @@ PES 包的长度通常都是远大于 TS 包的长度，一个 PES 包必须由
 
 将 PES 包内容分配到一系列固定长度的传输包（TS Packet）中。TS 流中 TS 传输包头加入了 PCR（节目参考时钟）与 PSI（节目专用信息），其中 PCR 用于解码器的系统时钟恢复。
 
+image
+
+    PCR 时钟作用：我们知道，编码器中有一个系统时钟，用于产生指示音视频正确显示和解码的时间标签（DTS、PTS）。解码器在解码时首先利用 PCR 时钟重建与编码器同步的系统时钟，再利用 PES 流中的 DTS、PTS 进行音视频的同步。
+
+4) 连续输出传输包形成具有恒定比特率的 MPEG-TS 流
+2.2 TS 流解析过程
+1) 从复用的 MPEG-TS 流中解析出 TS 包
+2) 从 TS 包中获取 PAT 及节目对应的 PMT，解析获取音视频
+
+首先简单了解一下什么是 PSI，后面会通过例子更详细的介绍。
 
+PSI 是节目特定信息，该表格信息用来描述传送流的组成结构。PSI 信息由四种类型的表组成，包括节目关联表（PAT，Program Association Table）、节目映射表（PMT，Program Map Table）、条件接收表（CAT）、网络信息表（NIT）。PAT 与 PMT 两张表帮助我们找到该传送流中的所有节目与流，PAT 告诉我们，TS 流是由哪些节目组成，每个节目的节目映射表 PMT 的 PID 是什么，而 PMT 告诉我们，该节目由哪些流组成，每一路流的类型与 PID 是什么。CAT 与 NIT 暂时不考虑。
 
+image
 
+从图中 PAT 表中可以获取该 TS 流中包含哪些节目，并通过 PAT 表中具体节目的 PMT 表 PID 值（如节目 0 对应 17 PMT PID），找到该节目对应的 PMT 表，而有了 PMT 表我们就知道该节目有哪些流以及流的类型（视频、音频等），进而获取到音视频流对应的 PID。
+3) 通过 PID 筛选出特定音视频流的 TS 包，并解析出 PES
+4) 从 PES 中读取到 PTS/DTS，并从 PES 中解析出基本码流 ES
+5) 将 ES 交给解码器解码
+3 TS 格式
+3.1 TS 包格式
 
+TS 包主要由两部分组成，一个是 4 字节的包头信息，二是有效负载，另外由于每个包固定需要 188 字节，所以中间有可能需要插入自适应调整字段。其中有效负载包括 PSI（节目专用信息）、PES（打包后的基本流）及其他业务信息。
 
 
 
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/fMP4 vs ts.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/fMP4 vs ts.md"
index f39c7036..1e1017b1 100644
--- "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/fMP4 vs ts.md"	
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/fMP4 vs ts.md"	
@@ -55,40 +55,12 @@ CENC使用的就是fMP4格式，这是利用了fMP4中音视频可以不复用
 
 
 
-
-
-MPEG-TS is designed for live streaming of events over DVB, UDP multicast, but also over HTTP.  It divides the stream in elementary streams, which are segmented in small chunks. System information is sent at regular intervals, so the receiver can start playing the stream any time.
-
-MPEG-TS isn't good for streaming files, because it doesn't provide info about the  duration of the movie or song, as well as the points you can seek to.
-
-
-
 ## 主要说了以下几点:
 
 - .ts文件不提供关于时长等信息，你无法在ts文件里去实现音视频的seek操作
 - .mp4不同于ts，是提供了时长等信息，可以执行seek到指定位置
 - .ts文件一般用于m3u8中, 或者提供了流媒体基础信息的前提下使用
-- .mp4文件可以在不下载完全媒体文件的前提下进行seek操作;因为其头部记录moov信息(`moov box 中包含编码、分辨率、码率、帧率、时长、音频采样率等等媒体信息`)
-
-
-
-
-
-https://www.itdaan.com/blog/2018/06/09/8e4ec0afb362459fc6abe8112e82a789.html
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+- .mp4文件可以在不下载完全媒体文件的前提下进行seek操作;因为其头部记录moov信息(moov box 中包含编码、分辨率、码率、帧率、时长、音频采样率等等媒体信息)
 
 
 
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/fMP4\346\240\274\345\274\217\350\257\246\350\247\243.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/fMP4\346\240\274\345\274\217\350\257\246\350\247\243.md"
index 232f8b0e..539663d5 100644
--- "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/fMP4\346\240\274\345\274\217\350\257\246\350\247\243.md"
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/fMP4\346\240\274\345\274\217\350\257\246\350\247\243.md"
@@ -14,41 +14,43 @@ fmp4 是基于 MPEG-4 Part 12 的**流媒体格式**。与普通MP4相比：
 
 
 
-![img](https://bitmovin.com/wp-content/uploads/2019/07/image7.png)
 
-https://bitmovin.com/wp-content/uploads/2019/07/image7.png
 
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/mp4_container_format.webp?raw=true)
 
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/fmp4_format.png?raw=true)
 
 
 
+Fragmented MP4 以 Fragment 的方式存储视频信息。每个 Fragment 由一个 moof box 和一个 mdat box 组成: 
 
+- ‘mdat’（media data box）
 
-![](https://upload-images.jianshu.io/upload_images/9570401-03569f6101ecfeea.png?imageMogr2/auto-orient/strip|imageView2/2/w/520)
+    和普通MP4文件的‘mdat’一样，用于存放媒体数据，不同的是普通MP4文件只有一个‘mdat’box，而Fragmented MP4文件中，每个fragment都会有一个‘mdat’类型的box。
 
+- ‘moof’（movie fragment box）
 
+    该类型的box存放的是fragment-level的metadata信息，用于描述所在的fragment。该类型的box在普通的MP4文件中是不存在的，而在Fragmented MP4文件中，每个fragment都会有一个‘moof’类型的box。moof和moov非常像，它包含了当前片段中mp4的相关元信息。
 
-Fragmented MP4 以 Fragment 的方式存储视频信息。每个 Fragment 由一个 moof box 和一个 mdat box 组成。
+一个‘moof’和一个‘mdat’组成Fragmented MP4文件的一个fragment，这个fragment包含一个video track或audio track，并且包含足够的metadata以保证这部分数据可以单独解码。Fragmented MP4 中的 moov box 只存储文件级别的媒体信息，因此 moov box 的体积比传统的 MP4 中的 moov box 体积要小很多。
 
-（2）‘mdat’（media data box）
 
-和普通MP4文件的‘mdat’一样，用于存放媒体数据，不同的是普通MP4文件只有一个‘mdat’box，而Fragmented MP4文件中，每个fragment都会有一个‘mdat’类型的box。
 
-（3）‘moof’（movie fragment box）
+![fmp4_parser](https://raw.githubusercontent.com/CharonChui/Pictures/master/fmp4_parser.png?raw=true)
 
-该类型的box存放的是fragment-level的metadata信息，用于描述所在的fragment。该类型的box在普通的MP4文件中是不存在的，而在Fragmented MP4文件中，每个fragment都会有一个‘moof’类型的box。
 
-一个‘moof’和一个‘mdat’组成Fragmented MP4文件的一个fragment，这个fragment包含一个video track或audio track，并且包含足够的metadata以保证这部分数据可以单独解码。
 
-A fragment consists of a Movie Fragment  Box (moof), which is very similar to a Movie Box (moov). It contains the information about the media streams contained in one single fragment.  E.g. it contains the timestamp information for the 10 seconds of video,  which are stored in the fragment. Each fragment has its own Media Data  (mdat) box. 
+### FMP4与普通MP4 BOX的区别
 
+#### Movie Extends Box (mvex)(fMP4专有)
 
+**mvex 是 fMP4 的标准盒子。它的作用是告诉解码器这是一个fMP4的文件，具体的 samples 信息内容不再放到 trak 里面，而是在每一个 moof 中**。基本格式为：
 
 
 
-Fragmented MP4 中的 moov box 只存储文件级别的媒体信息，因此 moov box 的体积比传统的 MP4 中的 moov box 体积要小很多。
-
+### moof
 
+moof 主要是用来存放 FMP4 的相关内容。它本身没啥太多的内容。
 
 
 
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217.md"
index 79860fd7..612262dc 100644
--- "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217.md"
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217.md"
@@ -1,182 +1,101 @@
 视频封装格式
 ===
 
-音视频组成
-一个完整的视频文件，包括音频、视频和基础元信息，我们常见的视频文件如mp4、mov、flv、avi、rmvb等视频文件，就是一个容器的封装，里面包含了音频和视频两部分，并且都是通过一些特定的编码算法，进行编码压缩过后的。
-H264、Xvid等就是视频编码格式，MP3、AAC等就是音频编码格式。例如：将一个Xvid视频编码文件和一个MP3音频编码文件按AVI封装标准封装以后，就得到一个AVI后缀的视频文件。
-因此，视频转换需要设置的本质就是
-
-设置需要的视频编码
-设置需要的音频编码
-选择需要的容器封装
-
-一个完整的视频转换设置都至少包括了上面3个步骤。
-
-
-
-编码格式
-音频编码格式
-音频编码格式有如下
-
-AAC
-AMR
-PCM
-ogg(ogg vorbis音频)
-AC3(DVD 专用音频编码)
-DTS(DVD 专用音频编码)
-APE(monkey’s 音频)
-AU(sun 格式)
-WMA
-
-音频编码方案之间音质比较（AAC，MP3，WMA等）结果： AAC+ > MP3PRO > AAC> RealAudio > WMA > MP3
-目前最常见的音频格式有 Mp3、AC-3、ACC，MP3最广泛的支持最多，AC-3是杜比公司的技术，ACC是MPEG-4中的音频标准，ACC是目前比较先进和具有优势的技术。对应入门，知道有这几种最常见的音频格式足以。
-视频编码格式
-视频编码标准有两大系统： MPEG 和ITU-T，国际上制定视频编解码技术的组织有两个，一个是“国际电联（ITU-T）”，它制定的标准有H.261、H.263、H.263+、H.264等，另一个是“国际标准化组织（ISO）”它制定的标准有MPEG-1、MPEG-2、MPEG-4等。
-常见编码格式有：
-
-Xvid(MPEG4)
-H264 （目前最常用编码格式）
-H263
-MPEG1，MPEG2
-AC-1
-RM，RMVB
-H.265（目前用的不够多）
-
-目前最常见的视频编码方式的大致性能排序基本是： MPEG-1/-2 < WMV/7/8 < RM/RMVB < Xvid/Divx < AVC/H.264（由低到高，可能不完全准确）。
-在H.265出来之前，H264是压缩率最高的视频压缩格式，其优势有:
-
-低码率（Low Bit Rate）：和MPEG2和MPEG4 ASP等压缩技术相比，在同等图像质量下，采用H.264技术压缩后的数据量只有MPEG2的1/8，MPEG4的1/3。
-高质量的图象 ：H.264能提供连续、流畅的高质量图象（DVD质量）。
-容错能力强   ：H.264提供了解决在不稳定网络环境下容易发生的丢包等错误的必要工具。
-网络适应性强 ：H.264提供了网络抽象层（Network Abstraction Layer），使得H.264的文件能容易地在不同网络上传输（例如互联网，CDMA，GPRS，WCDMA，CDMA2000等）。
 
-H.264最大的优势是具有很高的数据压缩比率，在同等图像质量的条件下，H.264的压缩比是MPEG-2的2倍以上，是MPEG-4的1.5～2倍。举个例子，原始文件的大小如果为88GB，采用MPEG-2压缩标准压缩后变成3.5GB，压缩比为25∶1，而采用H.264压缩标准压缩后变为879MB，从88GB到879MB，H.264的压缩比达到惊人的102∶1。低码率（Low Bit Rate）对H.264的高的压缩比起到了重要的作用，和MPEG-2和MPEG-4 ASP等压缩技术相比，H.264压缩技术将大大节省用户的下载时间和数据流量收费。尤其值得一提的是，H.264在具有高压缩比的同时还拥有高质量流畅的图像，正因为如此，经过H.264压缩的视频数据，在网络传输过程中所需要的带宽更少，也更加经济。
-目前这些常见的视频编码格式实际上都属于有损压缩，包括H264和H265，也是有损编码，有损编码才能在质量得以保证的前提下得到更高的压缩率和更小体积
-存储封装格式
-目前市面常见的存储封装格式有如下：
-
-AVI (.avi)
-ASF（.asf)
-WMV (.wmv)
-QuickTime ( .mov)
-MPEG (.mpg / .mpeg)
-MP4 (.mp4)
-m2ts （.m2ts / .mts )
-Matroska （.mkv / .mks / .mka )
-RM ( .rm / .rmvb)
-TS/PS
+一个完整的视频文件，包括音频、视频和基础元信息，我们常见的视频文件如mp4、mov、flv、avi、rmvb等视频文件，就是一个容器的封装，里面包含了音频和视频两部分，并且都是通过一些特定的编码算法，进行编码压缩过后的。
 
+例如：将一个Xvid视频编码文件和一个MP3音频编码文件按AVI封装标准封装以后，就得到一个AVI后缀的视频文件。
 
 
-## 常见格式
 
 
+## 音频编码格式
 
-[AVI](https://baike.baidu.com/item/AVI/213655)：微软在90年代初创立的封装标准，是当时为对抗quicktime格式（mov）而推出的，只能支持固定[CBR](https://baike.baidu.com/item/CBR/1022793)[恒定比特率](https://baike.baidu.com/item/恒定比特率/5926922)编码的声音文件。
+#### 音频编码格式有如下:
 
-[FLV](https://baike.baidu.com/item/FLV/6623513)：针对于[h.263](https://baike.baidu.com/item/h.263/2539746)家族的格式。
+- AAC
+- AMR
+- PCM
+- ogg(ogg vorbis音频)
+- AC3(DVD 专用音频编码)
+- DTS(DVD 专用音频编码)
+- APE(monkey’s 音频)
+- AU(sun 格式)
+- WMA
 
-MKV：万能封装器，有良好的兼容和跨平台性、纠错性，可带 [外挂字幕](https://baike.baidu.com/item/外挂字幕)。
+音频编码方案之间音质比较（AAC，MP3，WMA等）结果： 
 
-MOV：MOV是Quicktime封装。
+AAC+ > MP3PRO > AAC> RealAudio > WMA > MP3
+目前最常见的音频格式有 Mp3、AC-3、ACC，MP3最广泛的支持最多，AC-3是杜比公司的技术，ACC是MPEG-4中的音频标准，ACC是目前比较先进和具有优势的技术。对应入门，知道有这几种最常见的音频格式足以。
 
-MP4：主要应用于mpeg4的封装 。
+## 视频编码格式
 
-RM/[RMVB](https://baike.baidu.com/item/RMVB/229903)：Real Video，由[RealNetworks](https://baike.baidu.com/item/RealNetworks/1987003)开发的应用于[rmvb](https://baike.baidu.com/item/rmvb/229903)和rm 。
+视频编码标准有两大系统：
 
-TS/PS：PS封装只能在HDDVD原版。
+- “国际电联（ITU-T）”，它制定的标准有H.261、H.263、H.263+、H.264等，
+- “国际标准化组织（ISO）”它制定的标准有MPEG-1、MPEG-2、MPEG-4等。
 
-[WMV](https://baike.baidu.com/item/WMV/1195900)：微软推出的，作为市场竞争。
+#### 常见编码格式有：
 
+- Xvid(MPEG4)
 
+- H265
 
-Q:[b]为什么把flv叫做流式文件格式？ 和mp4，avi不是一样都是音视频的容器吗？ 有什么区别？[/b]
-一下是我收集的几种解释,每个人有不同的理解,把这些都看一遍,你会理解的更加清晰
+- H264 
 
-[quote]通常说的流式文件是可以边传边解的，开始不需要整个文件。特点是有文件头信息（这个不是必需的）和中间打包了，可以直接解析分包，而且文件可以任意大小，而不需要通过索引分包。FLV，MPEG，RMVB等都可以直接依次分包解析，而MP4，AVI一定要依赖索引表才行，而且开始就要固定位置好，如果索引表在尾部，还没办法解析。[/quote]
+- H263
 
+- MPEG1，MPEG2
 
-[quote]流媒体文件是指多媒体文件边下载可以边观看的文件。而传统的视频文件需下载完成才能观看，而流媒体主要是下载一部分文件到缓存区，然后再从缓存区里面拿数据~而能作为这种流媒体文件的只有经过特殊编码的格式才适合，而flv、rmvb、mov、asf等格式文件才属于流媒体格式文件~[/quote]
+- AC-1
 
-[quote]对于HTTP协议，流式文件可以使用HTTP分段下载，由于在前面的先播放，所以可以一边下载一边播放，但是对于容器格式的文件，由于客户端不知道如何对文件解析(必须拿到整个文件才能解析)，所以不能边下载边播放。
-要实现对容器格式的文件的在线播放，必须要服务器支持流式播放接口，例如RTSP协议[/quote]
+- RM，RMVB
 
+    
 
+目前最常见的视频编码方式的大致性能排序基本是：
 
+ MPEG-1/-2 < WMV/7/8 < RM/RMVB < Xvid/Divx < AVC/H.264（由低到高，可能不完全准确）。
 
+在H.265出来之前，H264是压缩率最高的视频压缩格式，其优势有:
 
-```
-1、mkv：mkv不等同于音频或视频编码格式，它只是为这些进行过音视频编码的数据提供了一个封装的格式，简单的说就是指定音视频数据在文件中如何排列放置。
-MKV最大的特点就是能容纳多种不同类型编码的视频、音频及字幕流，俗称万能媒体容器。
-MKV加入AVI所没有的EDC错误检测代码，这意味着即使是没有下载完毕的MKV文件也可以顺利回放，这些对AVI来说完全是不可想象的。虽然MKV加入了错误检测代码，但由于采用了新的更高效的组织结构，用MKV封装后的电影还是比AVI源文件要小了约1%，这就是说即使加上了多个字幕，MKV文件的体积也不可能比AVI文件大。
-MKV支持可变帧率，它可在动态画面中使用较大的帧率，而在静态画面中使用较小的帧率，这样可以有效的减少视频文件的体积，并改善动态画面的质量。它的作用比目前广泛使用的VBR（可变码率）更为明显。
+- 低码率（Low Bit Rate）：和MPEG2和MPEG4 ASP等压缩技术相比，在同等图像质量下，采用H.264技术压缩后的数据量只有MPEG2的1/8，MPEG4的1/3。
+- 高质量的图象 ：H.264能提供连续、流畅的高质量图象（DVD质量）。
+- 容错能力强   ：H.264提供了解决在不稳定网络环境下容易发生的丢包等错误的必要工具。
+- 网络适应性强 ：H.264提供了网络抽象层（Network Abstraction Layer），使得H.264的文件能容易地在不同网络上传输（例如互联网，CDMA，GPRS，WCDMA，CDMA2000等）。
 
-2、avi   可容纳多种类型的音频和视频流，他的封装格式比较老了，在功能上不能像mkv那样满足更多的需求
+H.264最大的优势是具有很高的数据压缩比率，在同等图像质量的条件下，H.264的压缩比是MPEG-2的2倍以上，是MPEG-4的1.5～2倍。举个例子，原始文件的大小如果为88GB，采用MPEG-2压缩标准压缩后变成3.5GB，压缩比为25∶1，而采用H.264压缩标准压缩后变为879MB，从88GB到879MB，H.264的压缩比达到惊人的102∶1。低码率（Low Bit Rate）对H.264的高的压缩比起到了重要的作用，和MPEG-2和MPEG-4 ASP等压缩技术相比，H.264压缩技术将大大节省用户的下载时间和数据流量收费。尤其值得一提的是，H.264在具有高压缩比的同时还拥有高质量流畅的图像，正因为如此，经过H.264压缩的视频数据，在网络传输过程中所需要的带宽更少，也更加经济。
+目前这些常见的视频编码格式实际上都属于有损压缩，包括H264和H265，也是有损编码，有损编码才能在质量得以保证的前提下得到更高的压缩率和更小体积。 
 
-3、rmvb  是rm的升级版本，vb代表变比特率，意思是在画面平缓的时候采用低比特率，画面变化剧烈的时候采用高比特率，有效降低文件尺寸，又不影响太多画质。一般来说，一个700MB的 DVDrip 采用平均比特率为450Kbps的压缩率，生成的 RMVB 大小仅为400MB，但是画质并没有太大变化。但是由于编码器的关系，在画质上还是略输于h.264，所以现在压缩高清视频时更偏重于使用mkv封装。
+## 存储封装格式
+目前市面常见的存储封装格式有如下：
 
-4、mp4   视频MP4格式实际上指的是使用MPEG-4编码格式、或使用MPEG-4衍生出来的编码格式进行编码的文件，比如DivX、XviD、H.263、H.264、 MS MPEG-4 3688 、 Microsoft Video1 、Microsoft RLE，此种文件格式功能不如mkv丰富。
+- AVI (.avi)
+- ASF（.asf)
+- WMV (.wmv)
+- QuickTime ( .mov)
+- MPEG (.mpg / .mpeg)
+- MP4 (.mp4)
+- m2ts （.m2ts / .mts )
+- Matroska （.mkv / .mks / .mka )
+- RM ( .rm / .rmvb)
+- TS/PS
+- FLV
 
-5、flv    FLV文件体积小巧，清晰的FLV视频1分钟在1MB左右，一部电影在100MB左右，是普通视频文件体积的1/3。再加上CPU占有率低、视频质量良好等特点使其在网络上盛行，目前网上的几家著名视频共享网站均采用FLV格式文件提供视频
 
-6、wmv   WMV是微软推出的一种流媒体格式，它是在“同门”的ASF（AdvancedStreamFormat）格式升级延伸来得。在同等视频质量下，WMV格式的文件可以边下载边播放，因此很适合在网上播放和传输。
-可是由于微软本身的局限性其WMV的应用发展并不顺利。第一, WM9是微软的产品它必定要依赖着Windows，Windows 意味着解码部分也要有PC，起码要有PC机的主板。这就大大增加了机顶盒的造价，从而影响了视频广播点播的普及。第二，WMV技术的视频传输延迟非常大，通常要10几秒钟，正是由于这种局限性，目前WMV也仅限于在计算机上浏览WM9视频文件。
-```
 
 
 
+- 为什么把flv叫做流式文件格式？ 和mp4，avi不是一样都是音视频的容器吗？ 有什么区别？
 
+    通常说的流式文件是可以边传边解的，开始不需要整个文件。特点是有文件头信息（这个不是必需的）和中间打包了，可以直接解析分包，而且文件可以任意大小，而不需要通过索引分包。FLV，MPEG，RMVB等都可以直接依次分包解析，而MP4，AVI一定要依赖索引表才行，而且开始就要固定位置好，如果索引表在尾部，还没办法解析。
 
-对于相同的音视频内容，使用三种不同的封装格式，则文件体积从大到小依次为
+    流媒体文件是指多媒体文件边下载可以边观看的文件。而传统的视频文件需下载完成才能观看，而流媒体主要是下载一部分文件到缓存区，然后再从缓存区里面拿数据~而能作为这种流媒体文件的只有经过特殊编码的格式才适合，而flv、rmvb、mov、asf等格式文件才属于流媒体格式文件
 
-TS -> MP4 -> FLV
+对于相同的音视频内容，使用三种不同的封装格式，则文件体积从大到小依次为：  TS -> MP4 -> FLV
 
  FLV和MP4封装格式的文件大小基本相等。
 
-例如：对于同一个文件，采用相同的编码设置，封装为不同的格式
-
-[root@localhost ffmpeg-2.1.1]# ffmpeg -i test_wei.flv -t 10 -vcodec libx264 -x264opts keyint=24 -acodec libfaac -r 24 -y output10s.ts
-
- 
-
- 
-
-[root@localhost ffmpeg-2.1.1]# ffmpeg -i test_wei.flv -t 10 -vcodec libx264 -x264opts keyint=24 -acodec libfaac -r 24 -y output10s.flv
-
- 
-
-[root@localhost ffmpeg-2.1.1]# ffmpeg -i test_wei.flv -t 10 -vcodec libx264 -x264opts keyint=24 -acodec libfaac -r 24 -y output10s.mp4
-
- 
-
- 
-
-[root@localhost ffmpeg-2.1.1]# ll
-
--rw-r--r-- 1 root root **1354272** Apr 18 11:06 output10s.flv
-
--rw-r--r-- 1 root root **1355649** Apr 18 11:07 output10s.mp4
-
--rw-r--r-- 1 root root **1492156** Apr 18 11:04 output10s.ts
-
-
-
-
-
-## 封装格式与编码方式的对应
-
-
-
-AVI：可用[MPEG-2](https://baike.baidu.com/item/MPEG-2/214322), DIVX, XVID, WMV3, WMV4, WMV9, H.264
-
-WMV：可用WMV3, WMV4, WMV9
-
-RM/[RMVB](https://baike.baidu.com/item/RMVB/229903)：可用RV40, RV50, RV60, RM8, RM9, RM10
-
-MOV：可用MPEG-2, MPEG4-ASP([XVID](https://baike.baidu.com/item/XVID/567063)), H.264
-
-MKV：可用所有[视频编码](https://baike.baidu.com/item/视频编码)方案
-
 
 
 

From 3b91efe8c4c884bdf2c0a7dbdceb0b393e9f6527 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 11 Jun 2020 20:45:07 +0800
Subject: [PATCH 023/213] update readme

---
 README.md | 40 ++++++++++++++++++++++++++++++++++------
 1 file changed, 34 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index ae74c648..50ed2ded 100644
--- a/README.md
+++ b/README.md
@@ -54,20 +54,34 @@ Android学习笔记
     - [DLNA简介][24]
     - [AudioTrack简介][214]
     - [流媒体协议][224]
-        - [流媒体通信协议][246]
+        - [流媒体协议][246]
         - [HLS][247]
         - [DASH][248]
+        - [HTTP FLV][249]
+        - [RTMP][250]
     - [ExoPlayer][216]
         - [1. ExoPlayer简介.md][217]
         - [2. ExoPlayer MediaSource简介][218]
         - [3. ExoPlayer源码分析之prepare方法][219]
         - [4. ExoPlayer源码分析之prepare序列图][220]
         - [5. ExoPlayer源码分析之PlayerView][221]
-    - [MP4格式详解][225]
+    - [视频封装格式][225]
+        - [MP4格式详解][251]
+        - [FLV][252]
+        - [TS][253]
+        - [fMP4 vs ts][254]
+        - [fMP4格式详解][255]
+        - [视频封装格式][256]
+    - [视频编码][257]
+        - [AV1][258]
+        - [H264][259]
+        - [H265][260]
     - [SurfaceView与TextureView][226]
     - [关键帧][227]
     - [CDN及PCDN][228]
-    - [P2P][229]
+    - [P2P技术][229]
+        - [P2P][261]
+        - [P2P原理_NAT穿透][262]
     - [播放器性能优化][230]
     - [MediaExtractor、MediaCodec、MediaMuxer][245]
     - [OpenGL][231]
@@ -503,11 +517,11 @@ Android学习笔记
 [222]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E5%8F%8D%E7%BC%96%E8%AF%91.md "反编译"
 [223]: https://github.com/CharonChui/AndroidNote/blob/master/Tools%26Library/Icon%E5%88%B6%E4%BD%9C.md "Icon制作"
 [224]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE "流媒体协议"
-[225]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/MP4%E6%A0%BC%E5%BC%8F%E8%AF%A6%E8%A7%A3.md "MP4格式详解"
+[225]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/%E8%A7%86%E9%A2%91%E5%B0%81%E8%A3%85%E6%A0%BC%E5%BC%8F "视频封装格式"
 [226]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/SurfaceView%E4%B8%8ETextureView.md "SurfaceView与TextureView"
 [227]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E5%85%B3%E9%94%AE%E5%B8%A7.md "关键帧"
 [228]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/CDN%E5%8F%8APCDN.md "CDN及PCDN"
-[229]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/P2P.md "P2P"
+[229]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/P2P%E6%8A%80%E6%9C%AF "P2P"
 [230]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%92%AD%E6%94%BE%E5%99%A8%E6%80%A7%E8%83%BD%E4%BC%98%E5%8C%96.md "播放器性能优化"
 [231]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/OpenGL  "OpenGL"
 [232]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/1.OpenGL%E7%AE%80%E4%BB%8B.md  "1.OpenGL简介"
@@ -525,9 +539,23 @@ Android学习笔记
 [243]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/Danmaku "弹幕"
 [244]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/Danmaku/Android%E5%BC%B9%E5%B9%95%E5%AE%9E%E7%8E%B0.md "Android弹幕实现"
 [245]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/MediaExtractor%E3%80%81MediaCodec%E3%80%81MediaMuxer.md "MediaExtractor、MediaCodec、MediaMuxer"
-[246]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE/%E6%B5%81%E5%AA%92%E4%BD%93%E9%80%9A%E4%BF%A1%E5%8D%8F%E8%AE%AE.md "流媒体通信协议"
+[246]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE.md  "流媒体协议"
 [247]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE/HLS.md "HLS"
 [248]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE/DASH.md "DASH"
+[249]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE/HTTP%20FLV.md "HTTP FLV"
+[250]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE/DASH.md "RTMP"
+[251]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E8%A7%86%E9%A2%91%E5%B0%81%E8%A3%85%E6%A0%BC%E5%BC%8F/MP4%E6%A0%BC%E5%BC%8F%E8%AF%A6%E8%A7%A3.md "MP4格式详解"
+[252]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E8%A7%86%E9%A2%91%E5%B0%81%E8%A3%85%E6%A0%BC%E5%BC%8F/FLV.md "FLV"
+[253]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E8%A7%86%E9%A2%91%E5%B0%81%E8%A3%85%E6%A0%BC%E5%BC%8F/TS.md "TS"
+[254]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E8%A7%86%E9%A2%91%E5%B0%81%E8%A3%85%E6%A0%BC%E5%BC%8F/fMP4%20vs%20ts.md "fMP4 vs ts"
+[255]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E8%A7%86%E9%A2%91%E5%B0%81%E8%A3%85%E6%A0%BC%E5%BC%8F/fMP4%E6%A0%BC%E5%BC%8F%E8%AF%A6%E8%A7%A3.md "fMP4格式详解"
+[256]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E8%A7%86%E9%A2%91%E5%B0%81%E8%A3%85%E6%A0%BC%E5%BC%8F/%E8%A7%86%E9%A2%91%E5%B0%81%E8%A3%85%E6%A0%BC%E5%BC%8F.md "视频封装格式"
+[257]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/%E8%A7%86%E9%A2%91%E7%BC%96%E7%A0%81  "视频编码"
+[258]:https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E8%A7%86%E9%A2%91%E7%BC%96%E7%A0%81/AV1.md   "AV1"
+[259]:https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E8%A7%86%E9%A2%91%E7%BC%96%E7%A0%81/H264.md  "H264"
+[260]:https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E8%A7%86%E9%A2%91%E7%BC%96%E7%A0%81/H265.md  "H265"
+[261]:  https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/P2P%E6%8A%80%E6%9C%AF/P2P.md "P2P"
+[262]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/P2P%E6%8A%80%E6%9C%AF/P2P%E5%8E%9F%E7%90%86_NAT%E7%A9%BF%E9%80%8F.md "P2P原理_NAT穿透"
 
 
 

From 5759f3bdffa2a1f43a9c300fbbe142ab51118ae7 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 11 Jun 2020 21:09:31 +0800
Subject: [PATCH 024/213] update

---
 README.md                                     |  2 +-
 .../HLS.md"                                   | 10 +-
 .../FLV.md"                                   | 34 ++++---
 .../TS.md"                                    | 65 +------------
 ...01\350\243\205\346\240\274\345\274\217.md" |  6 +-
 .../AV1.md"                                   | 90 +-----------------
 .../H265.md"                                  | 92 +------------------
 7 files changed, 37 insertions(+), 262 deletions(-)

diff --git a/README.md b/README.md
index 50ed2ded..766477dd 100644
--- a/README.md
+++ b/README.md
@@ -543,7 +543,7 @@ Android学习笔记
 [247]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE/HLS.md "HLS"
 [248]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE/DASH.md "DASH"
 [249]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE/HTTP%20FLV.md "HTTP FLV"
-[250]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE/DASH.md "RTMP"
+[250]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE/RTMP.md "RTMP"
 [251]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E8%A7%86%E9%A2%91%E5%B0%81%E8%A3%85%E6%A0%BC%E5%BC%8F/MP4%E6%A0%BC%E5%BC%8F%E8%AF%A6%E8%A7%A3.md "MP4格式详解"
 [252]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E8%A7%86%E9%A2%91%E5%B0%81%E8%A3%85%E6%A0%BC%E5%BC%8F/FLV.md "FLV"
 [253]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E8%A7%86%E9%A2%91%E5%B0%81%E8%A3%85%E6%A0%BC%E5%BC%8F/TS.md "TS"
diff --git "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HLS.md" "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HLS.md"
index ed214e94..707b4758 100644
--- "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HLS.md"
+++ "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HLS.md"
@@ -202,11 +202,11 @@ live m3u8文件列表需要不断更新，更新规则：
 
 #### 测试地址:
 
-CCTV1高清：http://ivi.bupt.edu.cn/hls/cctv1hd.m3u8
-CCTV3高清：http://ivi.bupt.edu.cn/hls/cctv3hd.m3u8
-CCTV5高清：http://ivi.bupt.edu.cn/hls/cctv5hd.m3u8
-CCTV5+高清：http://ivi.bupt.edu.cn/hls/cctv5phd.m3u8
-CCTV6高清：http://ivi.bupt.edu.cn/hls/cctv6hd.m3u8
+- CCTV1高清：http://ivi.bupt.edu.cn/hls/cctv1hd.m3u8
+- CCTV3高清：http://ivi.bupt.edu.cn/hls/cctv3hd.m3u8
+- CCTV5高清：http://ivi.bupt.edu.cn/hls/cctv5hd.m3u8
+- CCTV5+高清：http://ivi.bupt.edu.cn/hls/cctv5phd.m3u8
+- CCTV6高清：http://ivi.bupt.edu.cn/hls/cctv6hd.m3u8
 
 
 
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/FLV.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/FLV.md"
index 8cf22ef6..15f1f6e5 100644
--- "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/FLV.md"
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/FLV.md"
@@ -5,7 +5,9 @@ FLV
 
 FLV封装格式是由一个文件头（FLV header）和很多tag组成（FLV body）组成的二进制文件。Tag中包含了音频数据以及视频数据。FLV的结构如下图所示。
 
-![img](https://img-blog.csdn.net/20160118103525777)
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_tag.jpg?raw=true)
+
+
 
 tag又可以分成三类:audio,video,script，分别代表音频流，视频流，脚本流，而每个tag又由tag header和tag data组成。
 
@@ -13,15 +15,19 @@ tag又可以分成三类:audio,video,script，分别代表音频流，视频流
 
 #### FLV整体结构图：
 
-![img](https:////upload-images.jianshu.io/upload_images/9078032-4d1e3f09df181782.png?imageMogr2/auto-orient/strip|imageView2/2/w/843)
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_tag.jpg?raw=true)
+
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_header_tag.png?raw=true)
 
 
 
 #### FLV文件头结构图
 
-   
 
-![img](https:////upload-images.jianshu.io/upload_images/9078032-b0bab07d69f55262.png?imageMogr2/auto-orient/strip|imageView2/2/w/624)
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_tag_2.png?raw=true)   
 
 
 
@@ -33,7 +39,7 @@ tag又可以分成三类:audio,video,script，分别代表音频流，视频流
 
 ​    tag结构图：
 
-![img](https:////upload-images.jianshu.io/upload_images/9078032-24c834de3b517f60.png?imageMogr2/auto-orient/strip|imageView2/2/w/853)
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_body_tag.png?raw=true)   
 
 ​    tag header：
 
@@ -51,17 +57,19 @@ tag又可以分成三类:audio,video,script，分别代表音频流，视频流
 
 ​    音频TagData结构分析：
 
-![img](https:////upload-images.jianshu.io/upload_images/9078032-2339809cce2f8ab0.png?imageMogr2/auto-orient/strip|imageView2/2/w/852)
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_audio_tag.png?raw=true)   
 
 ​    音频参数中各字段的值及其意义如下表所示：
 
-![img](https:////upload-images.jianshu.io/upload_images/9078032-7265d2aa76864647.png?imageMogr2/auto-orient/strip|imageView2/2/w/654)
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_audio_tag2.png?raw=true)   
 
  音频参数对照表
 
 ​    视频TagData结构：
 
-![img](https:////upload-images.jianshu.io/upload_images/9078032-78db278c8115b2a8.png?imageMogr2/auto-orient/strip|imageView2/2/w/851)
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_video_tag.png?raw=true)   
 
 
 
@@ -69,7 +77,9 @@ tag又可以分成三类:audio,video,script，分别代表音频流，视频流
 
 ​    Script Tag通常被称为Metadata Tag，会放一些关于FLV视频和音频的元数据信息如：duration、width、height等。通常此类型Tag会跟在File Header后面作为第一个Tag出现，而且只有一个。
 
-![img](https:////upload-images.jianshu.io/upload_images/9078032-52b10dcecd85efe9.png?imageMogr2/auto-orient/strip|imageView2/2/w/843)
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_script_tag.png?raw=true)   
+
+
 
 
 
@@ -81,13 +91,15 @@ tag又可以分成三类:audio,video,script，分别代表音频流，视频流
 
 ​    第二个AMF包结构图：
 
-![img](https:////upload-images.jianshu.io/upload_images/9078032-023c79ab3f1c9f83.png?imageMogr2/auto-orient/strip|imageView2/2/w/842)
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_awf_tag.png?raw=true)   
 
  第二个AMF包结构图
 
 ​    第1个字节表示AMF包类型，一般总是0x08，表示数组。第2-5个字节为UI32类型值，表示数组元素的个数，后面即为各数组元素的封装。数组元素为元素名称和值组成的对。“数组元素结构”部分是推测，已经确认适用于duration、width、height等常见元素，但并不确认适用于所有元素。常见的数组元素如下表所示。
 
-![img](https:////upload-images.jianshu.io/upload_images/9078032-ca0f9296f78d19e6?imageMogr2/auto-orient/strip|imageView2/2/w/407)
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_amf_tag.jpg?raw=true)   
+
+
 
 
 
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/TS.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/TS.md"
index e258a1a9..c0a2daad 100644
--- "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/TS.md"
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/TS.md"
@@ -3,70 +3,7 @@ TS
 
 
 
-TS 全称是 MPEG2-TS，MPEG2-TS 是一种标准容器格式，传输与存储音视频、节目与系统信息协议数据，广泛应用于数字广播系统，我们日常数字机顶盒接收到的就是 TS（Transport Stream，传输流）流。
-
-首先需要先分辨 TS 传输流中几个基本概念
-
-    ES（Elementary Stream）：基本流，直接从编码器出来的数据流，可以是编码过的音频、视频或其他连续码流
-    PES（Packetized Elementary Streams）：PES 流是 ES 流经过 PES 打包器处理后形成的数据流，在这个过程中完成了将 ES 流分组、加入包头信息 （PTS、DTS 等）操作。PES 流的基本单位是 PES 包，PES 包由包头和 payload 组成
-    PS 流（Program Stream）：节目流，PS 流由 PS 包组成，而一个 PS 包又由若干个 PES 包组成。一个 PS 包由具有同一时间基准的一个或多个 PES 包复合合成。
-    TS 流（Transport Stream）：传输流，TS 流由固定长度（188 字节）的 TS 包组成，TS 包是对 PES 包的另一种封装方式，同样由具有同一时间基准的一个或多个 PES 包复合合成。PS 包是不固定长度，而 TS 包为固定长度。
-    
-    为便于传输，实现时分复用，基本流 ES 必须打包，就是将顺序连续、连续传输的数据流按一定的时间长度进行分割，分割的小段叫做包，因此打包也被称为分组。
-
-MPEG-2 标准中，有两种不同的码流可以输出到信号，一种是节目码流（PS Program Stream），一种是传输流（TS Transport Stream）。
-
-PS 流包结构长度可变，一旦某一 PS 包的同步信息丢失，接收机就无法确认下一包的同步位置，导致信息丢失，因此 PS 流适用于合理可靠的媒体，如光盘（DVD），PS 流的后缀名一般为 vob 或 evo。而 TS 传输流不同，TS 流的包结构为固定长度（一般为 188 字节），当传输误码破坏了某一 TS 包的同步信息时，接收机可在固定的位置检测它后面包中的同步信息，从而恢复同步，避免信息丢失，因此 TS 可适用于不太可靠的传输，即地面或卫星传播，TS 流的后缀一般为 ts、mpg、mpeg。
-
-    由于 TS 码流具有较强的抵抗传输误码的能力，因此目前在传输媒体中进行传输的 MPEG-2 码流基本上都采用了 TS
-
-2 基本流程
-2.1 TS 流形成过程
-
-image
-
-以电视数字信号为例：
-1) 原始音视频数据经过压缩编码得到基本流 ES 流
-
-生成的 ES 基本流比较大，并且只是 I、P、B 这些视频帧或音频取样信息。
-2) 对 ES 基本流 进行打包生成 PES 流
-
-通过 PES 打包器，首先对 ES 基本流进行分组打包，在每一个包前加上包头就构成了 PES 流的基本单位 —— PES 包，对视频 PES 来说，一般是一帧一个包，音频 PES 一般一个包不超过 64KB。
-
-PES 包头信息中加入了 PTS、DTS 信息，用与音视频的同步。
-3) 同一时间基准的 PES 包经过 TS 复用器生成 TS 传输包
-
-PES 包的长度通常都是远大于 TS 包的长度，一个 PES 包必须由整数个 TS 包来传送，没装满的 TS 包由填充字节填充。PES 包进行 TS 复用时，往往一个 PES 包会分存到多个 TS 包中
-
-将 PES 包内容分配到一系列固定长度的传输包（TS Packet）中。TS 流中 TS 传输包头加入了 PCR（节目参考时钟）与 PSI（节目专用信息），其中 PCR 用于解码器的系统时钟恢复。
-
-image
-
-    PCR 时钟作用：我们知道，编码器中有一个系统时钟，用于产生指示音视频正确显示和解码的时间标签（DTS、PTS）。解码器在解码时首先利用 PCR 时钟重建与编码器同步的系统时钟，再利用 PES 流中的 DTS、PTS 进行音视频的同步。
-
-4) 连续输出传输包形成具有恒定比特率的 MPEG-TS 流
-2.2 TS 流解析过程
-1) 从复用的 MPEG-TS 流中解析出 TS 包
-2) 从 TS 包中获取 PAT 及节目对应的 PMT，解析获取音视频
-
-首先简单了解一下什么是 PSI，后面会通过例子更详细的介绍。
-
-PSI 是节目特定信息，该表格信息用来描述传送流的组成结构。PSI 信息由四种类型的表组成，包括节目关联表（PAT，Program Association Table）、节目映射表（PMT，Program Map Table）、条件接收表（CAT）、网络信息表（NIT）。PAT 与 PMT 两张表帮助我们找到该传送流中的所有节目与流，PAT 告诉我们，TS 流是由哪些节目组成，每个节目的节目映射表 PMT 的 PID 是什么，而 PMT 告诉我们，该节目由哪些流组成，每一路流的类型与 PID 是什么。CAT 与 NIT 暂时不考虑。
-
-image
-
-从图中 PAT 表中可以获取该 TS 流中包含哪些节目，并通过 PAT 表中具体节目的 PMT 表 PID 值（如节目 0 对应 17 PMT PID），找到该节目对应的 PMT 表，而有了 PMT 表我们就知道该节目有哪些流以及流的类型（视频、音频等），进而获取到音视频流对应的 PID。
-3) 通过 PID 筛选出特定音视频流的 TS 包，并解析出 PES
-4) 从 PES 中读取到 PTS/DTS，并从 PES 中解析出基本码流 ES
-5) 将 ES 交给解码器解码
-3 TS 格式
-3.1 TS 包格式
-
-TS 包主要由两部分组成，一个是 4 字节的包头信息，二是有效负载，另外由于每个包固定需要 188 字节，所以中间有可能需要插入自适应调整字段。其中有效负载包括 PSI（节目专用信息）、PES（打包后的基本流）及其他业务信息。
-
-
-
-
+TODO 
 
 
 
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217.md"
index 612262dc..8899f1a8 100644
--- "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217.md"
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217.md"
@@ -86,11 +86,11 @@ H.264最大的优势是具有很高的数据压缩比率，在同等图像质量
 
 
 
-- 为什么把flv叫做流式文件格式？ 和mp4，avi不是一样都是音视频的容器吗？ 有什么区别？
+为什么把flv叫做流式文件格式？ 和mp4，avi不是一样都是音视频的容器吗？ 有什么区别？
 
-    通常说的流式文件是可以边传边解的，开始不需要整个文件。特点是有文件头信息（这个不是必需的）和中间打包了，可以直接解析分包，而且文件可以任意大小，而不需要通过索引分包。FLV，MPEG，RMVB等都可以直接依次分包解析，而MP4，AVI一定要依赖索引表才行，而且开始就要固定位置好，如果索引表在尾部，还没办法解析。
+通常说的流式文件是可以边传边解的，开始不需要整个文件。特点是有文件头信息（这个不是必需的）和中间打包了，可以直接解析分包，而且文件可以任意大小，而不需要通过索引分包。FLV，MPEG，RMVB等都可以直接依次分包解析，而MP4，AVI一定要依赖索引表才行，而且开始就要固定位置好，如果索引表在尾部，还没办法解析。
 
-    流媒体文件是指多媒体文件边下载可以边观看的文件。而传统的视频文件需下载完成才能观看，而流媒体主要是下载一部分文件到缓存区，然后再从缓存区里面拿数据~而能作为这种流媒体文件的只有经过特殊编码的格式才适合，而flv、rmvb、mov、asf等格式文件才属于流媒体格式文件
+流媒体文件是指多媒体文件边下载可以边观看的文件。而传统的视频文件需下载完成才能观看，而流媒体主要是下载一部分文件到缓存区，然后再从缓存区里面拿数据~而能作为这种流媒体文件的只有经过特殊编码的格式才适合，而flv、rmvb、mov、asf等格式文件才属于流媒体格式文件
 
 对于相同的音视频内容，使用三种不同的封装格式，则文件体积从大到小依次为：  TS -> MP4 -> FLV
 
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/AV1.md" "b/VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/AV1.md"
index 45aa49ec..39fb1ead 100644
--- "a/VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/AV1.md"
+++ "b/VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/AV1.md"
@@ -1,97 +1,11 @@
-H264
+AV1
 ===
 
 
 
 
 
-H.264是一种高性能的视频编解码技术。目前国际上制定视频编解码技术的组织有两个，一个是“国际电联”，它制定的标准有H.261、H.263、H.263+等，另一个是“国际标准化组织（ISO）”它制定的标准有MPEG-1、MPEG-2、MPEG-4等。而H.264则是由两个组织联合组建的联合视频组（JVT）共同制定的新数字视频编码标准，所以它既是ITU-T的H.264，又是ISO/IEC的MPEG-4高级视频编码，而且它将成为MPEG-4标准的第10部分。因此，不论是MPEG-4 AVC、MPEG-4 Part 10，还是ISO/IEC 14496-10，都是指H.264。
-
-
-
-
-
-## H.264算法的优势
-
-
- H.264是在MPEG-4技术的基础之上建立起来的，其编解码流程主要包括5个部分：帧间和帧内预测、变换和反变换、量化和反量化、环路滤波、熵编码。
-
- H.264/MPEG-4  AVC（H.264）是1995年自MPEG-2视频压缩标准发布以后的最新、最有前途的视频压缩标准。H.264是由ITU-T和ISO/IEC的联合开发组共同开发的最新国际视频编码标准。通过该标准，在同等图象质量下的压缩效率比以前的标准提高了2倍以上，因此，H.264被普遍认为是最有影响力的行业标准。
-
-## H.264的优势
-
-
- H.264在1997年ITU的视频编码专家组提出时被称为H.26L，在ITU与ISO合作研究后被称为MPEG4 Part10或H.264（JVT）。H.264标准的主要目标是：与其它现有的视频编码标准相比，在相同的带宽下提供更加优秀的图象质量。
-
-**而，H.264与以前的国际标准如H.263和MPEG-4相比，最大的优势体现在以下四个方面：**
-
-
-
-- 将每个视频帧分离成由像素组成的块，因此视频帧的编码处理的过程可以达到块的级别。
-- 采用空间冗余的方法，对视频帧的一些原始块进行空间预测、转换、优化和熵编码（可变长编码）。
-- 对连续帧的不同块采用临时存放的方法，这样，只需对连续帧中有改变的部分进行编码。该算法采用运动预测和运动补偿来完成。对某些特定的块，在一个或多个已经进行了编码的帧执行搜索来决定块的运动向量，并由此在后面的编码和解码中预测主块。
-- 采用剩余空间冗余技术，对视频帧里的残留块进行编码。例如：对于源块和相应预测块的不同，再次采用转换、优化和熵编码。
-
-
-**具体优势表现为：**
-
-
-
-- 低码流：和MPEG2和MPEG4 ASP等压缩技术相比，在同等图像质量下，采用H.264技术压缩后的数据量只有MPEG2的1/8，MPEG4的1/3。显然，H.264压缩技术的采用将大大节省用户的下载时间和数据流量收费。
-- 高质量的图象：H.264能提供连续、流畅的高质量图象（DVD质量）。
-- 容错能力强：H.264提供了解决在不稳定网络环境下容易发生的丢包等错误的必要工具。
-- 网络适应性强：H.264提供了网络适应层， 使得H.264的文件能容易地在不同网络上传输（例如互联网，CDMA，GPRS，WCDMA，CDMA2000等）。
-
-
- H.264和以前的标准一样，也是DPCM加变换编码的混合编码模式。但它采用“回归基本”的简洁设计，不用众多的选项，获得比H.263++好得多的压缩性能；加强了对各种信道的适应能力，采用“网络友好”的结构和语法，有利于对误码和丢包的处理；应用目标范围较宽，以满足不同速率、不同解析度以及不同传输（存储）场合的需求。
-
-## H.264标准的关键技术
-
-
-
-### 1 帧内预测编码
-
-
- 帧内编码用来缩减图像的空间冗余。为了提高H.264帧内编码的效率，在给定帧中充分利用相邻宏块的空间相关性，相邻的宏块通常含有相似的属性。因此，在对一给定宏块编码时，首先可以根据周围的宏块预测（典型的是根据左上角的宏块，因为此宏块已经被编码处理），然后对预测值与实际值的差值进行编码，这样，相对于直接对该帧编码而言，可以大大减小码率。
-
-
-
-### 2帧间预测编码
-
-
- 帧间预测编码利用连续帧中的时间冗余来进行运动估计和补偿。H.264的运动补偿支持以往的视频编码标准中的大部分关键特性，而且灵活地添加了更多的功能，除了支持P帧、B帧外，H.264还支持一种新的流间传送帧——SP帧，如图3所示。码流中包含SP帧后，能在有类似内容但有不同码率的码流之间快速切换，同时支持随机接入和快速回放模式。
-
-
-
-### 3整数变换
-
-
- 在变换方面，H.264使用了基于4×4像素块的类似于DCT的变换，但使用的是以整数为基础的空间变换，不存在反变换，因为取舍而存在误差的问题，变换矩阵如图5所示。与浮点运算相比，整数DCT变换会引起一些额外的误差，但因为DCT变换后的量化也存在量化误差，与之相比，整数DCT变换引起的量化误差影响并不大。此外，整数DCT变换还具有减少运算量和复杂度，有利于向定点DSP移植的优点。
-
-
-
-### 4量化
-
-
- H.264中可选32种不同的量化步长，这与H.263中有31个量化步长很相似，但是在H.264中，步长是以12.5%的复合率递进的，而不是一个固定常数。
-
- 在H.264中，变换系数的读出方式也有两种：之字形（Zigzag）扫描和双扫描，如图6所示。大多数情况下使用简单的之字形扫描；双扫描仅用于使用较小量化级的块内，有助于提高编码效率。
-
-
-
-### 5熵编码
-
-
- 视频编码处理的最后一步就是熵编码，在H.264中采用了两种不同的熵编码方法：通用可变长编码（UVLC）和基于文本的自适应二进制算术编码（CABAC）。
-
- 在H.263等标准中，根据要编码的数据类型如变换系数、运动矢量等，采用不同的VLC码表。H.264中的UVLC码表提供了一个简单的方法，不管符号表述什么类型的数据，都使用统一变字长编码表。其优点是简单；缺点是单一的码表是从概率统计分布模型得出的，没有考虑编码符号间的相关性，在中高码率时效果不是很好。
-
- 因此，H.264中还提供了可选的CABAC方法。算术编码使编码和解码两边都能使用所有句法元素（变换系数、运动矢量）的概率模型。为了提高算术编码的效率，通过内容建模的过程，使基本概率模型能适应随视频帧而改变的统计特性。内容建模提供了编码符号的条件概率估计，利用合适的内容模型，存在于符号间的相关性可以通过选择目前要编码符号邻近的已编码符号的相应概率模型来去除，不同的句法元素通常保持不同的模型。
-
-## H.264在实时视频聊天中的应用
-
-
- 目前，H.264已被广泛应用于实时视频应用中，相比以往的方案使得在同等速率下，H.264能够比H.263减小50%的码率。也就是说，用户即使是只利用 384kbit/s的带宽，就可以享受H.263下高达 768kbit/s的高质量视频服务。H.264  不但有助于节省庞大开支，还可以提高资源的使用效率，同时令达到商业质量的实时视频服务拥有更多的潜在客户。
+TODO 
 
 
 
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/H265.md" "b/VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/H265.md"
index 45aa49ec..418dae10 100644
--- "a/VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/H265.md"
+++ "b/VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/H265.md"
@@ -1,97 +1,9 @@
-H264
+H265
 ===
 
 
 
-
-
-H.264是一种高性能的视频编解码技术。目前国际上制定视频编解码技术的组织有两个，一个是“国际电联”，它制定的标准有H.261、H.263、H.263+等，另一个是“国际标准化组织（ISO）”它制定的标准有MPEG-1、MPEG-2、MPEG-4等。而H.264则是由两个组织联合组建的联合视频组（JVT）共同制定的新数字视频编码标准，所以它既是ITU-T的H.264，又是ISO/IEC的MPEG-4高级视频编码，而且它将成为MPEG-4标准的第10部分。因此，不论是MPEG-4 AVC、MPEG-4 Part 10，还是ISO/IEC 14496-10，都是指H.264。
-
-
-
-
-
-## H.264算法的优势
-
-
- H.264是在MPEG-4技术的基础之上建立起来的，其编解码流程主要包括5个部分：帧间和帧内预测、变换和反变换、量化和反量化、环路滤波、熵编码。
-
- H.264/MPEG-4  AVC（H.264）是1995年自MPEG-2视频压缩标准发布以后的最新、最有前途的视频压缩标准。H.264是由ITU-T和ISO/IEC的联合开发组共同开发的最新国际视频编码标准。通过该标准，在同等图象质量下的压缩效率比以前的标准提高了2倍以上，因此，H.264被普遍认为是最有影响力的行业标准。
-
-## H.264的优势
-
-
- H.264在1997年ITU的视频编码专家组提出时被称为H.26L，在ITU与ISO合作研究后被称为MPEG4 Part10或H.264（JVT）。H.264标准的主要目标是：与其它现有的视频编码标准相比，在相同的带宽下提供更加优秀的图象质量。
-
-**而，H.264与以前的国际标准如H.263和MPEG-4相比，最大的优势体现在以下四个方面：**
-
-
-
-- 将每个视频帧分离成由像素组成的块，因此视频帧的编码处理的过程可以达到块的级别。
-- 采用空间冗余的方法，对视频帧的一些原始块进行空间预测、转换、优化和熵编码（可变长编码）。
-- 对连续帧的不同块采用临时存放的方法，这样，只需对连续帧中有改变的部分进行编码。该算法采用运动预测和运动补偿来完成。对某些特定的块，在一个或多个已经进行了编码的帧执行搜索来决定块的运动向量，并由此在后面的编码和解码中预测主块。
-- 采用剩余空间冗余技术，对视频帧里的残留块进行编码。例如：对于源块和相应预测块的不同，再次采用转换、优化和熵编码。
-
-
-**具体优势表现为：**
-
-
-
-- 低码流：和MPEG2和MPEG4 ASP等压缩技术相比，在同等图像质量下，采用H.264技术压缩后的数据量只有MPEG2的1/8，MPEG4的1/3。显然，H.264压缩技术的采用将大大节省用户的下载时间和数据流量收费。
-- 高质量的图象：H.264能提供连续、流畅的高质量图象（DVD质量）。
-- 容错能力强：H.264提供了解决在不稳定网络环境下容易发生的丢包等错误的必要工具。
-- 网络适应性强：H.264提供了网络适应层， 使得H.264的文件能容易地在不同网络上传输（例如互联网，CDMA，GPRS，WCDMA，CDMA2000等）。
-
-
- H.264和以前的标准一样，也是DPCM加变换编码的混合编码模式。但它采用“回归基本”的简洁设计，不用众多的选项，获得比H.263++好得多的压缩性能；加强了对各种信道的适应能力，采用“网络友好”的结构和语法，有利于对误码和丢包的处理；应用目标范围较宽，以满足不同速率、不同解析度以及不同传输（存储）场合的需求。
-
-## H.264标准的关键技术
-
-
-
-### 1 帧内预测编码
-
-
- 帧内编码用来缩减图像的空间冗余。为了提高H.264帧内编码的效率，在给定帧中充分利用相邻宏块的空间相关性，相邻的宏块通常含有相似的属性。因此，在对一给定宏块编码时，首先可以根据周围的宏块预测（典型的是根据左上角的宏块，因为此宏块已经被编码处理），然后对预测值与实际值的差值进行编码，这样，相对于直接对该帧编码而言，可以大大减小码率。
-
-
-
-### 2帧间预测编码
-
-
- 帧间预测编码利用连续帧中的时间冗余来进行运动估计和补偿。H.264的运动补偿支持以往的视频编码标准中的大部分关键特性，而且灵活地添加了更多的功能，除了支持P帧、B帧外，H.264还支持一种新的流间传送帧——SP帧，如图3所示。码流中包含SP帧后，能在有类似内容但有不同码率的码流之间快速切换，同时支持随机接入和快速回放模式。
-
-
-
-### 3整数变换
-
-
- 在变换方面，H.264使用了基于4×4像素块的类似于DCT的变换，但使用的是以整数为基础的空间变换，不存在反变换，因为取舍而存在误差的问题，变换矩阵如图5所示。与浮点运算相比，整数DCT变换会引起一些额外的误差，但因为DCT变换后的量化也存在量化误差，与之相比，整数DCT变换引起的量化误差影响并不大。此外，整数DCT变换还具有减少运算量和复杂度，有利于向定点DSP移植的优点。
-
-
-
-### 4量化
-
-
- H.264中可选32种不同的量化步长，这与H.263中有31个量化步长很相似，但是在H.264中，步长是以12.5%的复合率递进的，而不是一个固定常数。
-
- 在H.264中，变换系数的读出方式也有两种：之字形（Zigzag）扫描和双扫描，如图6所示。大多数情况下使用简单的之字形扫描；双扫描仅用于使用较小量化级的块内，有助于提高编码效率。
-
-
-
-### 5熵编码
-
-
- 视频编码处理的最后一步就是熵编码，在H.264中采用了两种不同的熵编码方法：通用可变长编码（UVLC）和基于文本的自适应二进制算术编码（CABAC）。
-
- 在H.263等标准中，根据要编码的数据类型如变换系数、运动矢量等，采用不同的VLC码表。H.264中的UVLC码表提供了一个简单的方法，不管符号表述什么类型的数据，都使用统一变字长编码表。其优点是简单；缺点是单一的码表是从概率统计分布模型得出的，没有考虑编码符号间的相关性，在中高码率时效果不是很好。
-
- 因此，H.264中还提供了可选的CABAC方法。算术编码使编码和解码两边都能使用所有句法元素（变换系数、运动矢量）的概率模型。为了提高算术编码的效率，通过内容建模的过程，使基本概率模型能适应随视频帧而改变的统计特性。内容建模提供了编码符号的条件概率估计，利用合适的内容模型，存在于符号间的相关性可以通过选择目前要编码符号邻近的已编码符号的相应概率模型来去除，不同的句法元素通常保持不同的模型。
-
-## H.264在实时视频聊天中的应用
-
-
- 目前，H.264已被广泛应用于实时视频应用中，相比以往的方案使得在同等速率下，H.264能够比H.263减小50%的码率。也就是说，用户即使是只利用 384kbit/s的带宽，就可以享受H.263下高达 768kbit/s的高质量视频服务。H.264  不但有助于节省庞大开支，还可以提高资源的使用效率，同时令达到商业质量的实时视频服务拥有更多的潜在客户。
+TODO 
 
 
 

From 39f8ca0d45a1fab5682b5b10f585573659c0b82d Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Tue, 7 Jul 2020 22:04:08 +0800
Subject: [PATCH 025/213] update

---
 JavaKnowledge/.DS_Store                       | Bin 6148 -> 0 bytes
 .../Git\347\256\200\344\273\213.md"           |  15 +-
 ...37\347\220\206\345\210\206\346\236\220.md" | 684 +++++++++++++++++-
 3 files changed, 667 insertions(+), 32 deletions(-)
 delete mode 100644 JavaKnowledge/.DS_Store

diff --git a/JavaKnowledge/.DS_Store b/JavaKnowledge/.DS_Store
deleted file mode 100644
index 5008ddfcf53c02e82d7eee2e57c38e5672ef89f6..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6148
zcmeH~Jr2S!425mzP>H1@V-^m;4Wg<&0T*E43hX&L&p$$qDprKhvt+--jT7}7np#A3
zem<@ulZcFPQ@L2!n>{z**<q8>++&mCkOWA81W14cNZ<zv;LbK1Poaz?KmsK2CSc!(
z0ynLxE!0092;Krf2c+FF_Fe*7ECH>lEfg7;MkzE(HCqgga^y>{tEnwC%0;vJ&^%eQ
zLs35+`xjp>T0<F0fCPF1$Cyrb|F7^5{eNG?83~ZUUlGt@xh*qZDeu<Z%US-OSsOPv
j)R!Z4KLME7ReXlK;d!wEw5GODWMKRea10D2@KpjYNUI8I

diff --git "a/JavaKnowledge/Git\347\256\200\344\273\213.md" "b/JavaKnowledge/Git\347\256\200\344\273\213.md"
index 98287ca2..c1022154 100644
--- "a/JavaKnowledge/Git\347\256\200\344\273\213.md"
+++ "b/JavaKnowledge/Git\347\256\200\344\273\213.md"
@@ -160,7 +160,7 @@ git push  // 把所有文件从本地仓库推送进远程仓库
     用`git reflog`查看命令历史，以便确定要回到未来的哪个版本。     
     ```
     git log -p -2 // -p 是仅显示最近的x次提交   
-    git log --stat // stat简略的显示每次提交的内容梗概，如哪些文件变更，多少删除，多少天剑
+    git log --stat // stat简略的显示每次提交的内容梗概，如哪些文件变更，多少删除，多少添加
     git log --oneline --graph
     ```
     下面是常用的参数:   
@@ -187,9 +187,9 @@ git push  // 把所有文件从本地仓库推送进远程仓库
     # new file:   test.py
     ```
     `git reset [--hard|soft|mixed|merge|keep] [<commit>或HEAD]`:将当前的分支重设`(reset)`到指定的`<commit>`或者`HEAD`(默认，如果不显示指定`<commit>`，默认是`HEAD`，即最新的一次提交)，并且根据`[mode]`有可能更新索引和工作目录。`mode`的取值可以是`hard、soft、mixed、merged、keep`。下面来详细说明每种模式的意义和效果:    
-    - `--hard`:重设`(reset)`索引和工作目录，自从`<commit>`以来在工作目录中的任何改变都被丢弃，并把`HEAD`指向`<commit>`。会将其之后的修改全部撤回，并且会影响到工作区
-    - `--mixed`改变分支和暂存区，不影响工作区
-    - `soft`只改变分支的提交        
+    - `--hard`:彻底回退到某一个版本，本地的源码也会变为上一个版本的内容。重删除工作空间改动代码，撤销commit，撤销git add .。所有变更集都会被丢弃。
+    - `--mixed`:默认方式，它回退到某个版本，只保留源码，不删除工作空间改动代码，撤销commit，并且撤销git add . 。所有变更集都放在工作区。
+    - `--soft`: 回退到某个版本，不删除工作空间改动代码，撤销commit，不撤销git add . ，所有变更集都放在暂存区，如果还要提交直接重新commit即可。     
 
     下面是具体一个例子，假设有三个`commit`，执行`git status`结果如下:     
     ```
@@ -262,11 +262,6 @@ git push  // 把所有文件从本地仓库推送进远程仓库
     但是上面这样会导致你之前修改的代码都没有了，如果我只是想撤回提交，还想要我之前修改的东西重新回到本地仓库呢？ 
     `git reset --soft HEAD^`，这样就成功的撤销了你的commit。注意，仅仅是撤回commit操作，您写的代码仍然保留。
 
-    至于这几个参数：
-    1. --mixed：不删除工作空间改动代码，撤销commit，并且撤销git add . 操作这个为默认参数,git reset --mixed HEAD^ 和 git reset HEAD^ 效果是一样的。
-    2. --soft：不删除工作空间改动代码，撤销commit，不撤销git add . 
-    3. --hard：删除工作空间改动代码，撤销commit，撤销git add . 注意完成这个操作后，就恢复到了上一次的commit状态。
-
 - 已推送到远程仓库  
     如果你执行`git add .`后又`commit`又执行了`git push`操作了，这时候你的代码已经进入到了远程仓库中，如果你发现你提交的代码又问题想恢复的话，那你只能先把本地仓库的
     代码恢复，然后再强制执行`git push`仓做，`push`到远程仓库就可以了。    
@@ -367,7 +362,7 @@ git push  // 把所有文件从本地仓库推送进远程仓库
     在用`linux`的时候会自动生成一些以`~`结尾的备份文件，如果ignore掉呢？[https://github.com/github/gitignore/blob/master/Global/Linux.gitignore](https://github.com/github/gitignore/blob/master/Global/Linux.gitignore)
 
 - 撤销最后一次提交
-    有时候我们提交完了才发现漏掉了几个文件没有加或者提交信息写错了，想要撤销刚才的的提交操作。可以使用`--amend`选项重新提交:`git commit --amend`，然后再执行`git push`操作。
+    有时候我们提交完了才发现漏掉了几个文件没有加或者提交信息写错了，想要撤销刚才的的提交操作。可以修改后重新git add 然后使用`--amend`选项重新提交:`git commit --amend`，然后再执行`git push`操作。
 
 
 
diff --git "a/JavaKnowledge/HashMap\345\256\236\347\216\260\345\216\237\347\220\206\345\210\206\346\236\220.md" "b/JavaKnowledge/HashMap\345\256\236\347\216\260\345\216\237\347\220\206\345\210\206\346\236\220.md"
index d1808e42..63b0d41f 100644
--- "a/JavaKnowledge/HashMap\345\256\236\347\216\260\345\216\237\347\220\206\345\210\206\346\236\220.md"
+++ "b/JavaKnowledge/HashMap\345\256\236\347\216\260\345\216\237\347\220\206\345\210\206\346\236\220.md"
@@ -1,12 +1,31 @@
 HashMap实现原理分析
 ===
 
-`HashMap`主要是用数组来存储数据的，我们都知道它会对`key`进行哈希运算，哈系运算会有重复的哈希值，对于哈希值的冲突，`HashMap`采用链表来解决的。
-`在HashMap`里有这样的一句属性声明:   
+HashMap基于Map接口实现，元素以键值对的方式存储，并且允许使用null建和null值，因为key不允许重复，因此只能有一个键为null,另外HashMap不能保证放入元素的顺序，它是无序的，和放入的顺序并不能相同。
+
+
+
+## 原理
+
+其底层数据结构是数组称之为哈希桶，每个桶(bucket)里面放的是链表，链表中的每个节点，就是哈希表中的每个元素。
+
+通过hash的方法，通过put和get存储和获取对象。存储对象时，我们将K / V传给put方法时，它调用hashCode计算hash从而得到bucket位置，进一步存储，HashMap会根据当前bucket的占用情况自动调整容量 (超过 Load  Facotr则resize为原来的2倍)。获取对象时，我们 K传给get，它调用hashCodeO()计算hash从而得到bucket位置，并进一步调用equals()方法确定键值对。如果发生碰撞的时候，Hashmap通过链表将产生碰撞冲突的元素组织起来，在JDK8中，如果一个bucket中碰撞冲突的元素超过8哥，则使用红黑树来替换链表，从而提高速度。
+
+因其底层哈希桶的数据结构是数组，所以也会涉及到扩容的问题。当HashMap的容量达到threshold域值时，就会触发扩容。扩容前后，哈希桶的长度一定会是2的次方。这样在根据key的hash值寻找对应的哈希桶时，可以用位运算替代取余操作，更加高效。而key的hash值，并不仅仅只是key对象的hashCode()方法的返回值，还会经过扰动函数的扰动，以使hash值更加均衡。因为hashCode()是int类型，取值范围是40多亿，只要哈希函数映射的比较均匀松散，碰撞几率是很小的。 但就算原本的hashCode()取得很好，每个key的hashCode()不同，但是由于HashMap的哈希桶的长度远比hash取值范围小，默认是16，所以当对hash值以桶的长度取余，以找到存放该key的桶的下标时，由于取余是通过与操作完成的，会忽略hash值的高位。因此只有hashCode()的低位参加运算，发生不同的hash值，但是得到的index相同的情况的几率会大大增加，这种情况称之为hash碰撞。 即，碰撞率会增大。扰动函数就是为了解决hash碰撞的。它会综合hash值高位和低位的特征，并存放在低位，因此在与运算时，相当于高低位一起参与了运算，以减少hash碰撞的概率。（在JDK8之前，扰动函数会扰动四次，JDK8简化了这个操作）扩容操作时，会new一个新的Node数组作为哈希桶，然后将原哈希表中的所有数据(Node节点)移动到新的哈希桶中，相当于对原哈希表中所有的数据重新做了一个put操作。所以性能消耗很大，可想而知，在哈希表的容量越大时，性能消耗越明显。扩容时，如果发生过哈希碰撞，节点数小于8个。则要根据链表上每个节点的哈希值，依次放入新哈希桶对应下标位置。因为扩容是容量翻倍，所以原链表上的每个节点，现在可能存放在原来的下标，即low位， 或者扩容后的下标，即high位。 high位= low位+原哈希桶容量如果追加节点后，链表数量》=8，则转化为红黑树由迭代器的实现可以看出，遍历HashMap时，顺序是按照哈希桶从低到高，链表从前往后，依次遍历的。
+
+
+
+
+
+## JDK1.7
+
+HashMap在JDK1.8中发生了改变，下面的部分是基于JDK1.7的分析。HashMap主要是用数组来存储数据的，我们都知道它会对key进行哈希运算，哈希运算会有重复的哈希值，对于哈希值的冲突，HashMap采用链表来解决的。
+在HashMap里有这样的一句属性声明:   
+
 ```java
 transient Entry[] table;
 ```
-可以看到`Map`是通过数组的方式来储存`Entry`那`Entry`是神马呢？就是`HashMap`存储数据所用的类，它拥有的属性如下:   
+可以看到Map是通过数组的方式来储存Entry那Entry是神马呢？就是HashMap存储数据所用的类，它拥有的属性如下:   
 ```java
 static class Entry implements Map.Entry {
 	final K key;
@@ -16,20 +35,24 @@ static class Entry implements Map.Entry {
 	...//More code goes here
 }  
 ```
-看到`next`了吗？`next`就是为了哈希冲突而存在的。比如通过哈希运算，一个新元素应该在数组的第10个位置，但是第10个位置已经有Entry，那么好吧，
-将新加的元素也放到第10个位置，将第10个位置的原有`Entry`赋值给当前新加的`Entry`的`next`属性。数组存储的是链表，链表是为了解决哈希冲突的，这一点要注意。
+看到next了吗？next就是为了哈希冲突而存在的。比如通过哈希运算，一个新元素应该在数组的第10个位置，但是第10个位置已经有Entry，那么好吧，将新加的元素也放到第10个位置，将第10个位置的原有Entry赋值给当前新加的Entry的next属性。数组存储的是链表，链表是为了解决哈希冲突的，这一点要注意。
 
 好了，总结一下:       
 
-- `HashMap`中有一个叫`table`的`Entry`数组。
-- 这个数组存储了`Entry`类的对象。`HashMap`类有一个叫做`Entry`的内部类。这个`Entry`类包含了`key-value`作为实例变量。
-- 每当往`Hashmap`里面存放`key-value`对的时候，都会为它们实例化一个`Entry`对象，这个`Entry`对象就会存储在前面提到的`Entry`数组`table`中。
-现在你一定很想知道，上面创建的`Entry`对象将会存放在具体哪个位置(在`table`中的精确位置)。答案就是，根据`key`的`hashcode()`方法计算出来的`hash`值来决定。
-`hash`值用来计算`key`在`Entry`数组的索引。
-- 我们往`hashmap`放了4个`key-value`对，但是有时候看上去好像只有2个元素！！！这是因为，如果两个元素有相同的`hashcode`，它们会被放在同一个索引上。
-问题出现了，该怎么放呢？原来它是以链表`(LinkedList)`的形式来存储的。
+- HashMap中有一个叫table的Entry数组。这个数组存储了Entry类的对象。Entry类包含了key-value作为实例变量。
+
+- table的索引在逻辑上叫做“桶”(bucket)，它存储了链表的第一个元素。
+
+- 每当往Hashmap里面存放key-value对的时候，都会为它们实例化一个Entry对象，这个Entry对象就会存储在前面提到的Entry数组table中。根据key的hashcode()方法计算出来的hash值来决定在Entry数组的索引(所在的桶)。
+
+- 如果两个key有相同的hash值，他们会被放在table数组的同一个桶里面。
+
+- key的equals()方法用来确保key的唯一性。
+
+    
+
+接下来看一下put方法:      
 
-接下来看一下`put`方法:      
 ```java
 /**
 * Associates the specified value with the specified key in this map. If the
@@ -73,7 +96,7 @@ public V put(K key, V value) {
 	return null;
 }
 ```
-再看一下`get`方法:　　　　
+再看一下get方法:　　　　
 ```java
 /**
   * Returns the value to which the specified key is mapped, or {@code null}
@@ -110,15 +133,632 @@ public V get(Object key) {
 }
 ```
 
-总结:     
 
-- `HashMap`有一个叫做`Entry`的内部类，它用来存储`key-value`对。
-- 上面的`Entry`对象是存储在一个叫做`table`的`Entry`数组中。
-- `table`的索引在逻辑上叫做“桶”`(bucket)`，它存储了链表的第一个元素。
-- `key`的`hashcode()`方法用来找到`Entry`对象所在的桶。
-- 如果两个`key`有相同的`hash`值，他们会被放在`table`数组的同一个桶里面。
-- `key`的`equals()`方法用来确保`key`的唯一性。
-- `value`对象的`equals()`和`hashcode()`方法根本一点用也没有。
+
+## JDK1.8
+
+在Jdk1.8中HashMap的实现方式做了一些改变，但是基本思想还是没有变得，只是在一些地方做了优化，下面来看一下这些改变的地方,数据结构的存储由数组+链表的方式，变化为数组+链表+红黑树的存储方式，当链表长度超过阈值（8）时，将链表转换为红黑树。利用红黑树快速增删改查的特点来提高HashMap的性能，其中会用到红黑树的插入、删除、查找等算法。HashMap中，如果key经过hash算法得出的数组索引位置全部不相同，即Hash算法非常好，那样的话，getKey方法的时间复杂度就是O(1)，如果Hash算法技术的结果碰撞非常多，假如Hash算极其差，所有的Hash算法结果得出的索引位置一样，那样所有的键值对都集中到一个桶中，或者在一个链表中，或者在一个红黑树中，时间复杂度分别为O(n)和O(lgn)。
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/hashmap_data_structure.jpg)
+
+
+
+既然发生了变化，那这里就以1.8的源码基础上再做一下分析:  
+
+1. 首先看一下对应的两个Node类:  
+
+    ```java
+    // 单链表
+    static class Node<K,V> implements Map.Entry<K,V> {
+        // 用于定位数组的索引位置
+        final int hash;
+        final K key;
+        V value;
+        // 链表的下一个node
+        Node<K,V> next;
+    
+        Node(int hash, K key, V value, Node<K,V> next) {
+            this.hash = hash;
+            this.key = key;
+            this.value = value;
+            this.next = next;
+        }
+    
+        public final K getKey()        { return key; }
+        public final V getValue()      { return value; }
+        public final String toString() { return key + "=" + value; }
+    	// 每一个节点的hashcode值，是将key和value的hashCode值异或得到的
+        public final int hashCode() {
+            return Objects.hashCode(key) ^ Objects.hashCode(value);
+        }
+    
+        public final V setValue(V newValue) {
+            V oldValue = value;
+            value = newValue;
+            return oldValue;
+        }
+    
+        public final boolean equals(Object o) {
+            if (o == this)
+                return true;
+            if (o instanceof Map.Entry) {
+                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
+                if (Objects.equals(key, e.getKey()) &&
+                    Objects.equals(value, e.getValue()))
+                    return true;
+            }
+            return false;
+        }
+    }
+    ```
+
+    ```java
+    static class LinkedHashMapEntry<K,V> extends HashMap.Node<K,V> {
+        LinkedHashMapEntry<K,V> before, after;
+        LinkedHashMapEntry(int hash, K key, V value, Node<K,V> next) {
+            super(hash, key, value, next);
+        }
+    }
+    ```
+
+    ```java
+    // 红黑树
+    static final class TreeNode<K,V> extends LinkedHashMap.LinkedHashMapEntry<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) {
+            super(hash, key, val, next);
+        }
+        /**
+         * Forms tree of the nodes linked from this node.
+         * @return root of tree
+         */
+        final void treeify(Node<K,V>[] tab) {
+       		...
+        }
+    
+        /**
+         * Returns a list of non-TreeNodes replacing those linked from
+         * this node.
+         */
+        final Node<K,V> untreeify(HashMap<K,V> map) {
+            ...
+        }
+    
+        /**
+    	 * 红黑树的插入
+         * Tree version of putVal.
+         */
+        final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
+                                       int h, K k, V v) {
+            Class<?> kc = null;
+            boolean searched = false;
+            TreeNode<K,V> root = (parent != null) ? root() : this;
+            for (TreeNode<K,V> p = root;;) {
+                int dir, ph; K pk;
+                if ((ph = p.hash) > h)
+                    dir = -1;
+                else if (ph < h)
+                    dir = 1;
+                else if ((pk = p.key) == k || (k != null && k.equals(pk)))
+                    return p;
+                else if ((kc == null &&
+                          (kc = comparableClassFor(k)) == null) ||
+                         (dir = compareComparables(kc, k, pk)) == 0) {
+                    if (!searched) {
+                        TreeNode<K,V> q, ch;
+                        searched = true;
+                        if (((ch = p.left) != null &&
+                             (q = ch.find(h, k, kc)) != null) ||
+                            ((ch = p.right) != null &&
+                             (q = ch.find(h, k, kc)) != null))
+                            return q;
+                    }
+                    dir = tieBreakOrder(k, pk);
+                }
+    
+                TreeNode<K,V> xp = p;
+                if ((p = (dir <= 0) ? p.left : p.right) == null) {
+                    Node<K,V> xpn = xp.next;
+                    TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn);
+                    if (dir <= 0)
+                        xp.left = x;
+                    else
+                        xp.right = x;
+                    xp.next = x;
+                    x.parent = x.prev = xp;
+                    if (xpn != null)
+                        ((TreeNode<K,V>)xpn).prev = x;
+                    moveRootToFront(tab, balanceInsertion(root, x));
+                    return null;
+                }
+            }
+        }
+    }
+    ```
+
+2. 再来看一下HashMap的实现类及构造函数
+
+    ```java
+    public class HashMap<K,V> extends AbstractMap<K,V>
+        implements Map<K,V>, Cloneable, Serializable {
+    	// 默认的初始化容量大小，必须是2的倍数，默认是16，为啥必须是2的倍数，后面会说
+        static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
+        // 在构造函数中未指定时使用的负载因子。
+        static final float DEFAULT_LOAD_FACTOR = 0.75f;
+        // 使用红黑树树而不链表的容器计数阈值
+        static final int TREEIFY_THRESHOLD = 8;
+        // 用于在执行过程中取消使用红黑树（拆分）箱调整大小操作的箱计数阈值，
+        static final int UNTREEIFY_THRESHOLD = 6;
+        // 哈希桶，存储数据的数组
+        transient Node<K,V>[] table;
+        // Node[] table的初始化长度length(默认值是16)，Load factor为负载因子(默认值是0.75)，threshold是HashMap所能容纳的最大数据量的Node(键值对)个数。threshold = (capacity * load factor)，超过这个数量后就会进行重新resize(扩容)，扩容一后的HashMap容量是之前容量的两倍
+        int threshold;
+        
+        
+        public HashMap(int initialCapacity, float loadFactor) {
+            if (initialCapacity < 0)
+                throw new IllegalArgumentException("Illegal initial capacity: " +
+                                                   initialCapacity);
+            if (initialCapacity > MAXIMUM_CAPACITY)
+                initialCapacity = MAXIMUM_CAPACITY;
+            if (loadFactor <= 0 || Float.isNaN(loadFactor))
+                throw new IllegalArgumentException("Illegal load factor: " +
+                                                   loadFactor);
+            this.loadFactor = loadFactor;
+            this.threshold = tableSizeFor(initialCapacity);
+        }
+    
+        public HashMap(int initialCapacity) {
+            this(initialCapacity, DEFAULT_LOAD_FACTOR);
+        }
+    
+        /**
+         * Constructs an empty <tt>HashMap</tt> with the default initial capacity
+         * (16) and the default load factor (0.75).
+         */
+        public HashMap() {
+            this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
+        }
+    }
+    ```
+
+### 确定哈希桶数组索引位置
+
+不管增加、删除、查找键值对，定位到哈希桶数组的位置都是很关键的第一步。前面说过HashMap的数据结构是数组和链表的结合，所以我们当然希望这个HashMap里面的元素位置尽量分布均匀些，尽量使得每个位置上的元素数量只有一个，那么当我们用hash算法求得这个位置的时候，马上就可以知道对应位置的元素就是我们要的，不用遍历链表，大大优化了查询的效率。HashMap定位数组索引位置，直接决定了hash方法的离散性能。先看看源码的实现：  
+
+```java
+static final int hash(Object key) {
+    int h;
+    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
+}
+```
+
+对于任意给定的对象，只要它的hashCode()返回值相同，那么程序调用所计算得到的Hash码值总是相同的。我们首先想到的就是把hash值对数组长度取模运算，这样一来，元素的分布相对来说是比较均匀的。但是，模运算的消耗还是比较大的，在HashMap中是这样做的：调用 (table.length  -1) & hash来计算该对象应该保存在table数组的哪个索引处。这个方法非常巧妙，它通过 (table.length  -1) & hash来得到该对象的保存位，而HashMap底层数组的长度总是2的n次方，当length总是2的n次方时， (table.length  -1) & hash运算等价于对length取模，也就是h%length，但是&比%具有更高的效率。
+
+当length总是2的倍数时，h & (length-1) 将是一个非常巧妙的设计：
+
+- 假设h=5,length=16, 那么h & length - 1将得到 5；
+- 如果h=6,length=16, 那么h & length - 1将得到 6
+- 如果h=15,length=16, 那么h & length - 1将得到 15；
+- 但是当h=16时 , length=16 时，那么h & length - 1将得到0了；
+- 当h=17时, length=16时，那么h & length - 1将得到1了。
+
+这样保证计算得到的索引值总是位于 table 数组的索引之内。
+
+
+
+在JDK1.8的实现中，优化了高位运算的算法，通过hashCode()的高16位异或低16位实现的：(h = k.hashCode()) ^ (h >>>  16)，主要是从速度、功效、质量来考虑的，这么做可以在数组table的length比较小的时候，也能保证考虑到高低Bit都参与到Hash的计算中，同时不会有太大的开销。
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/hashmap_hash.bmp)
+
+
+
+### put
+
+```java
+    public V put(K key, V value) {
+        // 对key调用hash()方法获取hash值
+        return putVal(hash(key), key, value, false, true);
+    }
+
+
+    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
+                   boolean evict) {
+        Node<K,V>[] tab; Node<K,V> p; int n, i;
+        // 1. 如果table还没初始化就初始化
+        if ((tab = table) == null || (n = tab.length) == 0)
+            n = (tab = resize()).length;
+        // 2. 根据键值key计算的hash值来得到插入的数组索引i，判断tab[i]是否为null，数组索引通过(n -1) & hash来获得
+        if ((p = tab[i = (n - 1) & hash]) == null)
+            // 3. 如果tab[索引]的值为null，那就说明这个索引没有数组桶，直接新建一个数组桶
+            tab[i] = newNode(hash, key, value, null);
+        else {
+           	// 4. 否则就是目前已经存在该索引的数组桶了，要继续判断是链表还是红黑树。
+            Node<K,V> e; K k;
+            // 5. 判断table[索引]处的收个元素是否和key一样，如果首个就是那就直接覆盖value，不用再找了
+            if (p.hash == hash &&
+                ((k = p.key) == key || (key != null && key.equals(k))))
+                // 6. 数组桶的首个元素就是，直接覆盖value的值
+                e = p;
+            else if (p instanceof TreeNode)
+                // 7. 数组桶首个元素不是，并且链表是红黑树，红黑树直接插入键值对
+                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
+            else {
+            	// 8. 目前为链表，开始遍历链表准备插入
+                for (int binCount = 0; ; ++binCount) {
+                    if ((e = p.next) == null) {
+                        // 添加到目前的节点的next上
+                        p.next = newNode(hash, key, value, null);
+                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
+                            // 判断链表长度是否大于8，如果大于直接转换成红黑树，插入键值对
+                            treeifyBin(tab, hash);
+                        break;
+                    }
+                    
+                    if (e.hash == hash &&
+                        ((k = e.key) == key || (key != null && key.equals(k))))
+                        break;
+                    p = e;
+                }
+            }
+            if (e != null) { // existing mapping for key
+                V oldValue = e.value;
+                if (!onlyIfAbsent || oldValue == null)
+                    e.value = value;
+                afterNodeAccess(e);
+                return oldValue;
+            }
+        }
+        ++modCount;
+        // 判断当前存在的键值对数量size是否超过了最大容量threshold，如果超过就调用resize扩容
+        if (++size > threshold)
+            resize();
+        afterNodeInsertion(evict);
+        return null;
+    }
+```
+
+上面主要有两个方法一个是红黑树的插入，一个是treeifyBin()也就是把链表转换成红黑树
+
+```java
+// MIN_TREEIFY_CAPACITY 的值为64，若当前table的length不够，则resize()
+// 将桶内所有的 链表节点 替换成 红黑树节点
+final void treeifyBin(Node<K,V>[] tab, int hash) {
+    int n, index; Node<K,V> e;
+    // 如果当前哈希表为空，或者哈希表中元素的个数小于树形化阈值(默认为 64)，就去新建(扩容)
+    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
+        resize();
+    // 如果哈希表中的元素个数超过了树形化阈值，则进行树形化
+    // e 是哈希表中指定位置桶里的链表节点，从第一个开始
+    else if ((e = tab[index = (n - 1) & hash]) != null) {
+        // 红黑树的头、尾节点
+        TreeNode<K,V> hd = null, tl = null;
+        do {
+            // 新建一个树形节点，内容和当前链表节点 e 一致
+            TreeNode<K,V> p = replacementTreeNode(e, null);
+            // 确定树头节点
+            if (tl == null)
+                hd = p;
+            else {
+                p.prev = tl;
+                tl.next = p;
+            }
+            tl = p;
+        } while ((e = e.next) != null);
+        // 让桶的第一个元素指向新建的红黑树头结点，以后这个桶里的元素就是红黑树而不是链表了
+        if ((tab[index] = hd) != null)
+            hd.treeify(tab);
+    }
+}
+```
+
+### resize()扩容
+
+扩容(resize)就是重新计算容量，向HashMap对象里不停的添加元素，而HashMap对象内部的数组无法装载更多的元素时，对象就需要扩大数组的长度，以便能装入更多的元素。当然Java里的数组是无法自动扩容的，方法是使用一个新的数组代替已有的容量小的数组，就像我们用一个小桶装水，如果想装更多的水，就得换大水桶。
+
+resize()方法用于初始化数组或数组扩容，每次扩容后容量为原来的2倍，并进行数据迁移。 
+
+
+
+例如我们从 16 扩展为 32 时，具体的变化如下所示：
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/resize1.bmp)
+
+
+
+
+因此元素在重新计算hash之后，因为n变为 2 倍，那 n-1的mask范围在高位多1bit (红色)，因此新的 index就会发生这样的变化：
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/resize2.bmp)
+
+
+因此，我们在扩充HashMap的时候，不需要重新计算hash，只需要看看原来的hash值新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引变成 “原索引 + oldCap”。可以看看下图为16扩充为32的resize示意图：
+
+![resize](https://raw.githubusercontent.com/CharonChui/Pictures/master/resize3.bmp)
+
+
+
+
+这个设计确实非常的巧妙，既省去了重新计算 hash 值的时间，而且同时，**由于新增的 1bit 是 0 还是 1 可以认为是随机的，因此 resize 的过程，均匀的把之前的冲突的节点分散到新的 bucket 了**。
+
+```java
+final Node<K,V>[] resize() {
+    //oldTab 为当前表的哈希桶
+    Node<K,V>[] oldTab = table;
+    //当前哈希桶的容量 length
+    int oldCap = (oldTab == null) ? 0 : oldTab.length
+    //当前的阈值
+    int oldThr = threshold;
+    //初始化新的容量和阈值为 0
+    int newCap, newThr = 0;
+    //如果当前容量大于 0
+    if (oldCap > 0) {
+        //超过最大值就不再扩充了，就只好随你碰撞去吧
+        if (oldCap >= MAXIMUM_CAPACITY) {
+            threshold = Integer.MAX_VALUE;
+            return oldTab;
+        }
+        //没超过最大值，就扩充为原来的 2 倍 
+        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
+                oldCap >= DEFAULT_INITIAL_CAPACITY)
+            //如果旧的容量大于等于默认初始容量 16, 那么新的阈值也等于旧的阈值的两倍
+            newThr = oldThr << 1; // double threshold
+    }
+    else if (oldThr > 0) // initial capacity was placed in threshold
+        newCap = oldThr;//那么新表的容量就等于旧的阈值
+    else {// zero initial threshold signifies using defaults
+        newCap = DEFAULT_INITIAL_CAPACITY;//此时新表的容量为默认的容量 16
+        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//新的阈值为默认容量 16 * 默认加载因子 0.75f = 12
+    }
+    if (newThr == 0) {//如果新的阈值是 0，对应的是当前表是空的，但是有阈值的情况
+        float ft = (float)newCap * loadFactor;//根据新表容量和加载因子求出新的阈值
+        //进行越界修复
+        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE);
+    }
+    //更新阈值
+    threshold = newThr;
+    @SuppressWarnings({"rawtypes","unchecked"})
+    //根据新的容量构建新的哈希桶
+        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
+    //更新哈希桶引用
+    table = newTab;
+    //如果以前的哈希桶中有元素
+    //下面开始将当前哈希桶中的所有节点转移到新的哈希桶中
+    if (oldTab != null) {
+        //把每个 bucket 都移动到新的 buckets 中
+        for (int j = 0; j < oldCap; ++j) {
+            //取出当前的节点 e
+            Node<K,V> e;
+            //如果当前桶中有元素,则将链表赋值给 e
+            if ((e = oldTab[j]) != null) {
+                //将原哈希桶置空以便 GC
+                oldTab[j] = null;
+                //如果当前链表中就一个元素，（没有发生哈希碰撞）
+                if (e.next == null)
+                    //直接将这个元素放置在新的哈希桶里。
+                    //注意这里取下标是用哈希值与桶的长度-1。由于桶的长度是2的n次方，这么做其实是等于一个模运算。但是效率更高
+                    newTab[e.hash & (newCap - 1)] = e;
+                    //如果发生过哈希碰撞 ,而且是节点数超过8个，转化成了红黑树
+                else if (e instanceof TreeNode)
+                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
+                //如果发生过哈希碰撞，节点数小于 8 个。则要根据链表上每个节点的哈希值，依次放入新哈希桶对应下标位置。
+                else { // preserve order
+                    //因为扩容是容量翻倍，所以原链表上的每个节点，现在可能存放在原来的下标，即 low 位， 或者扩容后的下标，即 high 位。 high 位 = low 位 + 原哈希桶容量
+                    //低位链表的头结点、尾节点
+                    Node<K,V> loHead = null, loTail = null;
+                    //高位链表的头节点、尾节点
+                    Node<K,V> hiHead = null, hiTail = null;
+                    Node<K,V> next;//临时节点 存放 e 的下一个节点
+                    do {
+                        next = e.next;
+                        //这里又是一个利用位运算 代替常规运算的高效点：利用哈希值与旧的容量，可以得到哈希值去模后，是大于等于 oldCap 还是小于 oldCap，等于 0 代表小于 oldCap，应该存放在低位，否则存放在高位
+                        if ((e.hash & oldCap) == 0) {
+                            //给头尾节点指针赋值
+                            if (loTail == null)
+                                loHead = e;
+                            else
+                                loTail.next = e;
+                            loTail = e;
+                        }//高位也是相同的逻辑
+                        else {
+                            if (hiTail == null)
+                                hiHead = e;
+                            else
+                                hiTail.next = e;
+                            hiTail = e;
+                        }//循环直到链表结束
+                    } while ((e = next) != null);
+                    //将低位链表存放在原 index 处，
+                    if (loTail != null) {
+                        loTail.next = null;
+                        newTab[j] = loHead;
+                    }
+                    //将高位链表存放在新 index 处
+                    if (hiTail != null) {
+                        hiTail.next = null;
+                        newTab[j + oldCap] = hiHead;
+                    }
+                }
+            }
+        }
+    }
+    return newTab;
+}
+```
+
+再看一下往哈希表里插入一个节点的putVal函数,如果参数onlyIfAbsent是true，那么不会覆盖相同key的值value。如果evict是false。那么表示是在初始化时调用的
+
+```java
+final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
+                   boolean evict) {
+    //tab存放 当前的哈希桶， p用作临时链表节点  
+    Node<K,V>[] tab; Node<K,V> p; int n, i;
+    //如果当前哈希表是空的，代表是初始化
+    if ((tab = table) == null || (n = tab.length) == 0)
+        //那么直接去扩容哈希表，并且将扩容后的哈希桶长度赋值给n
+        n = (tab = resize()).length;
+    //如果当前index的节点是空的，表示没有发生哈希碰撞。 直接构建一个新节点Node，挂载在index处即可。
+    //这里再啰嗦一下，index 是利用 哈希值 & 哈希桶的长度-1，替代模运算
+    if ((p = tab[i = (n - 1) & hash]) == null)
+        tab[i] = newNode(hash, key, value, null);
+    else {//否则 发生了哈希冲突。
+        //e
+        Node<K,V> e; K k;
+        //如果哈希值相等，key也相等，则是覆盖value操作
+        if (p.hash == hash &&
+            ((k = p.key) == key || (key != null && key.equals(k))))
+            e = p;//将当前节点引用赋值给e
+        else if (p instanceof TreeNode)//红黑树暂且不谈
+            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
+        else {//不是覆盖操作，则插入一个普通链表节点
+            //遍历链表
+            for (int binCount = 0; ; ++binCount) {
+                if ((e = p.next) == null) {//遍历到尾部，追加新节点到尾部
+                    p.next = newNode(hash, key, value, null);
+                    //如果追加节点后，链表数量》=8，则转化为红黑树
+                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
+                        treeifyBin(tab, hash);
+                    break;
+                }
+                //如果找到了要覆盖的节点
+                if (e.hash == hash &&
+                    ((k = e.key) == key || (key != null && key.equals(k))))
+                    break;
+                p = e;
+            }
+        }
+        //如果e不是null，说明有需要覆盖的节点，
+        if (e != null) { // existing mapping for key
+            //则覆盖节点值，并返回原oldValue
+            V oldValue = e.value;
+            if (!onlyIfAbsent || oldValue == null)
+                e.value = value;
+            //这是一个空实现的函数，用作LinkedHashMap重写使用。
+            afterNodeAccess(e);
+            return oldValue;
+        }
+    }
+    //如果执行到了这里，说明插入了一个新的节点，所以会修改modCount，以及返回null。
+
+    //修改modCount
+    ++modCount;
+    //更新size，并判断是否需要扩容。
+    if (++size > threshold)
+        resize();
+    //这是一个空实现的函数，用作LinkedHashMap重写使用。
+    afterNodeInsertion(evict);
+    return null;
+}
+```
+
+
+
+扩容就是使用一个容量更大的数组来代替已有的容量小的数组，transfer()方法将原有Entry数组的元素拷贝到新的Entry数组里。
+
+* 运算尽量都用位运算代替，更高效。
+* 对于扩容导致需要新建数组存放更多元素时，除了要将老数组中的元素迁移过来，也记得将老数组中的引用置null，以便GC
+* 取下标 是用 哈希值 与运算 （桶的长度-1） i = (n - 1) & hash。 由于桶的长度是2的n次方，这么做其实是等于 一个模运算。但是效率更高
+* 扩容时，如果发生过哈希碰撞，节点数小于8个。则要根据链表上每个节点的哈希值，依次放入新哈希桶对应下标位置。
+* 因为扩容是容量翻倍，所以原链表上的每个节点，现在可能存放在原来的下标，即low位， 或者扩容后的下标，即high位。 high位= low位+原哈希桶容量
+* 利用哈希值 与运算 旧的容量 ，if ((e.hash & oldCap) == 0),可以得到哈希值去模后，是大于等于oldCap还是小于oldCap，等于0代表小于oldCap，应该存放在低位，否则存放在高位。这里又是一个利用位运算 代替常规运算的高效点
+* 如果追加节点后，链表数量》=8，则转化为红黑树
+* 插入节点操作时，有一些空实现的函数，用作LinkedHashMap重写使用。
+
+
+### get
+
+```java
+public V get(Object key) {
+    Node<K,V> e;
+    return (e = getNode(hash(key), key)) == null ? null : e.value;
+}
+
+final Node<K,V> getNode(int hash, Object key) {
+    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
+    if ((tab = table) != null && (n = tab.length) > 0 &&
+        (first = tab[(n - 1) & hash]) != null) {
+        // 找到索引，判断数组桶中的第一个元素是不是
+        if (first.hash == hash && // always check first node
+            ((k = first.key) == key || (key != null && key.equals(k))))
+            return first;
+        if ((e = first.next) != null) {
+            // 第一个元素不是的话，就看是不是红黑树还是链表，然后一直去找
+            if (first instanceof TreeNode)
+                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
+            do {
+                if (e.hash == hash &&
+                    ((k = e.key) == key || (key != null && key.equals(k))))
+                    return e;
+            } while ((e = e.next) != null);
+        }
+    }
+    return null;
+}
+```
+
+
+
+
+
+## JDK 7 与 JDK 8 中关于 HashMap的对比
+
+1. JDK8为红黑树 + 链表 + 数组的形式，当桶内元素大于8时，便会树化。
+2. hash值的计算方式不同 (jdk 8 简化)。
+3. JDK7中table在创建hashmap时分配空间，而8中在put的时候分配。
+4. 在发生冲突，插入链中时，7 是头插法，8 是尾插法
+5. 在resize操作中，7 需要重新进行index的计算，而8不需要，通过判断相应的位是0还是1，要么依旧是原index，要么是oldCap + 原 index。
+
+
+
+
+
+## 问题
+
+1. 为什么capcity是2的幂？
+     因为算index时用的是(n-1) & hash，这样就能保证n-1是全为1的二进制数，如果不全为1的话，存在某一位为 0，那么0，1与0与的结果都是0，这样便有可能将两个hash不同的值最终装入同一个桶中，造成冲突。所以必须是2的幂。这是为了服务key映射到index的Hash算法的，公式index=hashcode(key)&(length-1)，初始长度(16-1)，二进制为1111&hashcode结果为hashcode最后四位，能最大程度保持平均，二的幂数保证二进制为1，保持hashcode最后四位。这种算法在保持分布均匀之外，效率也非常高。
+
+
+
+2. 为什么需要使用加载因子，为什么需要扩容呢？
+
+    因为如果填充比很大，说明利用的空间很多，如果一直不进行扩容的话，链表就会越来越长，这样查找的效率很低，因为链表的长度很大（当然最新版本使用了红黑树后会改进很多），扩容之后，将原来链表数组的每一个链表分成奇偶两个子链表分别挂在新链表数组的散列位置，这样就减少了每个链表的长度，增加查找效率。HashMap 本来是以空间换时间，所以填充比没必要太大。但是填充比太小又会导致空间浪费。如果关注内存，填充比可以稍大，如果主要关注查找性能，填充比可以稍小。
+
+3. 为什么 HashMap 是线程不安全的，实际会如何体现？
+
+    - 如果多个线程同时使用put方法添加元素，假设正好存在两个put的key发生了碰撞 (hash值一样)，那么根据HashMap的实现，这两个key会添加到数组的同一个位置，这样最终就会发生其中一个线程的put的数据被覆盖。
+
+    - 如果多个线程同时检测到元素个数超过数组大小 * loadFactor。这样会发生多个线程同时对hash数组进行扩容，都在重新计算元素位置以及复制数据，但是最终只有一个线程扩容后的数组会赋给table，也就是说其他线程的都会丢失，并且各自线程put的数据也丢失。且会引起死循环的错误。
+
+        
+
+4. 与HashTable的区别
+
+    Hashtable是遗留类，很多映射的常用功能与HashMap类似，不同的是它承自Dictionary类，并且是线程安全的，任一时间只有一个线程能写Hashtable，它的并发性不如ConcurrentHashMap，因为ConcurrentHashMap引入了分段锁。Hashtable不建议在新代码中使用，不需要线程安全的场合可以用HashMap替换，需要线程安全的场合可以用ConcurrentHashMap替换。
+
+    - 与之相比HashTable是线程安全的，且不允许key、value是null。
+    - HashTable默认容量是11。
+    - HashTable是直接使用key的hashCode(key.hashCode())作为hash值，不像HashMap内部使用static final int hash(Object key)扰动函数对key的hashCode进行扰动后作为hash值。
+    - HashTable取哈希桶下标是直接用模运算%.（因为其默认容量也不是2的n次方。所以也无法用位运算替代模运算）
+    - 扩容时，新容量是原来的2倍+1。int newCapacity = (oldCapacity << 1) + 1;
+    - Hashtable是Dictionary的子类同时也实现了Map接口，HashMap是Map接口的一个实现类
+
+
+
+
+参考:  
+
+- [从 JDK7 与 JDK8 对比详细分析 HashMap 的原理与优化](https://allenmistake.top/2019/05/13/hashmap/)
+- [面试必备：HashMap源码解析（JDK8）](https://blog.csdn.net/zxt0601/article/details/77413921)
+
+
+
+
+
+
 
 ---
 - 邮箱 ：charon.chui@gmail.com  

From 00746b815f9d33559f697306e43499f9a97571cb Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 9 Jul 2020 17:51:36 +0800
Subject: [PATCH 026/213] add notes

---
 ...ps\347\232\204\345\214\272\345\210\253.md" |  26 +-
 ...36\346\224\266\346\234\272\345\210\266.md" | 473 +++++++++++++++---
 ...14Synchronized\345\214\272\345\210\253.md" | 303 ++++++++++-
 ...06\345\217\212\350\247\243\345\257\206.md" |  18 +-
 4 files changed, 715 insertions(+), 105 deletions(-)

diff --git "a/JavaKnowledge/Http\344\270\216Https\347\232\204\345\214\272\345\210\253.md" "b/JavaKnowledge/Http\344\270\216Https\347\232\204\345\214\272\345\210\253.md"
index 3c23a227..90346bfb 100644
--- "a/JavaKnowledge/Http\344\270\216Https\347\232\204\345\214\272\345\210\253.md"
+++ "b/JavaKnowledge/Http\344\270\216Https\347\232\204\345\214\272\345\210\253.md"
@@ -1,8 +1,21 @@
-Http与Https的区别
+HTTP与HTTPS的区别
 ===
 
-`http`(超文本传输协议)
----
+## HTTP(超文本传输协议)
+
+超文本传输协议，是一个基于请求与响应，无状态的，应用层的协议，常基于TCP/IP协议传输数据，互联网上应用最为广泛的一种网络协议,所有的WWW文件都必须遵守这个标准。设计HTTP的初衷是为了提供一种发布和接收HTML页面的方法。
+
+
+
+- 1997年发布HTTP/1.1: 持久连接(长连接)、节约带宽、HOST域、管道机制、分块传输编码。
+
+- 2015年发布HTTP/2:多路复用、服务器推送、头信息压缩、二进制协议等。
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/http1.1vs2.jpg)
+
+多路复用：通过单一的HTTP/2连接请求发起多重的请求-响应消息，多个请求stream共享一个TCP连接，实现多留并行而不是依赖建立多个TCP连接。
+
+
 
 缺点:    
 
@@ -14,11 +27,9 @@ Http与Https的区别
 
 - 传输速度快
 
+## HTTPS
 
-`https`
----
-
-`Https`并非是应用层的一种新协议。只是`http`通信接口部分用`SSL`(安全套接字层)和`TLS`(安全传输层协议)代替而已。即添加了加密及认证机制的`HTTP`称为`HTTPS(HTTP Secure)`.    
+Https并非是应用层的一种新协议。只是http通信接口部分用SSL(安全套接字层)和TLS(安全传输层协议)代替而已。即添加了加密及认证机制的HTTP称为HTTPS(HTTP Secure).    
 
 ```
 HTTP + 加密 + 认证 + 完整性保护 = HTTPS
@@ -136,7 +147,6 @@ HTTP + 加密 + 认证 + 完整性保护 = HTTPS
 
 
 
-	
 ----
 - 邮箱 ：charon.chui@gmail.com  
 - Good Luck! 
diff --git "a/JavaKnowledge/JVM\345\236\203\345\234\276\345\233\236\346\224\266\346\234\272\345\210\266.md" "b/JavaKnowledge/JVM\345\236\203\345\234\276\345\233\236\346\224\266\346\234\272\345\210\266.md"
index 03e7f1cd..1b1dfb51 100644
--- "a/JavaKnowledge/JVM\345\236\203\345\234\276\345\233\236\346\224\266\346\234\272\345\210\266.md"
+++ "b/JavaKnowledge/JVM\345\236\203\345\234\276\345\233\236\346\224\266\346\234\272\345\210\266.md"
@@ -1,8 +1,79 @@
-JVM垃圾回收机制
-===
+# JVM垃圾回收机制
 
-引用计数算法
----
+
+
+## JVM内存模式
+
+JVM内存模型可以分为两个部分，如下图所示，**堆和方法区是所有线程共有的**，而虚拟机栈，本地方法栈和程序计数器则是线程私有的。
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/jvm.png)
+
+### 堆（Heap）
+
+Java 堆是垃圾收集器管理的主要区域，因此也被称作GC 堆（Garbage Collected Heap)。Java的自动内存管理主要是针对对象内存的回收和对象内存的分配。同时，Java 自动内存管理最核心的功能是堆内存中对象的分配与回收。从垃圾回收的角度，由于现在收集器基本都采用分代垃圾收集算法，所以 Java 堆还可以细分为：新生代和老年代：再细致一点有：Eden 空间、From Survivor、To Survivor 空间等。进一步划分的目的是更好地回收内存，或者更快地分配内存。
+
+**堆空间的基本结构：**
+
+![](http://raw.githubusercontent.com/CharonChui/Pictures/master/java_heap.png)
+
+在我们垃圾回收的时候，我们往往将堆内存分成**新生代和老生代（大小比例1：2）**，新生代中由Eden和Survivor0，Survivor1组成，**三者的比例是8：1：1**，新生代的回收机制采用**复制算法**，大部分情况，对象都会首先在Eden区域分配，在一次新生代垃圾回收后，如果对象还存活，则会进入s0或者s1，并且对象的年龄还会加 1(Eden区->Survivor区后对象的初始年龄变为1)，当它的年龄增加到一定程度（默认为15  岁），就会被晋升到老年代中。对象晋升到老年代的年龄阈值，可以通过参数 `-XX:MaxTenuringThreshold` 来设置。老生代采用的回收算法是**标记整理算法。**
+
+
+
+#### 对象优先在eden区分配
+
+目前主流的垃圾收集器都会采用分代回收算法，因此需要将堆内存分为新生代和老年代，这样我们就可以根据各个年代的特点选择合适的垃圾收集算法。
+
+大多数情况下，对象在新生代中eden区分配。当eden区没有足够空间进行分配时，虚拟机将发起一次Minor GC.
+
+这里说一下Minor GC 和 Full GC 有什么不同呢？
+
+- 新生代 GC（Minor GC）:指发生新生代的的垃圾收集动作，Minor GC 非常频繁，回收速度一般也比较快。
+- 老年代 GC（Major GC/Full GC）:指发生在老年代的 GC，出现了 Major GC 经常会伴随至少一次的 Minor GC（并非绝对），Major GC 的速度一般会比 Minor GC 的慢 10 倍以上。
+
+#### 大对象直接进入老年代
+
+大对象就是需要大量连续内存空间的对象（比如：字符串、数组）。这样做主要是为了避免为大对象分配内存时由于分配担保机制带来的复制而降低效率。
+
+#### 长期存活的对象将进入老年代
+
+既然虚拟机采用了分代收集的思想来管理内存，那么内存回收时就必须能识别哪些对象应放在新生代，哪些对象应放在老年代中。为了做到这一点，虚拟机给每个对象一个对象年龄（Age）计数器。
+
+如果对象在Eden出生并经过第一次Minor GC后仍然能够存活，并且能被Survivor容纳的话，将被移动到Survivor空间中，并将对象年龄设为1.对象在Survivor中每熬过一次MinorGC,年龄就增加1岁，当它的年龄增加到一定程度（一般都会说默认为 15 岁，其实默认晋升年龄并不都是15，这个是要区分垃圾收集器的，CMS就是6.），就会被晋升到老年代中。对象晋升到老年代的年龄阈值，可以通过参数 `-XX:MaxTenuringThreshold` 来设置。
+
+
+
+### 方法区（Method Area）
+
+方法区也称”永久代“，它用于存储虚拟机加载的类信息、常量、静态变量、是各个线程共享的内存区域。默认最小值为16MB，最大值为64MB（64位JVM由于指针膨胀，默认是85M），可以通过-XX:PermSize 和 -XX:MaxPermSize 参数限制方法区的大小。它是一片连续的堆空间，永久代的垃圾收集是和老年代(old generation)捆绑在一起的，因此无论谁满了，都会触发永久代和老年代的垃圾收集。不过，一个明显的问题是，当JVM加载的类信息容量超过了参数-XX：MaxPermSize设定的值时，应用将会报OOM的错误。参数是通过-XX:PermSize和-XX：MaxPermSize来设定的。
+
+
+
+### 虚拟机栈(JVM Stack)
+
+描述的是java方法执行的内存模型：每个方法被执行的时候都会创建一个”栈帧”,用于存储局部变量表(包括参数)、操作栈、方法出口等信息。每个方法被调用到执行完的过程，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程**。**声明周期与线程相同，是线程私有的。栈帧由三部分组成：局部变量区、操作数栈、帧数据区。局部变量区被组织为以一个字长为单位、从0开始计数的数组，和局部变量区一样，操作数栈也被组织成一个以字长为单位的数组。但和前者不同的是，它不是通过索引来访问的，而是通过入栈和出栈来访问的，可以看作为临时数据的存储区域。除了局部变量区和操作数栈外，java栈帧还需要一些数据来支持常量池解析、正常方法返回以及异常派发机制。这些数据都保存在java栈帧的帧数据区中。
+
+局部变量表: 存放了编译器可知的各种基本数据类型、对象引用(引用指针，并非对象本身)，其中64位长度的long和double类型的数据会占用2个局部变量的空间，其余数据类型只占1个。局部变量表所需的内存空间**在**编译期间完成分配，当进入一个方法时，这个方法需要在栈帧中分配多大的局部变量是完全确定的，在运行期间栈帧不会改变局部变量表的大小空间。
+
+
+
+### 本地方法栈(Native Stack)
+
+与虚拟机栈基本类似，区别在于虚拟机栈为虚拟机执行的java方法服务，而本地方法栈则是为Native方法服务(栈的空间大小远远小于堆)。
+
+### 程序计数器（PC Register）
+
+最小的一块内存区域，它的作用是当前线程所执行的字节码的行号指示器，在虚拟机的模型里，字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令**，**分支**、**循环、异常处理、线程恢复等基础功能都需要依赖计数器完成。
+
+### 直接内存
+
+直接内存并不是虚拟机内存的一部分，也不是Java虚拟机规范中定义的内存区域。jdk1.4中新加入的NIO，引入了通道与缓冲区的IO方式，它可以调用Native方法直接分配堆外内存，这个堆外内存就是本机内存，不会影响到堆内存的大小.
+
+
+
+## 如何判断对象是垃圾
+
+### 引用计数算法
 
 在`JDK1.2`之前，使用的是引用计数器算法，即当这个类被加载到内存以后，就会产生方法区，
 堆栈、程序计数器等一系列信息，当创建对象的时候，为这个对象在堆栈空间中分配对象，
@@ -10,6 +81,7 @@ JVM垃圾回收机制
 而当其中一个引用销毁的时候，引用计数器-1，当引用计数器被减为零的时候，
 标志着这个对象已经没有引用了，可以回收了！
 这种算法在JDK1.2之前的版本被广泛使用，但是随着业务的发展，很快出现了一个问题，那就是互相引用的问题:   
+
 ```java
 ObjA.obj = ObjB
 ObjB.obj - ObjA
@@ -20,8 +92,11 @@ ObjB.obj - ObjA
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/yinyongjishu.jpg)
 
-根搜索算法
----
+
+
+
+
+### 根搜索算法
 
 根搜索算法是从离散数学中的图论引入的，程序把所有的引用关系看作一张图，
 从一个节点`GC ROOT`开始，寻找对应的引用节点，找到这个节点以后，继续寻找这个节点的引用节点，
@@ -46,69 +121,335 @@ ObjB.obj - ObjA
 
 那我们就继续分析下这三种算法：  
 
-- 标记-清除算法(Mark-Sweep)        
-    ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/biaoji_qingchu.jpg)
-    标记-清除算法采用从根集合进行扫描，对存活的对象对象标记，标记完毕后，再扫描整个空间中未被标记  的对象，进行回收，如上图所示。
-    标记-清除算法不需要进行对象的移动，并且仅对不存活的对象进行处理，在存活对象比较多的情况下极为高效，但由于标记-清除算法直接回收不存活的对象，因此会造成内存碎片！
-
-- 复制算法(Copying)           
-    ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/fuzhisuanfa.jpg)
-
-    复制算法采用从根集合扫描，并将存活对象复制到一块新的，没有使用过的空间中，这种算法当控件存活的对象比较少时，极为高效，但是带来的成本是需要一块内存交换空间用于进行对象的移动。
- 
-- 标记-整理算法(Mark-Compact)              
-    ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/biaoji_zhengli.jpg)
- 
-    整理算法采用标记-清除算法一样的方式进行对象的标记，但在清除时不同，在回收不存活的对象占用的空间后，会将所有的存活对象往左端空闲空间移动，并更新对应的指针。标记-整理算法是在标记-清除算法的基础上，又进行了对象的移动，因此成本更高，但是却解决了内存碎片的问题。
-
-- 分代收集算法(Generational Collection)
-    分代收集算法是目前大部分`JVM`的垃圾收集器采用的算法。它的核心思想是根据对象存活的生命周期将内存划分为若干个不同的区域。
-	一般情况下将堆区划分为老年代（`Tenured Generation`）和新生代（`Young Generation`），老年代的特点是每次垃圾收集时只有少量对象需要被回收，
-	而新生代的特点是每次垃圾回收时都有大量的对象需要被回收，那么就可以根据不同代的特点采取最适合的收集算法。
-　　目前大部分垃圾收集器对于新生代都采取复制算法，因为新生代中每次垃圾回收都要回收大部分对象，也就是说需要复制的操作次数较少，
-    但是实际中并不是按照1：1的比例来划分新生代的空间的，一般来说是将新生代划分为一块较大的`Eden`空间和两块较小的`Survivor`空间，
-	每次使用`Eden`空间和其中的一块`Survivor`空间，当进行回收时，将`Eden`和`Survivor`中还存活的对象复制到另一块`Survivor`空间中，
-	然后清理掉`Eden`和刚才使用过的`Survivor`空间。
-
-　　而由于老年代的特点是每次回收都只回收少量对象，一般使用的是标记-整理算法。
-　　注意，在堆区之外还有一个代就是永久代（`Permanet Generation`），它用来存储`class`类、常量、方法描述等。对永久代的回收主要回收两部分内容：
-    废弃常量和无用的类。         
-	![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/xinshengdai.jpg)
-	对象的内存分配，往大方向上讲就是在堆上分配，对象主要分配在新生代的`Eden Space`和`From Space`，
-	少数情况下会直接分配在老年代。如果新生代的`Eden Space`和`From Space`的空间不足，则会发起一次`GC`，如果进行了`GC`之后，`Eden Space`和`From Space`
-	能够容纳该对象就放在`Eden Space`和`From Space`。在`GC`的过程中，会将`Eden Space`和`From  Space`中的存活对象移动到`To Space`，
-	然后将`Eden Space`和`From Space`进行清理。如果在清理的过程中，`To Space`无法足够来存储某个对象，就会将该对象移动到老年代中。
-	在进行了`GC之`后，使用的便是`Eden space`和`To Space`了，下次`GC`时会将存活对象复制到`From Space`，如此反复循环。
-	当对象在`Survivor`区躲过一次`GC`的话，其对象年龄便会加1，默认情况下，如果对象年龄达到15岁，就会移动到老年代中。
-	
-垃圾收集器
----
+### 标记-清除算法(Mark-Sweep)        
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/biaoji_qingchu.png)	
+
+原理：从根集合节点进行扫描，标记出所有的存活对象，最后扫描整个内存空间并清除没有标记的对象（即死亡对象）    
+
+适用场合：
+
+- 存活对象较多的情况下比较高效 
+- 适用于年老代（即旧生代） 
+
+缺点: 
+
+- 标记清除算法带来的一个问题是会存在大量的空间碎片，因为回收后的空间是不连续的，这样给大对象分配内存的时候可能会提前触发full gc。 
+
+### 标记复制算法(mark-copy)           
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/fuzhisuanfa.png)
+
+原理：思路也很简单，将内存对半分，总是保留一块空着（上图中的右侧），将左侧存活的对象（浅灰色区域）复制到右侧，然后左侧全部清空。避免了内存碎片问题，但是内存浪费很严重，相当于只能使用 50% 的内存。。从根集合节点进行扫描，标记出所有的存活对象，并将这些存活的对象复制到一块儿新的内存（图中下边的那一块儿内存）上去，之后将原来的那一块儿内存（图中上边的那一块儿内存）全部回收掉 
+
+适用场合：
+
+- 存活对象较少的情况下比较高效 
+- 扫描了整个空间一次（标记存活对象并复制移动） 
+- 适用于年轻代（即新生代）：基本上98%的对象是”朝生夕死”的，存活下来的会很少 
+
+缺点：
+
+- 需要一块儿空的内存空间 
+- 需要复制移动对象 
+
+### 标记-整理算法(Mark-Compact)              
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/biaoji_zhengli.png)
+
+原理：从根集合节点进行扫描，标记出所有的存活对象，最后扫描整个内存空间并清除没有标记的对象（即死亡对象）（可以发现前边这些就是标记-清除算法的原理），清除完之后，将所有的存活对象左移到一起。 避免了上述两种算法的缺点，将垃圾对象清理掉后，同时将剩下的存活对象进行整理挪动（类似于 windows 的磁盘碎片整理），保证它们占用的空间连续，这样就避免了内存碎片问题，但是整理过程也会降低 GC 的效率。
+
+适用场合：
+
+- 用于年老代（即旧生代） 
+
+缺点：
+
+- 需要移动对象，若对象非常多而且标记回收后的内存非常不完整，可能移动这个动作也会耗费一定时间 
+- 扫描了整个空间两次（第一次：标记存活对象；第二次：清除没有标记的对象） 
+
+优点：
+
+- 不会产生内存碎片 
+
+### 分代收集算法(Generational Collection)
+
+上述三种算法，每种都有各自的优缺点，都不完美。在现代 JVM  中，往往是综合使用的，经过大量实际分析，发现内存中的对象，大致可以分为两类：有些生命周期很短，比如一些局部变量 /  临时对象，而另一些则会存活很久，典型的比如 websocket 长连接中的 connection 对象，如下图：
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/62226d097ac54148804119b4c239c802.png)
+
+纵向 y 轴可以理解分配内存的字节数，横向 x 轴理解为随着时间流逝（伴随着 GC），可以发现大部分对象其实相当短命，很少有对象能在 GC 后活下来。因此诞生了分代的思想，以 Hotspot 为例（JDK 7）：
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/e4ff361d409b6939e6da49a06b6dc677.png)
+
+将内存分成了三大块：年青代（Young Genaration），老年代（Old Generation）, 永久代（Permanent Generation），其中 Young Genaration 更是又细为分 eden，S0，S1 三个区。
+
+结合我们经常使用的一些 jvm 调优参数后，一些参数能影响的各区域内存大小值，示意图如下：
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/d4e6583cd0ecfa60622526e7a4f13634.png)
+
+注：jdk8 开始，用 MetaSpace 区取代了 Perm 区（永久代），所以相应的 jvm 参数变成 -XX:MetaspaceSize 及 -XX:MaxMetaspaceSize。
+
+以 Hotspot 为例，我们来分析下 GC 的主要过程：
+
+刚开始时，对象分配在 eden 区，s0（即：from）及 s1（即：to）区，几乎是空着。
+
+![一文看懂JVM内存布局及GC原理](https://raw.githubusercontent.com/CharonChui/Pictures/master/8dc1423cc9f85658a946e204dc85ec18.png)
+
+随着应用的运行，越来越多的对象被分配到 eden 区。
+
+![一文看懂JVM内存布局及GC原理](https://raw.githubusercontent.com/CharonChui/Pictures/master/c9138916377192a8a2590aca3e888049.png)
+
+当 eden 区放不下时，就会发生 minor GC（也被称为 young GC），第 1  步当然是要先标识出不可达垃圾对象（即：下图中的黄色块），然后将可达对象，移动到 s0 区（即：4 个淡蓝色的方块挪到 s0  区），然后将黄色的垃圾块清理掉，这一轮过后，eden 区就成空的了。
+
+注：这里其实已经综合运用了“【标记 - 清理 eden】 + 【标记 - 复制 eden->s0】”算法。
+
+![一文看懂JVM内存布局及GC原理](https://raw.githubusercontent.com/CharonChui/Pictures/master/adc376cad0670c6993da8f32f3a88aba.png)
+
+随着时间推移，eden 如果又满了，再次触发 minor GC，同样还是先做标记，这时 eden 和 s0  区可能都有垃圾对象了（下图中的黄色块），注意：这时 s1（即：to）区是空的，s0 区和 eden 区的存活对象，将直接搬到 s1 区。然后将  eden 和 s0 区的垃圾清理掉，这一轮 minor GC 后，eden 和 s0 区就变成了空的了。
+
+![一文看懂JVM内存布局及GC原理](https://raw.githubusercontent.com/CharonChui/Pictures/master/f21d18a0736d0976c4ecf14e82236cb2.png)
+
+继续，随着对象的不断分配，eden 空可能又满了，这时会重复刚才的 minor GC 过程，不过要注意的是，这时候 s0 是空的，所以  s0 与 s1 的角色其实会互换，即：存活的对象，会从 eden 和 s1 区，向 s0 区移动。然后再把 eden 和 s1  区中的垃圾清除，这一轮完成后，eden 与 s1 区变成空的，如下图。
+
+![一文看懂JVM内存布局及GC原理](https://raw.githubusercontent.com/CharonChui/Pictures/master/f765eb0f46635ae093516f35fb1eee66.png)
+
+对于那些比较“长寿”的对象一直在 s0 与 s1 中挪来挪去，一来很占地方，而且也会造成一定开销，降低 gc 效率，于是有了“代龄 (age)”及“晋升”。
+
+对象在年青代的 3 个区 (edge,s0,s1) 之间，每次从 1 个区移到另 1 区，年龄 +1，在 young  区达到一定的年龄阈值后，将晋升到老年代。下图中是 8，即：挪动 8 次后，如果还活着，下次 minor GC 时，将移动到 Tenured 区。
+
+![一文看懂JVM内存布局及GC原理](https://raw.githubusercontent.com/CharonChui/Pictures/master/2705a4ba41ed37bd535adab5b91ffb8f.png)
+
+下图是晋升的主要过程：对象先分配在年青代，经过多次 Young GC 后，如果对象还活着，晋升到老年代。
+
+![一文看懂JVM内存布局及GC原理](https://raw.githubusercontent.com/CharonChui/Pictures/master/6d24d96eb137f805c867736a750c2bd9.png)
+
+如果老年代，最终也放满了，就会发生 major GC（即 Full GC），由于老年代的的对象通常会比较多，因为标记 - 清理 - 整理（压缩）的耗时通常会比较长，会让应用出现卡顿的现象，这也是为什么很多应用要优化，尽量避免或减少 Full GC 的原因。
+
+![一文看懂JVM内存布局及GC原理](https://raw.githubusercontent.com/CharonChui/Pictures/master/ebad989a70f78a40c561df9943234441.png)
+
+注：上面的过程主要来自 oracle 官网的资料，但是有一个细节官网没有提到，如果分配的新对象比较大，eden 区放不下，但是 old 区可以放下时，会直接分配到 old 区（即没有晋升这一过程，直接到老年代了）。
+
+下图引自阿里出品的《码出高效 -Java 开发手册》一书，梳理了 GC 的主要过程。
+
+![一文看懂JVM内存布局及GC原理](https://raw.githubusercontent.com/CharonChui/Pictures/master/e663bd3043c6b3465edc1e7313671d69.png)
+
+
+
+##  垃圾回收器
+
+不算最新出现的神器 ZGC，历史上出现过 7 种经典的垃圾回收器。
+
+![一文看懂JVM内存布局及GC原理](https://raw.githubusercontent.com/CharonChui/Pictures/master/ab1c7be2fa4b5d180ffa1f43bf9dfce7.png)
+
+这些回收器都是基于分代的，把 G1 除外，按回收的分代划分，横线以上的 3 种：Serial ,ParNew, Parellel  Scavenge 都是回收年青代的，横线以下的 3 种：CMS，Serial Old, Parallel Old 都是回收老年代的。
+
+
 
 垃圾收集算法是内存回收的理论基础，而垃圾收集器就是内存回收的具体实现。
 下面介绍一下`HotSpot(JDK 7)`虚拟机提供的几种垃圾收集器，用户可以根据自己的需求组合出各个年代使用的收集器。	
-- Serial/Serial Old
-    `Serial/Serial Old`收集器是最基本最古老的收集器，它是一个单线程收集器，并且在它进行垃圾收集时，
-	必须暂停所有用户线程。`Serial`收集器是针对新生代的收集器，采用的是`Copying`算法，`Serial Old`收集器是针对老年代的收集器，
-	采用的是`Mark-Compact`算法。它的优点是实现简单高效，但是缺点是会给用户带来停顿。
-	
-- ParNew
-    `ParNew`收集器是`Serial`收集器的多线程版本，使用多个线程进行垃圾收集。	
-	
-- Parallel Scavenge	
-    `Parallel Scavenge`收集器是一个新生代的多线程收集器（并行收集器），它在回收期间不需要暂停其他用户线程，其采用的是`Copying`算法，
-	该收集器与前两个收集器有所不同，它主要是为了达到一个可控的吞吐量。
-
-- Parallel Old
-    `Parallel Old`是`Parallel Scavenge`收集器的老年代版本（并行收集器），使用多线程和`Mark-Compact`算法。	
-	
-- CMS
-    `CMS(Current Mark Sweep)`收集器是一种以获取最短回收停顿时间为目标的收集器，它是一种并发收集器，采用的是`Mark-Sweep`算法。	
-	
-- G1
-    `G1`收集器是当今收集器技术发展最前沿的成果，它是一款面向服务端应用的收集器，它能充分利用多`CPU`、多核环境。因此它是一款并行与并发收集器，
-	并且它能建立可预测的停顿时间模型。	
-	
-	
+
+### Serial/Serial Old
+`Serial/Serial Old`收集器是最基本最古老的收集器，它是一个单线程收集器，并且在它进行垃圾收集时，
+必须暂停所有用户线程。`Serial`收集器是针对新生代的收集器，采用的是`Copying`算法，`Serial Old`收集器是针对老年代的收集器，
+采用的是`Mark-Compact`算法。它的优点是实现简单高效，但是缺点是会给用户带来停顿。
+
+### ParNew	
+
+ParNew收集器是Serial收集器新生代的多线程实现，注意在进行垃圾回收的时候依然会stop the world，只是相比较Serial收集器而言它会运行多条进程进行垃圾回收。
+
+ParNew收集器在单CPU的环境中绝对不会有比Serial收集器更好的效果，甚至由于存在线程交互的开销，该收集器在通过超线程技术实现的两个CPU的环境中都不能百分之百的保证能超越Serial收集器。当然，随着可以使用的CPU的数量增加，它对于GC时系统资源的利用还是很有好处的。它默认开启的收集线程数与CPU的数量相同，在CPU非常多（譬如32个，现在CPU动辄4核加超线程，服务器超过32个逻辑CPU的情况越来越多了）的环境下，可以使用-XX:ParallelGCThreads参数来限制垃圾收集的线程数。
+
+### Parallel Scavenge	
+Parallel是采用复制算法的多线程新生代垃圾回收器，似乎和ParNew收集器有很多的相似的地方。但是Parallel  Scanvenge收集器的一个特点是它所关注的目标是吞吐量(Throughput)。所谓吞吐量就是CPU用于运行用户代码的时间与CPU总消耗时间的比值，即吞吐量=运行用户代码时间 / (运行用户代码时间 +  垃圾收集时间)。停顿时间越短就越适合需要与用户交互的程序，良好的响应速度能够提升用户的体验；而高吞吐量则可以最高效率地利用CPU时间，尽快地完成程序的运算任务，主要适合在后台运算而不需要太多交互的任务。
+
+### CMS	
+
+全称：Concurrent Mark Sweep，从名字上看，就能猜出它是并发多线程的。这是 JDK 7 中广泛使用的收集器，有必要多说一下，借一张网友的图说话：
+
+![一文看懂JVM内存布局及GC原理](https://static001.infoq.cn/resource/image/e8/4e/e8b152cf510b06544c2a13bfb4fc564e.png)
+
+相对Serial Old 收集器或Parallel Old 收集器而言，这个明显要复杂多了，从名字(Mark Swep)就可以看出，CMS收集器是基于标记清除算法实现的。它的收集过程分为四个步骤：
+
+1. 初始标记(initial mark) 
+2. 并发标记(concurrent mark) 
+3. 重新标记(remark) 
+4. 并发清除(concurrent sweep) 
+
+分为 4 个阶段：
+
+1）Inital Mark 初始标记：主要是标记 GC Root 开始的下级（注：仅下一级）对象，这个过程会 STW，但是跟 GC Root 直接关联的下级对象不会很多，因此这个过程其实很快。
+
+2）Concurrent Mark 并发标记：根据上一步的结果，继续向下标识所有关联的对象，直到这条链上的最尽头。这个过程是多线程的，虽然耗时理论上会比较长，但是其它工作线程并不会阻塞，没有 STW。
+
+3）Remark 再标志：为啥还要再标记一次？因为第 2 步并没有阻塞其它工作线程，其它线程在标识过程中，很有可能会产生新的垃圾。
+
+试想下，高铁上的垃圾清理员，从车厢一头开始吆喝“有需要扔垃圾的乘客，请把垃圾扔一下”，一边工作一边向前走，等走到车厢另一头时，刚才走过的位置上，可能又有乘客产生了新的空瓶垃圾。所以，要完全把这个车厢清理干净的话，她应该喊一下：所有乘客不要再扔垃圾了（STW），然后把新产生的垃圾收走。当然，因为刚才已经把收过一遍垃圾，所以这次收集新产生的垃圾，用不了多长时间（即：STW 时间不会很长）。
+
+4）Concurrent Sweep：并行清理，这里使用多线程以“Mark Sweep- 标记清理”算法，把垃圾清掉，其它工作线程仍然能继续支行，不会造成卡顿。
+
+等等，刚才我们不是提到过“标记清理”法，会留下很多内存碎片吗？确实，但是也没办法，如果换成“Mark Compact 标记 -  整理”法，把垃圾清理后，剩下的对象也顺便排整理，会导致这些对象的内存地址发生变化，别忘了，此时其它线程还在工作，如果引用的对象地址变了，就天下大乱了。
+
+另外，由于这一步是并行处理，并不阻塞其它线程，所以还有一个副使用，在清理的过程中，仍然可能会有新垃圾对象产生，只能等到下一轮 GC，才会被清理掉。不过由于CMS收集器是基于标记清除算法实现的，会导致有大量的空间碎片产生，在为大对象分配内存的时候，往往会出现老年代还有很大的空间剩余，但是无法找到足够大的连续空间来分配当前对象，不得不提前开启一次Full GC。
+
+为了解决这个问题，CMS收集器默认提供了一个-XX:+UseCMSCompactAtFullCollection收集开关参数（默认就是开启的)，用于在CMS收集器进行FullGC完开启内存碎片的合并整理过程，内存整理的过程是无法并发的，这样内存碎片问题倒是没有了，不过停顿时间不得不变长。虚拟机设计者还提供了另外一个参数-XX:CMSFullGCsBeforeCompaction参数用于设置执行多少次不压缩的FULL GC后跟着来一次带压缩的（默认值为0，表示每次进入Full GC时都进行碎片整理）。
+
+不幸的是，它作为老年代的收集器，却无法与jdk1.4中已经存在的新生代收集器Parallel  Scavenge配合工作，所以在jdk1.5中使用cms来收集老年代的时候，新生代只能选择ParNew或Serial收集器中的一个。ParNew收集器是使用-XX:+UseConcMarkSweepGC选项启用CMS收集器之后的默认新生代收集器，也可以使用-XX:+UseParNewGC选项来强制指定它。
+
+虽然仍不完美，但是从这 4 步的处理过程来看，以往收集器中最让人诟病的长时间 STW，通过上述设计，被分解成二次短暂的 STW，所以从总体效果上看，应用在 GC 期间卡顿的情况会大大改善，这也是 CMS 一度十分流行的重要原因。
+
+### G1
+
+G1 的全称是 Garbage-First，为什么叫这个名字，呆会儿会详细说明。鉴于 CMS 的一些不足之外，比如:  老年代内存碎片化，STW 时间虽然已经改善了很多，但是仍然有提升空间。G1 就横空出世了，它对于 heap  区的内存划思路很新颖，有点算法中分治法“分而治之”的味道。G1收集器是一款面向服务端应用的垃圾收集器。HotSpot团队赋予它的使命是在未来替换掉JDK1.5中发布的CMS收集器。与其他GC收集器相比，G1具备如下特点：
+
+1. 并行与并发：G1能更充分的利用CPU，多核环境下的硬件优势来缩短stop the world的停顿时间。 
+2. 分代收集：和其他收集器一样，分代的概念在G1中依然存在，不过G1不需要其他的垃圾回收器的配合就可以独自管理整个GC堆。 
+3. 空间整合：G1收集器有利于程序长时间运行，分配大对象时不会无法得到连续的空间而提前触发一次GC。 
+4. 可预测的非停顿：这是G1相对于CMS的另一大优势，降低停顿时间是G1和CMS共同的关注点，能让使用者明确指定在一个长度为M毫秒的时间片段内，消耗在垃圾收集上的时间不得超过N毫秒。 
+
+在使用G1收集器时，Java堆的内存布局和其他收集器有很大的差别，它将这个Java堆分为多个大小相等的独立区域，虽然还保留新生代和老年代的概念，但是新生代和老年代不再是物理隔离的了，它们都是一部分Region（不需要连续）的集合。
+
+虽然G1看起来有很多优点，实际上CMS还是主流。
+
+
+
+如下图，G1 将 heap 内存区，划分为一个个大小相等（1-32M，2 的 n 次方）、内存连续的 Region 区域，每个  region 都对应 Eden、Survivor 、Old、Humongous 四种角色之一，但是 region 与 region  之间不要求连续。
+
+注：Humongous，简称 H 区是专用于存放超大对象的区域，通常 >= 1/2 Region Size，且只有 Full GC 阶段，才会回收 H 区，避免了频繁扫描、复制 / 移动大对象。
+
+所有的垃圾回收，都是基于 1 个个 region 的。JVM 内部知道，哪些 region  的对象最少（即：该区域最空），总是会优先收集这些 region（因为对象少，内存相对较空，肯定快），这也是 Garbage-First  得名的由来，G 即是 Garbage 的缩写， 1 即 First。
+
+![一文看懂JVM内存布局及GC原理](https://raw.githubusercontent.com/CharonChui/Pictures/master/f1a1bdecf4e56a4440707ce073d73f61.png)
+
+**G1 Young GC**
+
+young GC 前：
+
+![一文看懂JVM内存布局及GC原理](https://raw.githubusercontent.com/CharonChui/Pictures/master/28b9077c545675b934d64ee643e30a9a.png)
+
+young GC 后：
+
+![一文看懂JVM内存布局及GC原理](https://raw.githubusercontent.com/CharonChui/Pictures/master/be46c92240c7fd6dfcc6c11a48e4edd9.png)
+
+理论上讲，只要有一个 Empty Region（空区域），就可以进行垃圾回收。
+
+![一文看懂JVM内存布局及GC原理](https://raw.githubusercontent.com/CharonChui/Pictures/master/28ca063660f168b462ed8466faa77e68.png)
+
+由于 region 与 region 之间并不要求连续，而使用 G1 的场景通常是大内存，比如 64G 甚至更大，为了提高扫描根对象和标记的效率，G1 使用了二个新的辅助存储结构：
+
+Remembered Sets：简称 RSets，用于根据每个 region 里的对象，是从哪指向过来的（即：谁引用了我），每个 Region 都有独立的 RSets。（Other Region -> Self Region）。
+
+Collection Sets ：简称 CSets，记录了等待回收的 Region 集合，GC 时这些 Region 中的对象会被回收（copied or moved）。
+
+RSets 的引入，在 YGC 时，将年青代 Region 的 RSets 做为根对象，可以避免扫描老年代的 region，能大大减轻  GC 的负担。注：在老年代收集 Mixed GC 时，RSets 记录了 Old->Old 的引用，也可以避免扫描所有 Old 区。
+
+
+
+### ZGC （截止目前史上最好的 GC 收集器）
+
+在 G1 的基础上，做了很多改进（JDK 11 开始引入）
+
+#### 动态调整大小的 Region
+
+G1 中每个 Region 的大小是固定的，创建和销毁 Region，可以动态调整大小，内存使用更高效。
+
+![一文看懂JVM内存布局及GC原理](https://static001.infoq.cn/resource/image/4f/03/4fd12cf96cf020e56d071161fa56b603.png)
+
+#### 不分代，干掉了 RSets
+
+G1 中每个 Region 需要借助额外的 RSets 来记录“谁引用了我”，占用了额外的内存空间，每次对象移动时，RSets 也需要更新，会产生开销。
+
+注：ZGC 没有为止，没有实现分代机制，每次都是并发的对所有 region 进行回收，不象 G1 是增量回收，所以用不着  RSets。不分代的带来的可能性能下降，会用下面马上提到的 Colored Pointer && Load Barrier  来优化。
+
+#### 带颜色的指针 Colored Pointer
+
+![一文看懂JVM内存布局及GC原理](https://static001.infoq.cn/resource/image/0e/5a/0e071b9c1124d0b7b09150d960c2925a.png)
+
+这里的指针类似 java 中的引用，意为对某块虚拟内存的引用。ZGC 采用了 64 位指针（注：目前只支持 linux 64 位系统），将 42-45 这 4 个 bit 位置赋予了不同的含义，即所谓的颜色标志位，也换为指针的 metadata。
+
+finalizable 位：仅 finalizer（类比 c++ 中的析构函数）可访问；
+
+remap 位：指向对象当前（最新）的内存地址，参考下面提到的 relocation；
+
+marked0 && marked1 位：用于标志可达对象；
+
+这 4 个标志位，同一时刻只会有 1 个位置是 1。每当指针对应的内存数据发生变化，比如内存被移动，颜色会发生变化。
+
+####  读屏障 Load Barrier
+
+传统 GC 做标记时，为了防止其它线程在标记期间修改对象，通常会简单的 STW。而 ZGC 有了 Colored Pointer  后，引入了所谓的读屏障，当指针引用的内存正被移动时，指针上的颜色就会变化，ZGC 会先把指针更新成最新状态，然后再返回。（大家可以回想下  java 中的[ volatile 关键字](https://www.cnblogs.com/yjmyzz/p/6994796.html)，有异曲同工之妙），这样仅读取该指针时可能会略有开销，而不用将整个 heap STW。
+
+#### 重定位 relocation
+
+![一文看懂JVM内存布局及GC原理](https://static001.infoq.cn/resource/image/0e/dd/0ee7dc65b940fe54d0b67a217174d2dd.png)
+
+如上图，在标记过程中，先从 Roots 对象找到了直接关联的下级对象 1，2，4。
+
+![一文看懂JVM内存布局及GC原理](https://static001.infoq.cn/resource/image/fd/e2/fd2797de4c1ba3b3f8e3b6b871d773e2.png)
+
+然后继续向下层标记，找到了 5，8 对象， 此时已经可以判定 3，6，7 为垃圾对象。
+
+![一文看懂JVM内存布局及GC原理](https://static001.infoq.cn/resource/image/95/28/9524b9346adfa6f78283b73b1b201728.png)
+
+如果按常规思路，一般会将 8 从最右侧的 Region 移动或复制到中间的 Region，然后再将中间 Region 的 3  干掉，最后再对中间 Region 做压缩 compact 整理。但 ZGC 做得更高明，它直接将 4，5 复制到了一个空的新 Region  就完事了，然后中间的 2 个 Region 直接废弃，或理解为“释放”，做为下次回收的“新”Region。这样的好处是避免了中间 Region 的 compact 整理过程。
+
+![一文看懂JVM内存布局及GC原理](https://static001.infoq.cn/resource/image/7b/22/7b18ada0e14c1fb65eabd73d7760a422.png)
+
+最后，指针重新调整为正确的指向（即：remap），而且上一阶段的 remap 与下一阶段的 mark 是混在一起处理的，相对更高效。
+
+Remap 的流程图如下：
+
+![一文看懂JVM内存布局及GC原理](https://static001.infoq.cn/resource/image/8f/c7/8f02e87ca3f90da08edb414e174fd8c7.png)
+
+####  多重映射 Multi-Mapping
+
+这个优化，说实话没完全看懂，只能谈下自己的理解（如果有误，欢迎指正)。虚拟内存与实际物理内存，OS 会维护一个映射关系，才能正常使用。如下图：
+
+![一文看懂JVM内存布局及GC原理](https://static001.infoq.cn/resource/image/4c/c4/4ce9d8741ffd7bcde179ed56ac56abc4.png)
+
+zgc 的 64 位颜色指针，在解除映射关系时，代价较高（需要屏蔽额外的 42-45 的颜色标志位）。考虑到这 4 个标志位，同 1  时刻，只会有 1 位置成 1（如下图），另外 finalizable 标志位，永远不希望被解除映射绑定（可不用考虑映射问题）。
+
+所以剩下 3 种颜色的虚拟内存，可以都映射到同 1 段物理内存。即映射复用，或者更通俗点讲，本来 3 种不同颜色的指针，哪怕 0-41 位完全相同，也需要映射到 3 段不同的物理内存，现在只需要映射到同 1 段物理内存即可。
+
+![一文看懂JVM内存布局及GC原理](https://static001.infoq.cn/resource/image/ac/49/ac0d5ac0f5f32a7c1c23bde7f513b649.png)
+
+![一文看懂JVM内存布局及GC原理](https://static001.infoq.cn/resource/image/44/2c/445295bc8132bf5aa33fd5aa6cc3c02c.png)
+
+####  支持[ NUMA 架构](https://baike.baidu.com/item/NUMA/6906025?fr=aladdin)
+
+NUMA 是一种多核服务器的架构，简单来讲，一个多核服务器（比如 2core），每个 cpu 都有属于自己的存储器，会比访问另一个核的存储器会慢很多（类似于就近访问更快）。
+
+相对之前的 GC 算法，ZGC 首次支持了 NUMA 架构，申请堆内存时，判断当前线程属是哪个 CPU 在执行，然后就近申请该 CPU 能使用的内存。
+
+**小结**：革命性的 ZGC 经过上述一堆优化后，每次 GC 总体卡顿时间按官方说法 <10ms。注：启用 zgc，需要设置 -XX:+UnlockExperimentalVMOptions -XX:+UseZGC。
+
+
+
+
+
+
+
+# 	与GC相关的常用参数 
+
+​	除了上面提及的一些参数，下面补充一些和GC相关的常用参数：
+
+- ​		-Xmx: 设置堆内存的最大值。 
+- ​		-Xms: 设置堆内存的初始值。 
+- ​		-Xmn: 设置新生代的大小。 
+- ​		-Xss: 设置栈的大小。 
+- ​		-PretenureSizeThreshold: 直接晋升到老年代的对象大小，设置这个参数后，大于这个参数的对象将直接在老年代分配。 
+- ​		-MaxTenuringThrehold: 晋升到老年代的对象年龄。每个对象在坚持过一次Minor GC之后，年龄就会加1，当超过这个参数值时就进入老年代。 
+- ​		-UseAdaptiveSizePolicy:  在这种模式下，新生代的大小、eden 和 survivor  的比例、晋升老年代的对象年龄等参数会被自动调整，以达到在堆大小、吞吐量和停顿时间之间的平衡点。在手工调优比较困难的场合，可以直接使用这种自适应的方式，仅指定虚拟机的最大堆、目标的吞吐量 (GCTimeRatio) 和停顿时间 (MaxGCPauseMills)，让虚拟机自己完成调优工作。 
+- ​		-SurvivorRattio: 新生代Eden区域与Survivor区域的容量比值，默认为8，代表Eden: Suvivor= 8: 1。 
+- ​		-XX:ParallelGCThreads：设置用于垃圾回收的线程数。通常情况下可以和 CPU 数量相等。但在 CPU 数量比较多的情况下，设置相对较小的数值也是合理的。 
+- ​		-XX:MaxGCPauseMills：设置最大垃圾收集停顿时间。它的值是一个大于 0 的整数。收集器在工作时，会调整 Java 堆大小或者其他一些参数，尽可能地把停顿时间控制在 MaxGCPauseMills 以内。 
+- ​		-XX:GCTimeRatio:设置吞吐量大小，它的值是一个 0-100 之间的整数。假设 GCTimeRatio 的值为 n，那么系统将花费不超过 1/(1+n) 的时间用于垃圾收集。 
+
+
+
+参考: 
+
+- [一文看懂 JVM 内存布局及 GC 原理](https://www.infoq.cn/article/3WyReTKqrHIvtw4frmr3)
+
+
+
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
diff --git "a/JavaKnowledge/volatile\345\222\214Synchronized\345\214\272\345\210\253.md" "b/JavaKnowledge/volatile\345\222\214Synchronized\345\214\272\345\210\253.md"
index 2ec2cda3..5b1f37ab 100644
--- "a/JavaKnowledge/volatile\345\222\214Synchronized\345\214\272\345\210\253.md"
+++ "b/JavaKnowledge/volatile\345\222\214Synchronized\345\214\272\345\210\253.md"
@@ -1,30 +1,291 @@
-volatile和Synchronized区别
-===
+# volatile和Synchronized
 
-- volatile
-    作用：使变量在多个线程间可见（可见性）
-    `Java`语言规范中指出：为了获得最佳速度，允许线程保存共享成员变量的私有拷贝，而在这个过程中,变量的新值对其他线程是不可见的.而且只当线程进入或者离开同步代码块时才与共享成员变量
-的原始值对比。这样当多个线程同时与某个对象交互时，就必须要注意到要让线程及时的得到共享成员变量的变化。
+## Java内存模型(Java Memory Model ,JMM)
 
-也就是说每个线程都有一个自己的本地内存空间，在线程执行时，先把变量从主内存读取到线程自己的本地内存空间，然后再对该变量进行操作，当对该变量操作完后，在某个时间再把变量刷新回主内存
+**Java内存模型**(java Memory Model)描述了Java程序中各种变量(**线程共享变量**)的访问规则，以及在JVM中将变量**存储到内存**和从**内存中读取出变量**这样的底层细节。
 
-而`volatile`关键字就是提示`JVM`：对于这个成员变量不能保存它的私有拷贝，而应直接与共享成员变量交互。
-使用建议：在两个或者更多的线程访问的成员变量上使用`volatile`。当要访问的变量已在`synchronized`代码块中，或者为常量时，不必使用。
-由于使用`volatile`屏蔽掉了`JVM`中必要的代码优化，所以在效率上比较低，因此一定在必要时才使用此关键字。 就跟`C`中的一样 禁止编译器进行优化.
 
-注意:如果给一个变量加上`volatile`修饰符，就相当于：每一个线程中一旦这个值发生了变化就马上刷新回主存，使得各个线程取出的值相同。编译器不要对这个变量的读、写操作做优化。但是值得注意的是，除了对`long`和`double`的简单操作之外，`volatile`并不能提供原子性。
-所以，就算你将一个变量修饰为`volatile`，但是对这个变量的操作并不是原子的，在并发环境下，还是不能避免错误的发生！
 
-- synchronized
-    `synchronized`为一段操作或内存进行加锁，它具有互斥性。当线程要操作被`synchronized`修饰的内存或操作时，必须首先获得锁才能进行后续操作；但是在同一时刻只能有一个线程获得相同的一把锁（对象监视器），所以它只允许一个线程进行操作。
-    它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。
-    - 当两个并发线程访问同一个对象中的这个`synchronized(this)`同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
-    - 然而，当一个线程访问`object`的一个`synchronized(this)`同步代码块时，另一个线程仍然可以访问该`object`中的非`synchronized(this)`同步代码块。
-    - 尤其关键的是，当一个线程访问`object`的一个`synchronized(this)`同步代码块时，其他线程对`object`中所有其它`synchronized(this)`同步代码块的访问将被阻塞。
+计算机在执行程序的时候，每条指令都是在CPU中执行的，而执行的时候，又免不了要和数据打交道。而计算机上面的数据，是存放在主存当中的，也就是计算机的物理内存。但是随着CPU技术的发展，CPU的执行速度越来越快。而由于内存的技术并没有太大的变化，所以从内存中读取和写入数据的过程和CPU的执行速度比起来差距就会越来越大,这就导致CPU每次操作内存都要耗费很多等待时间。可是，不能因为内存的读写速度慢，就不发展CPU技术了，所以人们想出来了一个好的办法，就是在CPU和内存之间增加高速缓存。缓存的概念大家都知道，就是保存一份数据拷贝。他的特点是速度快，内存小，并且昂贵。
+
+那么，程序的执行过程就变成了：当程序在运行过程中，会将运算需要的数据从主存复制一份到CPU的高速缓存当中，那么CPU进行计算时就可以直接从它的高速缓存读取数据和向其中写入数据，当运算结束之后，再将高速缓存中的数据刷新到主存当中。而随着CPU能力的不断提升，一层缓存就慢慢的无法满足要求了，就逐渐的衍生出多级缓存。按照数据读取顺序和与CPU结合的紧密程度，CPU缓存可以分为一级缓存（L1），二级缓存（L3），部分高端CPU还具有三级缓存（L3），每一级缓存中所储存的全部数据都是下一级缓存的一部分。
+
+这三种缓存的技术难度和制造成本是相对递减的，所以其容量也是相对递增的。
+
+那么，在有了多级缓存之后，程序的执行就变成了：    
+
+当CPU要读取一个数据时，首先从一级缓存中查找，如果没有找到再从二级缓存中查找，如果还是没有就从三级缓存或内存中查找。
+
+
+
+> 这就像一家创业公司，刚开始，创始人和员工之间工作关系其乐融融，但是随着创始人的能力和野心越来越大，逐渐和员工之间出现了差距，普通员工原来越跟不上CEO的脚步。老板的每一个命令，传到到基层员工之后，由于基层员工的理解能力、执行能力的欠缺，就会耗费很多时间。这也就无形中拖慢了整家公司的工作效率。
+>
+> 之后，这家公司开始设立中层管理人员，管理人员直接归CEO领导，领导有什么指示，直接告诉管理人员，然后就可以去做自己的事情了。管理人员负责去协调底层员工的工作。因为管理人员是了解手下的人员以及自己负责的事情的。所以，大多数时候，公司的各种决策，通知等，CEO只要和管理人员之间沟通就够了。
+>
+> 随着公司越来越大，老板要管的事情越来越多，公司的管理部门开始改革，开始出现高层，中层，底层等管理者。一级一级之间逐层管理。
+>
+> 公司也分很多种，有些公司只有一个大Boss，他一个人说了算。但是有些公司有比如联席总经理、合伙人等机制。
+>
+> 单核CPU就像一家公司只有一个老板，所有命令都来自于他，那么就只需要一套管理班底就够了。
+>
+> 多核CPU就像一家公司是由多个合伙人共同创办的，那么，就需要给每个合伙人都设立一套供自己直接领导的高层管理人员，多个合伙人共享使用的是公司的底层员工。
+>
+> 还有的公司，不断壮大，开始差分出各个子公司。各个子公司就是多个CPU了，互相使用没有共用的资源。互不影响。
+
+随着计算机能力不断提升，开始支持多线程。那么问题就来了。我们分别来分析下单线程、多线程在单核CPU、多核CPU中的影响。
+
+**单线程。**cpu核心的缓存只被一个线程访问。缓存独占，不会出现访问冲突等问题。
+
+**单核CPU，多线程。**进程中的多个线程会同时访问进程中的共享数据，CPU将某块内存加载到缓存后，不同线程在访问相同的物理地址的时候，都会映射到相同的缓存位置，这样即使发生线程的切换，缓存仍然不会失效。但由于任何时刻只能有一个线程在执行，因此不会出现缓存访问冲突。
+
+**多核CPU，多线程。**每个核都至少有一个L1  缓存。多个线程访问进程中的某个共享内存，且这多个线程分别在不同的核心上执行，则每个核心都会在各自的caehe中保留一份共享内存的缓冲。由于多核是可以并行的，可能会出现多个线程同时写各自的缓存的情况，而各自的cache之间的数据就有可能不同。
+
+在CPU和主存之间增加缓存，在多线程场景下就可能存在**缓存一致性问题**，也就是说，在多核CPU中，每个核的自己的缓存中，关于同一个数据的缓存内容可能不一致。
+
+> 如果这家公司的命令都是串行下发的话，那么就没有任何问题。
+>
+> 如果这家公司的命令都是并行下发的话，并且这些命令都是由同一个CEO下发的，这种机制是也没有什么问题。因为他的命令执行者只有一套管理体系。
+>
+> 如果这家公司的命令都是并行下发的话，并且这些命令是由多个合伙人下发的，这就有问题了。因为每个合伙人只会把命令下达给自己直属的管理人员，而多个管理人员管理的底层员工可能是公用的。
+>
+> 比如，合伙人1要辞退员工a，合伙人2要给员工a升职，升职后的话他再被辞退需要多个合伙人开会决议。两个合伙人分别把命令下发给了自己的管理人员。合伙人1命令下达后，管理人员a在辞退了员工后，他就知道这个员工被开除了。而合伙人2的管理人员2这时候在没得到消息之前，还认为员工a是在职的，他就欣然的接收了合伙人给他的升职a的命令。
+
+### 处理器优化和指令重排
+
+上面提到在在CPU和主存之间增加缓存，在多线程场景下会存在**缓存一致性问题**。除了这种情况，还有一种硬件问题也比较重要。那就是为了使处理器内部的运算单元能够尽量的被充分利用，处理器可能会对输入代码进行乱序执行处理。这就是**处理器优化**。
+
+除了现在很多流行的处理器会对代码进行优化乱序处理，很多编程语言的编译器也会有类似的优化，比如Java虚拟机的即时编译器（JIT）也会做**指令重排**。
+
+可想而知，如果任由处理器优化和编译器对指令重排的话，就可能导致各种各样的问题。
+
+> 关于员工组织调整的情况，如果允许人事部在接到多个命令后进行随意拆分乱序执行或者重排的话，那么对于这个员工以及这家公司的影响是非常大的。
+
+
+
+并发编程，为了保证数据的安全，需要满足以下三个特性：
+
+**原子性**是指在一个操作中就是cpu不可以在中途暂停然后再调度，既不被中断操作，要不执行完成，要不就不执行。
+
+**可见性**是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。
+
+**有序性**即程序执行的顺序按照代码的先后顺序执行。
+
+有没有发现，**缓存一致性问题**其实就是**可见性问题**。而**处理器优化**是可以导致**原子性问题**的。**指令重排**即会导致**有序性问题**。所以，后文将不再提起硬件层面的那些概念，而是直接使用大家熟悉的原子性、可见性和有序性。
+
+前面提到的，缓存一致性问题、处理器器优化的指令重排问题是硬件的不断升级导致的。那么，有没有什么机制可以很好的解决上面的这些问题呢？
+
+最简单直接的做法就是废除处理器和处理器的优化技术、废除CPU缓存，让CPU直接和主存交互。但是，这么做虽然可以保证多线程下的并发问题。但是，这就有点因噎废食了。
+
+所以，为了保证并发编程中可以满足原子性、可见性及有序性。有一个重要的概念，那就是——内存模型。
+
+**为了保证共享内存的正确性（可见性、有序性、原子性），内存模型定义了共享内存系统中多线程程序读写操作行为的规范。**通过这些规则来规范对内存的读写操作，从而保证指令执行的正确性。它与处理器有关、与缓存有关、与并发有关、与编译器也有关。他解决了CPU多级缓存、处理器优化、指令重排等导致的内存访问问题，保证了并发场景下的一致性、原子性和有序性。
+
+内存模型解决并发问题主要采用两种方式：**限制处理器优化**和**使用内存屏障**。
+
+Java内存模型规定了所有的变量都存储在主内存中，每条线程还有自己的工作内存，线程的工作内存中保存了该线程中是用到的变量的主内存副本拷贝，线程对变量的所有操作都必须在工作内存中进行，而不能直接读写主内存(每个线程都分配有单独的处理器缓存，用这些处理器缓存去缓存一些数据，就可以不用再次访问主内存去获取相应的数据，这样就可以提高效率)。不同的线程之间也无法直接访问对方工作内存中的变量，线程间变量的传递均需要自己的工作内存和主存之间进行数据同步进行。而JMM就作用于工作内存和主存之间数据同步过程。他规定了如何做数据同步以及什么时候做数据同步。对于共享普通变量来说，约定了变量在工作内存中发生变化了之后，必须要回写到工作内存(**迟早要回写但并非马上回写**)，*但对于volatile变量则要求工作内存中发生变化之后，必须马上回写到工作内存，而线程读取volatile变量的时候，必须马上到工作内存中去取最新值而不是读取本地工作内存的副本*，此规则保证了前面所说的“当线程A对变量X进行了修改后，在线程A后面执行的其他线程能看到变量X的变动”。
+
+
+
+
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/java_mm.png)
+
+这里面提到的主内存和工作内存，读者可以简单的类比成计算机内存模型中的主存和缓存的概念。特别需要注意的是，主内存和工作内存与JVM内存结构中的Java堆、栈、方法区等并不是同一个层次的内存划分，无法直接类比。《深入理解Java虚拟机》中认为，如果一定要勉强对应起来的话，从变量、主内存、工作内存的定义来看，主内存主要对应于Java堆中的对象实例数据部分。工作内存则对应于虚拟机栈中的部分区域。
+
+**所以，再来总结下，JMM是一种规范，目的是解决由于多线程通过共享内存进行通信时，存在的本地内存数据不一致、编译器会对代码指令重排序、处理器会对代码乱序执行等带来的问题。**
+
+
+
+
+
+## volatile
+
+
+
+作用：使变量在多个线程间可见（可见性），能够保证volatile变量的可见性，但不能保证volatile变量复合操作的原子性。
+
+`Java`语言规范中指出：为了获得最佳速度，允许线程保存共享成员变量的私有拷贝，而在这个过程中,变量的新值对其他线程是不可见的.而且只当线程进入或者离开同步代码块时才与共享成员变量
+的原始值对比。这样当多个线程同时与某个对象交互时，就必须要注意到要让线程及时的得到共享成员变量的变化。也就是说每个线程都有一个自己的本地内存空间，在线程执行时，先把变量从主内存读取到线程自己的本地内存空间，然后再对该变量进行操作，当对该变量操作完后，在某个时间再把变量刷新回主内存。 
+
+
+
+- 
+
+volatile如何实现内存可见性。深入来说：通过加入**内存屏障**和**禁止重排序优化**来实现的
+
+- 对volatile变量执行写操作时，会在写操作后加入一条store屏障指令
+- 对volatile变量执行读操作时，会在读操作前加入一条load屏障指令
+
+当volatile修饰一个变量i在线程1中从1发生改变成2时，这时线程1会做两件事：
+
+1. **更新主内存。**
+2. **向CPU总线发送一个修改信号。**
+
+
+
+**这时监听CPU总线的处理器会收到这个修改信号后，如果发现修改的数据自己缓存了，就把自己缓存的数据失效掉。这样其它线程访问到这段缓存时知道缓存数据失效了，需要从主内存中获取。这样所有线程中的共享变量i就达到了一致性。**
+
+![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/java_mm_1.jpg)
+
+**所以volatile也可以看作线程间通信的一种廉价方式。**
+
+
+
+
+### volatile关键字的非原子性
+
+所谓原子性，就是某系列的操作步骤要么全部执行，要么都不执行。
+
+比如，变量的自增操作 i++，分三个步骤： 
+
+- 从内存中读取出变量 i 的值
+
+- 将i的值加1
+
+- 将加1后的值写回内存
+
+这说明 i++ 并不是一个原子操作。因为，它分成了三步，有可能当某个线程执行到了第②时被中断了，那么就意味着只执行了其中的两个步骤，没有全部执行。
+
+volatile修饰的变量并不保证对它的操作（自增）具有原子性。（对于自增操作，可以使用JAVA的原子类AutoicInteger类保证原子自增）
+
+比如，假设i自增到5，线程A从主内存中读取i，值为5，将它存储到自己的线程空间中，执行加1操作，值为6。此时，CPU切换到线程B执行，从主从内存中读取变量i的值。由于线程A还没有来得及将加1后的结果写回到主内存，线程B就已经从主内存中读取了i，因此，线程B读到的变量i值还是5。
+
+相当于线程B读取的是已经过时的数据了，从而导致线程不安全性。这种情形在《Effective JAVA》中称之为“安全性失败”
+
+**综上，仅靠volatile不能保证线程的安全性。（原子性）**
+
+ 
+
+###  volatile禁止指令重排序
+
+代码书写的顺序与实际执行的顺序不同，指令重排序是编译器或处理器为了提高程序性能而做的优化
+
+1. **编译器优化的重排序（编译器优化）**
+2. **指令级并行重排序（处理器优化）**
+3. **内存系统的重排序（处理器优化）**
+
+volatile禁止指令重排序，典型的应用是单例模式中的双重检查机制。
+
+由于synchronized是一个重量级锁，会影响运行效率。双重检查机制中，先判断单例变量是否为null，再进入同步代码块。这样只在第一次获取单例变量时，会有效率影响。
+
+```java
+public class DoubleCheckSingleton {
+
+	private volatile static DoubleCheckSingleton singleton;
+	
+	private DoubleCheckSingleton() {}
+	
+	public static DoubleCheckSingleton getInstance() {
+		if(singleton == null) {
+			synchronized (singleton) {
+				if(singleton == null) {
+					singleton = new DoubleCheckSingleton();
+				}
+			}
+		}
+		return singleton;
+	}
+	
+}
+```
+
+单例变量需要用volatile修饰，否则，在new单例对象时会出现问题。使用new来创建一个对象可以分解为如下的3行伪代码：
+
+```java
+memory = allocate();   //1.分配对象的内存空间
+ctorInstance(memory);  //2.初始化对象
+instance = memory; 	   //3.设置instance指向刚分配的内存地址
+```
+
+上面3行伪代码中的2和3之间可能会发生重排序，排序后的执行顺序如下：
+
+```java
+memory = allocate();   //1.分配对象的内存空间
+instance = memory; 	   //3.设置instance指向刚分配的内存地址，此时对象还没有初始化，但instance == null 判断为false
+ctorInstance(memory);  //2.初始化对象
+```
+
+指令重排序后，在多线程情况下，可能会发生A线程正在new对象，执行了3，但还没有执行2。此时B线程进入方法获取单例对象，执行同步代码块外的非空判断，发现变量非空，但此时对象还未初始化，B线程获取到的是一个未被初始化的对象。使用volatile修饰后，禁止指令重排序。即，先初始化对象后，再设置instance指向刚分配的内存地址。这样就就不存在获取到未被初始化的对象。
+
+
+
+## synchronized
+
+**synchronized实现同步的基础是：Java中的每个对象都可作为锁。所以synchronized锁的都对象，只不过不同形式下锁的对象不一样。**
+
+- **对于普通同步方法，锁的是当前实例对象。**
+- **对于静态同步方法，锁的是当前类的Class对象。**
+- **对于同步方法块，锁是Synchronized括号里配置的对象。**
+
+`synchronized`为一段操作或内存进行加锁，它具有互斥性。当线程要操作被`synchronized`修饰的内存或操作时，必须首先获得锁才能进行后续操作；但是在同一时刻只能有一个线程获得相同的一把锁（对象监视器），所以它只允许一个线程进行操作。
+它用来修饰一个方法或者一个代码块的时候，能够保证在同一时刻最多只有一个线程执行该段代码。
+
+- 当两个并发线程访问同一个对象中的这个`synchronized(this)`同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。
+- 然而，当一个线程访问`object`的一个`synchronized(this)`同步代码块时，另一个线程仍然可以访问该`object`中的非`synchronized(this)`同步代码块。
+- 尤其关键的是，当一个线程访问`object`的一个`synchronized(this)`同步代码块时，其他线程对`object`中所有其它`synchronized(this)`同步代码块的访问将被阻塞。
+
+
+
+**在JVM规范中规定了synchronized是通过Monitor对象来实现方法和代码块的同步，但两者实现细节有点一不样。代码块同步是使用monitorenter和monitorexit指令，方法同步是使用另外一种方法实现，细节JVM规范并没有详细说明。但是，方法的同步同样可以使用这两指令来实现。**
+
+**monitorenter指令是编译后插入到同步代码块的开始位置，而monitorexit指令是插入到方法结束处和异常处。JVM保证了每个monitorenter都有对应的monitorexit。任何一个对象都有一个monitor与之关联，当且一个monitor被持有后，对象将处于锁定状态。线程执行到monitorenter指令时，将会尝试获取对象对应monitor的所有权，即尝试获得对象的锁。**
+
+
+
+### synchronized缺点
+
+#### 有性能损耗
+
+虽然在JDK 1.6中对synchronized做了很多优化，如如适应性自旋、锁消除、锁粗化、轻量级锁和偏向锁等，但是他毕竟还是一种锁。以上这几种优化，都是尽量想办法避免对Monitor进行加锁，但是，并不是所有情况都可以优化的，况且就算是经过优化，优化的过程也是有一定的耗时的。所以，无论是使用同步方法还是同步代码块，在同步操作之前还是要进行加锁，同步操作之后需要进行解锁，这个加锁、解锁的过程是要有性能损耗的。
+
+Monitor其实是一种同步工具，也可以说是一种同步机制，它通常被描述为一个对象，主要特点是：
+
+> 对象的所有方法都被“互斥”的执行。好比一个Monitor只有一个运行“许可”，任一个线程进入任何一个方法都需要获得这个“许可”，离开时把许可归还。
+>
+> 通常提供singal机制：允许正持有“许可”的线程暂时放弃“许可”，等待某个谓词成真（条件变量），而条件成立后，当前进程可以“通知”正在等待这个条件变量的线程，让他可以重新去获得运行许可。
+
+
+
+#### 产生阻塞
+
+基于Monitor对象，当多个线程同时访问一段同步代码时，首先会进入Entry Set，当有一个线程获取到对象的锁之后，才能进行The  Owner区域，其他线程还会继续在Entry Set等待。并且当某个线程调用了wait方法后，会释放锁并进入Wait Set等待。
+
+![img](http://47.103.216.138/wp-content/uploads/2019/08/15660298698995.jpg)
+
+所以，synchronize实现的锁本质上是一种阻塞锁，也就是说多个线程要排队访问同一个共享对象。
+
+
+
+## volatile与Synchronized的区别：
+
+
+
+- synchronized通过加锁的方式，使得其在需要原子性、可见性和有序性这三种特性的时候都可以作为其中一种解决方案，看起来是“万能”的。的确，大部分并发控制操作都能使用synchronized来完成。
+
+- volatile通过在volatile变量的操作前后插入内存屏障的方式，保证了变量在并发场景下的可见性和有序性。
+
+- volatile关键字是无法保证原子性的，而synchronized通过monitorenter和monitorexit两个指令，可以保证被synchronized修饰的代码在同一时间只能被一个线程访问，即可保证不会出现CPU时间片在多个线程间切换，即可保证原子性
+
+- volatile是变量修饰符，而synchronized则作用于一段代码或方法。
+- volatile只是在线程内存和“主”内存间同步某个变量的值；而synchronized通过锁定和解锁某个监视器同步所有变量的值。显然synchronized要比volatile消耗更多资源。 
+
+一句话，那什么时候才能用volatile关键字呢？（千万记住了，重要事情说三遍，感觉这句话过时了）
+
+> 如果写入变量值不依赖变量当前值，那么就可以用 volatile
+>
+> 如果写入变量值不依赖变量当前值，那么就可以用 volatile
+>
+> 如果写入变量值不依赖变量当前值，那么就可以用 volatile
+
+比如上面 count++ ，是获取-计算-写入三步操作，也就是依赖当前值的，所以不能靠volatile 解决问题。
+
+
+
+参考:  
+
+- [再有人问你Java内存模型是什么，就把这篇文章发给他](https://www.hollischuang.com/archives/2550)
+
 
-- 区别：
-    - `volatile`是变量修饰符，而`synchronized`则作用于一段代码或方法。
-    - `volatile`只是在线程内存和“主”内存间同步某个变量的值；而`synchronized`通过锁定和解锁某个监视器同步所有变量的值。显然`synchronized`要比`volatile`消耗更多资源。 
 
 ---
 
diff --git "a/JavaKnowledge/\346\225\260\346\215\256\345\212\240\345\257\206\345\217\212\350\247\243\345\257\206.md" "b/JavaKnowledge/\346\225\260\346\215\256\345\212\240\345\257\206\345\217\212\350\247\243\345\257\206.md"
index d3832e6b..fa29a7b1 100644
--- "a/JavaKnowledge/\346\225\260\346\215\256\345\212\240\345\257\206\345\217\212\350\247\243\345\257\206.md"
+++ "b/JavaKnowledge/\346\225\260\346\215\256\345\212\240\345\257\206\345\217\212\350\247\243\345\257\206.md"
@@ -21,19 +21,17 @@
 
 - DES
 
-`DES`全称为`Data Encryption Standard`,即数据加密标准，是一种使用密钥加密的块算法，
-1976年被美国联邦政府的国家标准局确定为联邦资料处理标准(`FIPS`)，随后在国际上广泛流传开来。
-
-`DES`算法的入口参数有三个:`Key`、`Data`、`Mode`。其中`Key`为8个字节共64位,是`DES`算法的工作密钥;`Data`也为8个字节64位,
-是要被加密或被解密的数据;`Mode`为`DES`的工作方式,有两种:加密或解密。 
-`DES`算法把64位的明文输入块变为64位的密文输出块,它所使用的密钥也是64位。 
-
+    DES`全称为`Data Encryption Standard`,即数据加密标准，是一种使用密钥加密的块算法，
+    1976年被美国联邦政府的国家标准局确定为联邦资料处理标准(`FIPS`)，随后在国际上广泛流传开来。`
 
+    `DES`算法的入口参数有三个:`Key`、`Data`、`Mode`。其中`Key`为8个字节共64位,是`DES`算法的工作密钥;`Data`也为8个字节64位,
+    是要被加密或被解密的数据;`Mode`为`DES`的工作方式,有两种:加密或解密。 
+    `DES`算法把64位的明文输入块变为64位的密文输出块,它所使用的密钥也是64位。 
 
 - AES
-`AES`全程为`Advanced Encryption Standard`,即高级加密标准，在密码学中又称`Rijndael`加密法，
-是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的`DES`，已经被多方分析且广为全世界所使用。
-`AES`加密数据块分组长度必须为128比特，密钥长度可以是128比特、192比特、256比特中的任意一个（如果数据块及密钥长度不足时，会补齐）
+    `AES`全程为`Advanced Encryption Standard`,即高级加密标准，在密码学中又称`Rijndael`加密法，
+    是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的`DES`，已经被多方分析且广为全世界所使用。
+    `AES`加密数据块分组长度必须为128比特，密钥长度可以是128比特、192比特、256比特中的任意一个（如果数据块及密钥长度不足时，会补齐）
 
 
 

From afab78854925643c9508f8d2da2bcd816f98b1d3 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Fri, 10 Jul 2020 15:07:22 +0800
Subject: [PATCH 027/213] update notes

---
 ...37\347\220\206\345\210\206\346\236\220.md" |  32 +++-
 ...12\346\234\211\345\272\217\346\200\247.md" | 171 ++++++++++++++++++
 ...14Synchronized\345\214\272\345\210\253.md" |  17 +-
 ...12\346\234\211\345\272\217\346\200\247.md" |  74 --------
 4 files changed, 205 insertions(+), 89 deletions(-)
 create mode 100644 "JavaKnowledge/Java\345\271\266\345\217\221\347\274\226\347\250\213\344\271\213\345\216\237\345\255\220\346\200\247\343\200\201\345\217\257\350\247\201\346\200\247\344\273\245\345\217\212\346\234\211\345\272\217\346\200\247.md"
 delete mode 100644 "JavaKnowledge/\345\216\237\345\255\220\346\200\247\343\200\201\345\217\257\350\247\201\346\200\247\344\273\245\345\217\212\346\234\211\345\272\217\346\200\247.md"

diff --git "a/JavaKnowledge/HashMap\345\256\236\347\216\260\345\216\237\347\220\206\345\210\206\346\236\220.md" "b/JavaKnowledge/HashMap\345\256\236\347\216\260\345\216\237\347\220\206\345\210\206\346\236\220.md"
index 63b0d41f..5ebc846c 100644
--- "a/JavaKnowledge/HashMap\345\256\236\347\216\260\345\216\237\347\220\206\345\210\206\346\236\220.md"
+++ "b/JavaKnowledge/HashMap\345\256\236\347\216\260\345\216\237\347\220\206\345\210\206\346\236\220.md"
@@ -292,6 +292,7 @@ public V get(Object key) {
         // 使用红黑树树而不链表的容器计数阈值
         static final int TREEIFY_THRESHOLD = 8;
         // 用于在执行过程中取消使用红黑树（拆分）箱调整大小操作的箱计数阈值，
+        // 为啥这里转成红黑树是8，而从红黑树转成链表是6？ 在hash函数设计合理的情况下，发生hash碰撞8次的几率为百万分之6，概率说话。。因为8够用了，至于为什么转回来是6，因为如果hash碰撞次数在8附近徘徊，会一直发生链表和红黑树的转化，为了预防这种情况的发生。
         static final int UNTREEIFY_THRESHOLD = 6;
         // 哈希桶，存储数据的数组
         transient Node<K,V>[] table;
@@ -337,6 +338,17 @@ static final int hash(Object key) {
 }
 ```
 
+hash函数是先拿到通过key 的hashcode，是32位的int值，然后让hashcode的高16位和低16位进行异或操作。为什么要这样设计呢？ 主要有两个原因 ：  
+
+1. 一定要尽可能降低hash碰撞，越分散越好。
+2. 算法一定要尽可能高效，因为这是高频操作，因此采用位运算。
+
+因为hashcode是32位的int值int值范围为**-2147483648~2147483647**，前后加起来大概40亿的映射空间。只要哈希函数映射得比较均匀松散，一般应用是很难出现碰撞的。但问题是一个40亿长度的数组，内存是放不下的。你想，如果HashMap数组的初始大小才16，用之前需要对数组的长度取模运算，得到的余数才能用来访问数组下标。源码中模运算就是把散列值和数组长度-1做一个"与"操作，位运算比%运算要快。
+
+
+
+
+
 对于任意给定的对象，只要它的hashCode()返回值相同，那么程序调用所计算得到的Hash码值总是相同的。我们首先想到的就是把hash值对数组长度取模运算，这样一来，元素的分布相对来说是比较均匀的。但是，模运算的消耗还是比较大的，在HashMap中是这样做的：调用 (table.length  -1) & hash来计算该对象应该保存在table数组的哪个索引处。这个方法非常巧妙，它通过 (table.length  -1) & hash来得到该对象的保存位，而HashMap底层数组的长度总是2的n次方，当length总是2的n次方时， (table.length  -1) & hash运算等价于对length取模，也就是h%length，但是&比%具有更高的效率。
 
 当length总是2的倍数时，h & (length-1) 将是一个非常巧妙的设计：
@@ -709,8 +721,9 @@ final Node<K,V> getNode(int hash, Object key) {
 1. JDK8为红黑树 + 链表 + 数组的形式，当桶内元素大于8时，便会树化。
 2. hash值的计算方式不同 (jdk 8 简化)。
 3. JDK7中table在创建hashmap时分配空间，而8中在put的时候分配。
-4. 在发生冲突，插入链中时，7 是头插法，8 是尾插法
+4. 链表的插入方式从头插法改成了尾插法，简单说就是插入时，如果数组位置上已经有元素，1.7将新元素放到数组中，原始节点作为新节点的后继节点，1.8遍历链表，将元素放置到链表的最后；因为头插法会使链表发生反转，多线程环境下会产生环；
 5. 在resize操作中，7 需要重新进行index的计算，而8不需要，通过判断相应的位是0还是1，要么依旧是原index，要么是oldCap + 原 index。
+6. 在插入时，1.7先判断是否需要扩容，再插入，1.8先进行插入，插入完成再判断是否需要扩容；
 
 
 
@@ -721,8 +734,6 @@ final Node<K,V> getNode(int hash, Object key) {
 1. 为什么capcity是2的幂？
      因为算index时用的是(n-1) & hash，这样就能保证n-1是全为1的二进制数，如果不全为1的话，存在某一位为 0，那么0，1与0与的结果都是0，这样便有可能将两个hash不同的值最终装入同一个桶中，造成冲突。所以必须是2的幂。这是为了服务key映射到index的Hash算法的，公式index=hashcode(key)&(length-1)，初始长度(16-1)，二进制为1111&hashcode结果为hashcode最后四位，能最大程度保持平均，二的幂数保证二进制为1，保持hashcode最后四位。这种算法在保持分布均匀之外，效率也非常高。
 
-
-
 2. 为什么需要使用加载因子，为什么需要扩容呢？
 
     因为如果填充比很大，说明利用的空间很多，如果一直不进行扩容的话，链表就会越来越长，这样查找的效率很低，因为链表的长度很大（当然最新版本使用了红黑树后会改进很多），扩容之后，将原来链表数组的每一个链表分成奇偶两个子链表分别挂在新链表数组的散列位置，这样就减少了每个链表的长度，增加查找效率。HashMap 本来是以空间换时间，所以填充比没必要太大。但是填充比太小又会导致空间浪费。如果关注内存，填充比可以稍大，如果主要关注查找性能，填充比可以稍小。
@@ -730,11 +741,8 @@ final Node<K,V> getNode(int hash, Object key) {
 3. 为什么 HashMap 是线程不安全的，实际会如何体现？
 
     - 如果多个线程同时使用put方法添加元素，假设正好存在两个put的key发生了碰撞 (hash值一样)，那么根据HashMap的实现，这两个key会添加到数组的同一个位置，这样最终就会发生其中一个线程的put的数据被覆盖。
-
-    - 如果多个线程同时检测到元素个数超过数组大小 * loadFactor。这样会发生多个线程同时对hash数组进行扩容，都在重新计算元素位置以及复制数据，但是最终只有一个线程扩容后的数组会赋给table，也就是说其他线程的都会丢失，并且各自线程put的数据也丢失。且会引起死循环的错误。
-
-        
-
+- 如果多个线程同时检测到元素个数超过数组大小 * loadFactor。这样会发生多个线程同时对hash数组进行扩容，都在重新计算元素位置以及复制数据，但是最终只有一个线程扩容后的数组会赋给table，也就是说其他线程的都会丢失，并且各自线程put的数据也丢失。且会引起死循环的错误。
+    
 4. 与HashTable的区别
 
     Hashtable是遗留类，很多映射的常用功能与HashMap类似，不同的是它承自Dictionary类，并且是线程安全的，任一时间只有一个线程能写Hashtable，它的并发性不如ConcurrentHashMap，因为ConcurrentHashMap引入了分段锁。Hashtable不建议在新代码中使用，不需要线程安全的场合可以用HashMap替换，需要线程安全的场合可以用ConcurrentHashMap替换。
@@ -745,8 +753,16 @@ final Node<K,V> getNode(int hash, Object key) {
     - HashTable取哈希桶下标是直接用模运算%.（因为其默认容量也不是2的n次方。所以也无法用位运算替代模运算）
     - 扩容时，新容量是原来的2倍+1。int newCapacity = (oldCapacity << 1) + 1;
     - Hashtable是Dictionary的子类同时也实现了Map接口，HashMap是Map接口的一个实现类
+    
+5. 扩容的时候为什么1.8 不用重新hash就可以直接定位原节点在新数据的位置呢?
+
+    这是由于扩容是扩大为原数组大小的2倍，用于计算数组位置的掩码仅仅只是高位多了一个1，举个例子：
 
+      扩容前长度为16，用于计算 (n-1) & hash 的二进制n - 1为0000 1111， 
 
+       扩容后为32后的二进制就高位多了1，============>为0001 1111。因为是& 运算，1和任何数 & 都是它本身，那就分二种情况，如下图：原数据hashcode高位第4位为0和高位为1的情况；第四位高位为0，重新hash数值不变，第四位为1，重新hash数值比原来大16（旧数组的容量）。
+
+    
 
 
 参考:  
diff --git "a/JavaKnowledge/Java\345\271\266\345\217\221\347\274\226\347\250\213\344\271\213\345\216\237\345\255\220\346\200\247\343\200\201\345\217\257\350\247\201\346\200\247\344\273\245\345\217\212\346\234\211\345\272\217\346\200\247.md" "b/JavaKnowledge/Java\345\271\266\345\217\221\347\274\226\347\250\213\344\271\213\345\216\237\345\255\220\346\200\247\343\200\201\345\217\257\350\247\201\346\200\247\344\273\245\345\217\212\346\234\211\345\272\217\346\200\247.md"
new file mode 100644
index 00000000..1f3a021f
--- /dev/null
+++ "b/JavaKnowledge/Java\345\271\266\345\217\221\347\274\226\347\250\213\344\271\213\345\216\237\345\255\220\346\200\247\343\200\201\345\217\257\350\247\201\346\200\247\344\273\245\345\217\212\346\234\211\345\272\217\346\200\247.md"
@@ -0,0 +1,171 @@
+# Java并发编程之原子性、可见性以及有序性
+
+
+
+- 缓存导致的可见性问题
+- 线程切换带来的原子性问题
+- 编译优化带来的有序性问题
+
+
+
+## 原子性(Atomicity）
+
+众所周知，原子是构成物质的基本单位，所以原子代表着不可分。
+即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。
+最简单的一个例子就是银行转账问题，赋值或者`return`。比如`a = 1;`和 `return a;`这样的操作都具有原子性
+原子性不论是多核还是单核，具有原子性的量，同一时刻只能有一个线程来对它进行操作！
+加锁可以保证复合语句的原子性，Java中提供了两个高级指令 `monitorenter`和 `monitorexit`，也就是对应的synchronized同步锁来保证原子性。
+
+非原子性操作
+类似`a += b`这样的操作不具有原子性，在某些`JVM`中`a += b`可能要经过这样三个步骤: 
+
+- 取出`a`和`b`        
+- 计算`a+b`        
+- 将计算结果写入内存       
+    如果有两个线程`t1`,`t2`在进行这样的操作。`t1`在第二步做完之后还没来得及把数据写回内存就被线程调度器中断了，于是`t2`开始执行，`t2`执行完毕后`t1`又把没有完成的第三步做完。这个时候就出现了错误，
+    相当于`t2`的计算结果被无视掉了。所以上面的买碘片例子在同步`add`方法之前，实际结果总是小于预期结果的，因为很多操作都被无视掉了。                       
+    类似的，像`a++`这样的操作也都不具有原子性。所以在多线程的环境下一定要记得进行同步操作。   
+
+## 可见性(Visibility)
+
+可见性指的是当一个线程修改了共享变量后，其他线程能够立即得知这个修改。
+
+在多核处理器中，如果多个线程对一个变量进行操作，但是这多个线程有可能被分配到多个处理器中运行，那么编译器会对代码进行优化，当线程要处理该变量时，多个处理器会将变量从主内存复制一份分别存储在自己的片上存储器中，等到进行完操作后，再赋值回主存。(这样做的好处是提高了运行的速度，因为在处理过程中多个处理器减少了同主内存通信的次数)；同样在单核处理器中这样由于备份造成的问题同样存在！这样的优化带来的问题之一是变量可见性——如果线程`t1`与线程`t2`分别被安排在了不同的处理器上面，那么`t1`与`t2`对于变量`A`的修改时相互不可见，如果`t1`给`A`赋值，然后`t2`又赋新值，那么`t2`的操作就将`t1`的操作覆盖掉了，这样会产生不可预料的结果。所以，即使有些操作时原子性的，但是如果不具有可见性，那么多个处理器中备份的存在就会使原子性失去意义。
+
+volatile、synchronized、final都可以解决可见性问题。
+
+## 有序性(Ordering)
+
+有序性：即程序执行的顺序按照代码的先后顺序执行。
+
+有序性简单来说就是程序代码执行的顺序是否按照我们编写代码的顺序执行，一般来说，为了提高性能，编译器和处理器会对指令做重排序，重排序分3类
+
+- 编译器优化重排序，在不改变单线程程序语义的前提下，改变代码的执行顺序
+- 指令集并行的重排序，对于不存在数据依赖的指令，处理器可以改变语句对应指令的执行顺序来充分利用CPU资源
+- 内存系统的重排序，也就是前面说的CPU的内存乱序访问问题
+
+也就是说，我们编写的源代码到最终执行的指令，会经过三种重排序。 
+
+比如编写时顺序如下的程序：
+
+```java
+1. a = 5;
+2. b = 20;
+3. c = a + b;
+```
+
+编译器优化后执行的顺序可能变成: 
+
+```java
+1. b = 20;
+2. a = 5; 
+3. c = a + b;
+```
+
+在这个例子中，编译器调整了语句的顺序，但是不影响程序的最终结果
+
+在单例模式的实现上有一种双重检验锁定的方式（Double-checked Locking）： 
+
+```java
+public class Singleton{
+    private static Singleton instance;
+    public static Singleton getInstance(){
+        if (instance == null){
+            synchronized(Singleton.class){
+                if(instance == null) {
+                    instance = new Singleton();
+                }
+            }
+        }
+	    return instance;
+    }
+}
+```
+
+我们先看 instance=newSingleton() 的未被编译器优化的操作
+
+- 指令 1：分配一块内存 M；
+- 指令 2：在内存 M 上初始化 Singleton 对象；
+- 指令 3：然后 M 的地址赋值给 instance 变量。
+
+编译器优化后的操作指令
+
+- 指令 1：分配一块内存 M；
+- 指令 2：将 M 的地址赋值给 instance 变量；
+- 指令 3：然后在内存 M 上初始化 Singleton 对象。
+
+现在有A，B两个线程，我们假设线程A先执行getInstance()方法，当执行编译器优化后的操作指令2时（此时候未完成对象的初始化），这时候发生了线程切换，那么线程B进入，刚好执行到第一次判断instance==nul会发现 instance不等于null了，所以直接返回instance，而此时的 instance 是没有初始化过的。
+
+
+
+Java语言提供了volatile和synchronized两个关键字来保证线程之间操作的有序性，volatile关键字本身就包含了禁止指令重排序的语义，而synchronized则是由“一个变量在同一时刻只允许一条线程对其进行lock操作”这条规则来获得的，这个规则决定了持有同一个锁的两个同步块只能串行地进入。
+
+## **先行发生原则：**
+
+如果Java内存模型中所有的有序性都只靠volatile和synchronized来完成，那么有一些操作将会变得很啰嗦，但是我们在编写Java并发代码的时候并没有感觉到这一点，这是因为Java语言中有一个“先行发生”(Happen-Before)的原则。这个原则非常重要，它是判断数据是否存在竞争，线程是否安全的主要依赖。
+
+先行发生原则是指Java内存模型中定义的两项操作之间的依序关系，如果说操作A先行发生于操作B，其实就是说发生操作B之前，操作A产生的影响能被操作B观察到，“影响”包含了修改了内存中共享变量的值、发送了消息、调用了方法等。下面是Java内存模型下一些”天然的“先行发生关系，这些先行发生关系无须任何同步器协助就已经存在，可以在编码中直接使用。如果两个操作之间的关系不在此列，并且无法从下列规则推导出来的话，它们就没有顺序性保障，虚拟机可以对它们进行随意地重排序。
+
+- 程序次序规则(Pragram Order Rule)：在一个线程内，按照程序代码顺序，书写在前面的操作先行发生于书写在后面的操作。准确地说应该是控制流顺序而不是程序代码顺序，因为要考虑分支、循环结构。
+
+- 管程锁定规则(Monitor Lock Rule)：一个unlock操作先行发生于后面对同一个锁的lock操作。这里必须强调的是同一个锁，而”后面“是指时间上的先后顺序。
+
+- volatile变量规则(Volatile Variable Rule)：对一个volatile变量的写操作先行发生于后面对这个变量的读取操作，这里的”后面“同样指时间上的先后顺序。
+
+- 线程启动规则(Thread Start Rule)：Thread对象的start()方法先行发生于此线程的每一个动作。
+
+- 线程终于规则(Thread Termination Rule)：线程中的所有操作都先行发生于对此线程的终止检测，我们可以通过Thread.join()方法结束，Thread.isAlive()的返回值等作段检测到线程已经终止执行。
+
+- 线程中断规则(Thread Interruption Rule)：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生，可以通过Thread.interrupted()方法检测是否有中断发生。
+
+- 对象终结规则(Finalizer Rule)：一个对象初始化完成(构造方法执行完成)先行发生于它的finalize()方法的开始。
+
+- 传递性(Transitivity)：如果操作A先行发生于操作B，操作B先行发生于操作C，那就可以得出操作A先行发生于操作C的结论。
+
+一个操作”时间上的先发生“不代表这个操作会是”先行发生“，那如果一个操作”先行发生“是否就能推导出这个操作必定是”时间上的先发生“呢？也是不成立的，一个典型的例子就是指令重排序。所以时间上的先后顺序与先生发生原则之间基本没有什么关系，所以衡量并发安全问题一切必须以先行发生原则为准。
+
+```java
+int i = 0;              
+boolean flag = false;
+i = 1;                //语句1  
+flag = true;          //语句2
+```
+上面代码定义了一个`int`型变量，定义了一个`boolean`类型变量，然后分别对两个变量进行赋值操作。从代码顺序上看，语句1是在语句2前面的，那么`JVM`在真正执行这段代码的时候会保证语句1一定会在语句2前面执行吗？
+不一定，为什么呢？这里可能会发生指令重排序`(Instruction Reorder)`。                      
+下面解释一下什么是指令重排序，一般来说，处理器为了提高程序运行效率，可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。比如上面的代码中，语句1和语句2谁先执行对最终的程序结果并没有影响，那么就有可能在执行过程中，语句2先执行而语句1后执行。但是要注意，虽然处理器会对指令进行重排序，但是它会保证程序最终结果会和代码顺序执行结果相同，那么它靠什么保证的呢？             
+再看下面一个例子:                
+
+```java
+int a = 10;    //语句1
+int r = 2;    //语句2
+a = a + 3;    //语句3
+r = a*a;     //语句4
+```
+这段代码有4个语句，那么可能的一个执行顺序是:     
+语句2->语句1->语句3->语句4
+那么可能不可能是这个执行顺序呢？语句2->语句1->语句4->语句3，这是不可能的，因为处理器在进行重排序时是会考虑指令之间的数据依赖性，
+如果一个指令Instruction 2必须用到Instruction 1的结果，那么处理器会保证Instruction 1会在Instruction 2之前执行。
+
+虽然重排序不会影响单个线程内程序执行的结果，但是多线程呢？下面看一个例子：
+```java
+//线程1:
+context = loadContext();   //语句1
+inited = true;             //语句2
+ 
+//线程2:
+while(!inited ){
+  sleep()
+}
+doSomethingwithconfig(context);
+```
+上面代码中，由于语句1和语句2没有数据依赖性，因此可能会被重排序。假如发生了重排序，在线程1执行过程中先执行语句2，而此时线程2会以为初始化工作已经完成，
+那么就会跳出while循环，去执行doSomethingwithconfig(context)方法，而此时context并没有被初始化，就会导致程序出错。
+从上面可以看出，指令重排序不会影响单个线程的执行，但是会影响到线程并发执行的正确性。也就是说，要想并发程序正确地执行，必须要保证原子性、可见性以及有序性。只要有一个没有被保证，就有可能会导致程序运行不正确。
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/JavaKnowledge/volatile\345\222\214Synchronized\345\214\272\345\210\253.md" "b/JavaKnowledge/volatile\345\222\214Synchronized\345\214\272\345\210\253.md"
index 5b1f37ab..d447a6d3 100644
--- "a/JavaKnowledge/volatile\345\222\214Synchronized\345\214\272\345\210\253.md"
+++ "b/JavaKnowledge/volatile\345\222\214Synchronized\345\214\272\345\210\253.md"
@@ -1,10 +1,8 @@
 # volatile和Synchronized
 
-## Java内存模型(Java Memory Model ,JMM)
-
-**Java内存模型**(java Memory Model)描述了Java程序中各种变量(**线程共享变量**)的访问规则，以及在JVM中将变量**存储到内存**和从**内存中读取出变量**这样的底层细节。
-
+## 内存模型
 
+内存模型：英文名 Memory Model，它是一个老古董了。它是与计算机硬件有关的一个概念。那么，我先介绍下它和硬件到底有啥关系。
 
 计算机在执行程序的时候，每条指令都是在CPU中执行的，而执行的时候，又免不了要和数据打交道。而计算机上面的数据，是存放在主存当中的，也就是计算机的物理内存。但是随着CPU技术的发展，CPU的执行速度越来越快。而由于内存的技术并没有太大的变化，所以从内存中读取和写入数据的过程和CPU的执行速度比起来差距就会越来越大,这就导致CPU每次操作内存都要耗费很多等待时间。可是，不能因为内存的读写速度慢，就不发展CPU技术了，所以人们想出来了一个好的办法，就是在CPU和内存之间增加高速缓存。缓存的概念大家都知道，就是保存一份数据拷贝。他的特点是速度快，内存小，并且昂贵。
 
@@ -60,7 +58,7 @@
 
 > 关于员工组织调整的情况，如果允许人事部在接到多个命令后进行随意拆分乱序执行或者重排的话，那么对于这个员工以及这家公司的影响是非常大的。
 
-
+### 并发编程问题
 
 并发编程，为了保证数据的安全，需要满足以下三个特性：
 
@@ -82,6 +80,10 @@
 
 内存模型解决并发问题主要采用两种方式：**限制处理器优化**和**使用内存屏障**。
 
+## Java内存模型
+
+**Java内存模型**(java Memory Model，JMM)描述了Java程序中各种变量(**线程共享变量**)的访问规则，以及在JVM中将变量**存储到内存**和从**内存中读取出变量**这样的底层细节。
+
 Java内存模型规定了所有的变量都存储在主内存中，每条线程还有自己的工作内存，线程的工作内存中保存了该线程中是用到的变量的主内存副本拷贝，线程对变量的所有操作都必须在工作内存中进行，而不能直接读写主内存(每个线程都分配有单独的处理器缓存，用这些处理器缓存去缓存一些数据，就可以不用再次访问主内存去获取相应的数据，这样就可以提高效率)。不同的线程之间也无法直接访问对方工作内存中的变量，线程间变量的传递均需要自己的工作内存和主存之间进行数据同步进行。而JMM就作用于工作内存和主存之间数据同步过程。他规定了如何做数据同步以及什么时候做数据同步。对于共享普通变量来说，约定了变量在工作内存中发生变化了之后，必须要回写到工作内存(**迟早要回写但并非马上回写**)，*但对于volatile变量则要求工作内存中发生变化之后，必须马上回写到工作内存，而线程读取volatile变量的时候，必须马上到工作内存中去取最新值而不是读取本地工作内存的副本*，此规则保证了前面所说的“当线程A对变量X进行了修改后，在线程A后面执行的其他线程能看到变量X的变动”。
 
 
@@ -96,8 +98,6 @@ Java内存模型规定了所有的变量都存储在主内存中，每条线程
 
 
 
-
-
 ## volatile
 
 
@@ -281,9 +281,12 @@ Monitor其实是一种同步工具，也可以说是一种同步机制，它通
 
 
 
+
+
 参考:  
 
 - [再有人问你Java内存模型是什么，就把这篇文章发给他](https://www.hollischuang.com/archives/2550)
+- [原子性、可见性以及有序性](https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E5%8E%9F%E5%AD%90%E6%80%A7%E3%80%81%E5%8F%AF%E8%A7%81%E6%80%A7%E4%BB%A5%E5%8F%8A%E6%9C%89%E5%BA%8F%E6%80%A7.md)
 
 
 
diff --git "a/JavaKnowledge/\345\216\237\345\255\220\346\200\247\343\200\201\345\217\257\350\247\201\346\200\247\344\273\245\345\217\212\346\234\211\345\272\217\346\200\247.md" "b/JavaKnowledge/\345\216\237\345\255\220\346\200\247\343\200\201\345\217\257\350\247\201\346\200\247\344\273\245\345\217\212\346\234\211\345\272\217\346\200\247.md"
deleted file mode 100644
index 52e55a8e..00000000
--- "a/JavaKnowledge/\345\216\237\345\255\220\346\200\247\343\200\201\345\217\257\350\247\201\346\200\247\344\273\245\345\217\212\346\234\211\345\272\217\346\200\247.md"
+++ /dev/null
@@ -1,74 +0,0 @@
-原子性、可见性以及有序性
-===
-
-- 原子性:
-    众所周知，原子是构成物质的基本单位，所以原子代表着不可分。
-	即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。
-    最简单的一个例子就是银行转账问题，赋值或者`return`。比如`a = 1;`和 `return a;`这样的操作都具有原子性
-    原子性不论是多核还是单核，具有原子性的量，同一时刻只能有一个线程来对它进行操作！
-	加锁可以保证复合语句的原子性，`sychronized`可以保证多条语句在`synchronized`块中语意上是原子的。
-
-- 可见性:     
-    在多核处理器中，如果多个线程对一个变量进行操作，但是这多个线程有可能被分配到多个处理器中运行，那么编译器会对代码进行优化，当线程要处理该变量时，
-	多个处理器会将变量从主内存复制一份分别存储在自己的片上存储器中，等到进行完操作后，再赋值回主存。
-	(这样做的好处是提高了运行的速度，因为在处理过程中多个处理器减少了同主内存通信的次数)；同样在单核处理器中这样由于备份造成的问题同样存在！
-    这样的优化带来的问题之一是变量可见性——如果线程`t1`与线程`t2`分别被安排在了不同的处理器上面，那么`t1`与`t2`对于变量`A`的修改时相互不可见，如果`t1`给`A`赋值，然后`t2`又赋新值，那么`t2`的操作就将`t1`的操作覆盖掉了，
-	这样会产生不可预料的结果。所以，即使有些操作时原子性的，但是如果不具有可见性，那么多个处理器中备份的存在就会使原子性失去意义。
-	
-- 非原子性操作
-    类似`a += b`这样的操作不具有原子性，在某些`JVM`中`a += b`可能要经过这样三个步骤: 
-
-    - 取出`a`和`b`        
-    - 计算`a+b`        
-	- 将计算结果写入内存       
-    如果有两个线程`t1`,`t2`在进行这样的操作。`t1`在第二步做完之后还没来得及把数据写回内存就被线程调度器中断了，于是`t2`开始执行，`t2`执行完毕后`t1`又把没有完成的第三步做完。这个时候就出现了错误，
-	相当于`t2`的计算结果被无视掉了。所以上面的买碘片例子在同步`add`方法之前，实际结果总是小于预期结果的，因为很多操作都被无视掉了。                       
-    类似的，像`a++`这样的操作也都不具有原子性。所以在多线程的环境下一定要记得进行同步操作。   
-	
--  有序性
-    有序性：即程序执行的顺序按照代码的先后顺序执行。
-    ```java
-	int i = 0;              
-	boolean flag = false;
-	i = 1;                //语句1  
-	flag = true;          //语句2
-    ```	
-	上面代码定义了一个`int`型变量，定义了一个`boolean`类型变量，然后分别对两个变量进行赋值操作。从代码顺序上看，语句1是在语句2前面的，那么`JVM`在真正执行这段代码的时候会保证语句1一定会在语句2前面执行吗？
-	不一定，为什么呢？这里可能会发生指令重排序`(Instruction Reorder)`。                      
-　　下面解释一下什么是指令重排序，一般来说，处理器为了提高程序运行效率，可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。
-　　比如上面的代码中，语句1和语句2谁先执行对最终的程序结果并没有影响，那么就有可能在执行过程中，语句2先执行而语句1后执行。                      
-　　但是要注意，虽然处理器会对指令进行重排序，但是它会保证程序最终结果会和代码顺序执行结果相同，那么它靠什么保证的呢？             
-    再看下面一个例子:                
-	```java
-	int a = 10;    //语句1
-	int r = 2;    //语句2
-	a = a + 3;    //语句3
-	r = a*a;     //语句4
-	```
-	这段代码有4个语句，那么可能的一个执行顺序是:     
-	语句2->语句1->语句3->语句4
-	那么可能不可能是这个执行顺序呢？语句2->语句1->语句4->语句3，这是不可能的，因为处理器在进行重排序时是会考虑指令之间的数据依赖性，
-	如果一个指令`Instruction 2`必须用到`Instruction 1`的结果，那么处理器会保证`Instruction 1`会在`Instruction 2`之前执行。
-	
-	虽然重排序不会影响单个线程内程序执行的结果，但是多线程呢？下面看一个例子：
-	```java
-	//线程1:
-	context = loadContext();   //语句1
-	inited = true;             //语句2
-	 
-	//线程2:
-	while(!inited ){
-	  sleep()
-	}
-	doSomethingwithconfig(context);
-	```
-    上面代码中，由于语句1和语句2没有数据依赖性，因此可能会被重排序。假如发生了重排序，在线程1执行过程中先执行语句2，而此时线程2会以为初始化工作已经完成，
-	那么就会跳出`while`循环，去执行`doSomethingwithconfig(context)`方法，而此时`context`并没有被初始化，就会导致程序出错。
-    从上面可以看出，指令重排序不会影响单个线程的执行，但是会影响到线程并发执行的正确性。
-　　也就是说，要想并发程序正确地执行，必须要保证原子性、可见性以及有序性。只要有一个没有被保证，就有可能会导致程序运行不正确。
-
----
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
-
-	

From 07917cf6a0783cc7f8c3d290868dc8d9e1142c31 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Tue, 14 Jul 2020 17:47:05 +0800
Subject: [PATCH 028/213] add images

---
 ...14Synchronized\345\214\272\345\210\253.md" |  4 +-
 ...01\350\231\232\345\274\225\347\224\250.md" | 91 ++++++++++++++-----
 README.md                                     |  4 +-
 3 files changed, 70 insertions(+), 29 deletions(-)

diff --git "a/JavaKnowledge/volatile\345\222\214Synchronized\345\214\272\345\210\253.md" "b/JavaKnowledge/volatile\345\222\214Synchronized\345\214\272\345\210\253.md"
index d447a6d3..9dd6ce0a 100644
--- "a/JavaKnowledge/volatile\345\222\214Synchronized\345\214\272\345\210\253.md"
+++ "b/JavaKnowledge/volatile\345\222\214Synchronized\345\214\272\345\210\253.md"
@@ -109,9 +109,7 @@ Java内存模型规定了所有的变量都存储在主内存中，每条线程
 
 
 
-- 
-
-volatile如何实现内存可见性。深入来说：通过加入**内存屏障**和**禁止重排序优化**来实现的
+- volatile如何实现内存可见性。深入来说：通过加入**内存屏障**和**禁止重排序优化**来实现的
 
 - 对volatile变量执行写操作时，会在写操作后加入一条store屏障指令
 - 对volatile变量执行读操作时，会在读操作前加入一条load屏障指令
diff --git "a/JavaKnowledge/\345\274\272\345\274\225\347\224\250\343\200\201\350\275\257\345\274\225\347\224\250\343\200\201\345\274\261\345\274\225\347\224\250\343\200\201\350\231\232\345\274\225\347\224\250.md" "b/JavaKnowledge/\345\274\272\345\274\225\347\224\250\343\200\201\350\275\257\345\274\225\347\224\250\343\200\201\345\274\261\345\274\225\347\224\250\343\200\201\350\231\232\345\274\225\347\224\250.md"
index 9f7da395..1f4346c1 100644
--- "a/JavaKnowledge/\345\274\272\345\274\225\347\224\250\343\200\201\350\275\257\345\274\225\347\224\250\343\200\201\345\274\261\345\274\225\347\224\250\343\200\201\350\231\232\345\274\225\347\224\250.md"
+++ "b/JavaKnowledge/\345\274\272\345\274\225\347\224\250\343\200\201\350\275\257\345\274\225\347\224\250\343\200\201\345\274\261\345\274\225\347\224\250\343\200\201\350\231\232\345\274\225\347\224\250.md"
@@ -1,37 +1,80 @@
 强引用、软引用、弱引用、虚引用
 ===
 
+在JDK1.2以前的版本中，当一个对象不被任何变量引用，那么程序就无法再使用这个对象。也就是说，只有对象处于可触及状态，程序才能使用它。这就像在日常生活中，从商店购买了某样物品后，如果有用，就一直保留它，否则就把它扔到垃圾箱，由清洁工人收走。一般说来，如果物品已经被扔到垃圾箱，想再把它捡回来使用就不可能了。      
+但有时候情况并不这么简单，你可能会遇到类似鸡肋一样的物品，食之无味，弃之可惜。这种物品现在已经无用了，保留它会占空间，但是立刻扔掉它也不划算，因为也许将来还会派用场。对于这样的可有可无的物品，一种折衷的处理办法是：如果家里空间足够，就先把它保留在家里，如果家里空间不够，即使把家里所有的垃圾清除，还是无法容纳那些必不可少的生活用品，那么再扔掉这些可有可无的物品。     
+从JDK1.2版本开始，把对象的引用分为四种级别，从而使程序能更加灵活的控制对象的生命周期。
+
+***这四种级别由高到低依次为：强引用 > 软引用 > 弱引用 > 虚引用。***
+
+
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/reference_list.jpg)
+
+在java.lang.ref包中提供了三个类：SoftReference类、WeakReference类和PhantomReference类，它们分别代表软引用、弱引用和虚引用。ReferenceQueue类表示引用队列，它可以和这三种引用类联合使用，以便跟踪Java虚拟机回收所引用的对 象的活动。
+
+
+
 - 强引用(Strong Reference)
-    平时我们编程的时候例如：`Object object=new Object()`；那`object`就是一个强引用了。如果一个对象具有强引用，那就类似于必不可少的生活用品，
-	垃圾回收器绝不会回收它。当内存空 间不足，`Java`虚拟机宁愿抛出`OutOfMemoryError`错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足问题。
+    
+	你懂的，不要胡乱持有着不放，不然内存泄露、oom有你好看，就像是老板（OOM）的亲儿子一样，在公司可以什么事都不干，但是千万不要老是占用公司的资源为他自己做事，记得用完公司的妹子之后,要让她们去工作(资源要懂得释放) 不然公司很可能会垮掉的。   
 
+    平时我们编程的时候例如：`Object object=new Object()`；那`object`就是一个强引用了。如果一个对象具有强引用，那就类似于必不可少的生活用品，垃圾回收器绝不会回收它。当JVM的内存空间不足时，宁愿抛出OutOfMemoryError使得程序异常终止也不愿意回收具有强引用的存活着的对象！记住是存活着，不可能是你new一个对象就永远不会被GC回收。
+    
 - 软引用(SoftReference)
-    如果一个对象只具有软引用，那就类似于可有可物的生活用品。如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存。
-    只要垃圾回收器没有回收它，该对象就可以被程序使用。**软引用可用来实现内存敏感的高速缓存**。 软引用可以和一个引用队列`(ReferenceQueue)`联合使用，
+    
+    描述一些还有用，但并非必需的对象。如果一个对象只具有软引用，那就类似于可有可物的生活用品。如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存，但是system.gc对其无效，有点像老板(OOM)的亲戚，在公司表现不好有可能会被开除，即使你投诉他（调用GC)上班看片，但是只要不被老板看到（被JVM检测到）就不会被开除（被虚拟机回收）。
+    
+**软引用可用来实现内存敏感的高速缓存**。 软引用可以和一个引用队列`(ReferenceQueue)`联合使用，
     如果软引用所引用的对象被垃圾回收，`Java`虚拟机就会把这个软引用加入到与之关联的引用队列中。
-
+    
 - 弱引用(WeakReference)
-    弱引用是在第二次垃圾回收时回收，短时间内通过弱引用取对应的数据，可以取到，当执行过第二次垃圾回收时，将返回null。
-    弱引用主要用于监控对象是否已经被垃圾回收器标记为即将回收的垃圾，可以通过弱引用的isEnQueued方法返回对象是否被垃圾回收器 
-    弱引用可以和一个引用队列`(ReferenceQueue)`联合使用，如果弱引用所引用的对象被垃圾回收,`Java`虚拟机就会把这个弱引用加入到与之关联的引用队列中。 
-	
+    
+    同软引用，也用来描述非必须对象，但是它的强度比软引用更弱一些，被弱引用关联的对象只能生存到下一次垃圾收集发生之前。在对象没有其他引用的情况下，调用system.gc对象可被虚拟机回收，就是一个普通的员工，平常如果表现不佳会被开除（对象没有其他引用的情况下），遇到别人投诉（调用GC)上班看片,那开除是肯定了(被虚拟机回收)。
+    
+	在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了***只具***有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。弱引用最常见的用途是实现规范映射(canonicalizing mappings，比如哈希表）。
 
+    常见的一个例子就是WeakHashMap，在HashMap中，键被置为null，唤醒gc后，不会垃圾回收键为null的键值对。但是在WeakHashMap中，键被置为null，唤醒gc后，键为null的键值对会被回收。
+    
+    ```
+    public static void weakHashMapTest() {
+    	Integer key = new Integer(1);
+    	String value = "李四";
+    	Map<Integer,String> weakHashMap = new WeakHashMap();
+    	weakHashMap.put(key, value);
+    	System.out.println(weakHashMap);//{1=李四}
+    	key = null;
+    	System.gc();
+    	System.out.println(weakHashMap);//{}
+    }
+    public static void hashMapTest() {
+    	HashMap<Integer,String> map = new HashMap<>();
+    	Integer key = 1;
+    	String value = "张三";
+    	map.put(key,value);
+    	System.out.println(map);//{1=张三}
+    	key = null;
+    	System.gc();
+        System.out.println(map);//{1=张三}
+    }
+    ```
+    
 - 虚引用(PhantomReference)   
-    "虚引用"顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，
-    那么它就和没有任何引用一样，在 任何时候都可能被垃圾回收。 虚引用主要用来跟踪对象被垃圾回收的活动。虚引用与软引用和弱引用的一个区别在于：
-    虚引用必须和引用队列 `(ReferenceQueue)`联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，
-    把这个虚引用加入到与之 关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。
-    程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。 虚引用是每次垃圾回收的时候都会被回收，通过虚引用的get方法永远获取到的数据为null，因此也被成为幽灵引用。
-    虚引用是每次垃圾回收的时候都会被回收，通过虚引用的get方法永远获取到的数据为null，因此也被成为幽灵引用。
-    虚引用主要用于检测对象是否已经从内存中删除。
-    
-	
-有关弱引用以及软引用再分析一下:
-我们都知道垃圾回收器会回收符合回收条件的对象的内存，但并不是所有的程序员都知道回收条件取决于指向该对象的引用类型。这正是`Java`中弱引用和软引用的主要区别。
-如果一个对象只有弱引用指向它，垃圾回收器会立即回收该对象，这是一种急切回收方式。相对的，如果有软引用指向这些对象，则只有在`JVM`需要内存时才回收这些对象。
-弱引用和软引用的特殊行为使得它们在某些情况下非常有用。例如：软引用可以很好的用来实现缓存，当`JVM`需要内存时，垃圾回收器就会回收这些只有被软引用指向的对象。
-而弱引用非常适合存储元数据，例如：存储`ClassLoader`引用。如果没有类被加载，那么也没有指向`ClassLoader`的引用。一旦上一次的强引用被去除，
-只有弱引用的`ClassLoader`就会被回收。
+    
+    "虚引用"顾名思义，就是形同虚设，也成为幽灵引用或幻影引用，它是最弱的一种引用关系。就只是一个标识，对象的生命周期不受期影响，这货估计就是个临时工把，遇到事情的时候想到了你，没有事情的时候，秒秒钟拿出去顶锅，开除。
+    
+    一个对象是否有虚引用的存在完全不会对其生存时间构成影响，也无法通过虚引用来取得一个对象实例。为一个对象设置虚引用关联的唯一的用处：能在对象被GC时收到系统通知，主要用于跟踪对象何时被回收，比如防止资源泄漏等。 
+    
+    虚引用必须和引用队列 `(ReferenceQueue)`联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。 虚引用是每次垃圾回收的时候都会被回收，通过虚引用的get方法永远获取到的数据为null。
+    
+    
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/reference_compare.jpg)
+
+
+
+
+
 
 ---
 
diff --git a/README.md b/README.md
index 766477dd..316ffbc9 100644
--- a/README.md
+++ b/README.md
@@ -202,7 +202,7 @@ Android学习笔记
     - [常见算法][95]
     - [网络请求相关内容总结][96]
     - [线程池的原理][97]
-    - [原子性、可见性以及有序性][98]
+    - [Java并发编程之原子性、可见性以及有序性][98]
     - [Base64加密][99]
     - [Git简介][100]
     - [hashCode与equals][101]
@@ -387,7 +387,7 @@ Android学习笔记
 [95]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E5%B8%B8%E8%A7%81%E7%AE%97%E6%B3%95.md   "算法"
 [96]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E7%BD%91%E7%BB%9C%E8%AF%B7%E6%B1%82%E7%9B%B8%E5%85%B3%E5%86%85%E5%AE%B9%E6%80%BB%E7%BB%93.md   "网络请求相关内容总结"
 [97]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E7%BA%BF%E7%A8%8B%E6%B1%A0%E7%9A%84%E5%8E%9F%E7%90%86.md   "线程池的原理"
-[98]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E5%8E%9F%E5%AD%90%E6%80%A7%E3%80%81%E5%8F%AF%E8%A7%81%E6%80%A7%E4%BB%A5%E5%8F%8A%E6%9C%89%E5%BA%8F%E6%80%A7.md   "原子性、可见性以及有序性"
+[98]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/Java并发编程之原子性、可见性以及有序性.md  "Java并发编程之原子性、可见性以及有序性"
 [99]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/Base64%E5%8A%A0%E5%AF%86.md   "Base64加密"
 [100]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/Git%E7%AE%80%E4%BB%8B.md   "Git简介"
 [101]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/hashCode%E4%B8%8Eequals.md   "hashCode与equals"

From e9ff7c5e8cad6d9753f9efaaed909ffb97c3ce2d Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 15 Jul 2020 15:40:30 +0800
Subject: [PATCH 029/213] update

---
 .../MVC\344\270\216MVP\345\217\212MVVM.md"    |  8 ++
 ...04\345\244\215\346\235\202\345\272\246.md" | 27 +++---
 ...13\346\261\240\347\256\200\344\273\213.md" | 84 ++++++++++++++++---
 3 files changed, 92 insertions(+), 27 deletions(-)

diff --git "a/JavaKnowledge/MVC\344\270\216MVP\345\217\212MVVM.md" "b/JavaKnowledge/MVC\344\270\216MVP\345\217\212MVVM.md"
index 031a3198..428ac290 100644
--- "a/JavaKnowledge/MVC\344\270\216MVP\345\217\212MVVM.md"
+++ "b/JavaKnowledge/MVC\344\270\216MVP\345\217\212MVVM.md"
@@ -64,6 +64,14 @@ MVVM
 
 MVVM是Model-View-ViewModel的简写。
 
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/MVVM.png)
+
+MVVM模式将Presener改名为View Model，基本上与MVP模式完全一致，同样是以VM为核心，但是不同于MVP，MVVM采用了数据双向绑定的方案，替代了繁琐复杂的DOM操作。该模型中，View与VM保持同步，View绑定到VM的属性上，如果VM数据发生变化，通过数据绑定的方式，View会自动更新视图；VM同样也暴露出Model中的数据。
+
+看起来MVVM很好的解决了MVC和MVP的不足，但是由于数据和视图的双向绑定，导致出现问题时不太好定位来源，有可能数据问题导致，也有可能业务逻辑中对视图属性的修改导致。如果项目中打算用MVVM的话可以考虑使用官方的架构组件ViewModel、LiveData、DataBinding去实现MVVM
+
+
+
 - 优点
     `MVVM`模式和`MVC`模式一样，主要目的是分离视图`View`和模型`Model`
 - 低耦合。
diff --git "a/JavaKnowledge/\347\256\227\346\263\225\347\232\204\345\244\215\346\235\202\345\272\246.md" "b/JavaKnowledge/\347\256\227\346\263\225\347\232\204\345\244\215\346\235\202\345\272\246.md"
index 1465cb7b..341bdff2 100644
--- "a/JavaKnowledge/\347\256\227\346\263\225\347\232\204\345\244\215\346\235\202\345\272\246.md"
+++ "b/JavaKnowledge/\347\256\227\346\263\225\347\232\204\345\244\215\346\235\202\345\272\246.md"
@@ -41,15 +41,16 @@
 
 什么是时间复杂度，算法中某个函数有n次基本操作重复执行，用T(n)表示，现在有某个辅助函数f(n),使得当n趋近于无穷大时，T（n)/f(n)的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作T(n)=O(f(n)),称O(f(n)) 为算法的渐进时间复杂度，简称时间复杂度。通俗一点讲，其实所谓的时间复杂度，就是找了一个同样曲线类型的函数f(n)来表示这个算法的在n不断变大时的趋势 。当输入量n逐渐加大时，时间复杂性的极限情形称为算法的“渐近时间复杂性”。 
 
-- 时间频度        
+- 时间频度         
 
     一个算法执行所耗费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。但我们不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。并且一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为`T(n)`。（算法中的基本操作一般指算法中最深层循环内的语句）
 
-- 时间复杂度      
+- 时间复杂度         
 
     在刚才提到的时间频度中，`n`称为问题的规模，当`n`不断变化时，时间频度`T(n)`也会不断变化。但有时我们想知道它变化时呈现什么规律。为此，我们引入时间复杂度的概念。
     
     
+
 在进行算法分析时，语句总的执行次数`T(n)`是关于问题规模`n`的函数，进而分析`T(n)`随`n`的变化情况并确定`T(n)`的数量级。
 算法的时间复杂度，也就是算法的时间量度，记作`T(n) = O(f(n))`。它表示随问题规模`n`的增大，算法执行时间的增长率和`f(n)`的增长率相同，
 称为算法的渐近时间复杂度，简称为时间复杂度。其中`f(n)`是规模`n`的某个函数。
@@ -139,26 +140,24 @@ O(2的`n`次方) 比如求具有`n`个元素集合的所有子集的算法
 空间复杂度
 ---
 
-算法的空间复杂度并不是计算实际占用的空间，而是计算整个算法的辅助空间单元的个数，与问题的规模没有关系。算法的空间复杂度`S(n)`定义为该算法所耗费空间的数量级。
-`S(n)=O(f(n))`若算法执行时所需要的辅助空间相对于输入数据量`n`而言是一个常数，则称这个算法的辅助空间为`O(1)`; 
-递归算法的空间复杂度:递归深度`N*`每次递归所要的辅助空间， 如果每次递归所需的辅助空间是常数，则递归的空间复杂度是`O(N)`.
+算法的空间复杂度并不是计算实际占用的空间，而是计算整个算法的辅助空间单元的个数，与问题的规模没有关系。算法的空间复杂度`S(n)`定义为该算法所耗费空间的数量级。     
+`S(n)=O(f(n))`若算法执行时所需要的辅助空间相对于输入数据量`n`而言是一个常数，则称这个算法的辅助空间为`O(1)`;      
+递归算法的空间复杂度:递归深度`N*`每次递归所要的辅助空间， 如果每次递归所需的辅助空间是常数，则递归的空间复杂度是`O(N)`.     
 
-空间复杂度的分析方法:   
+空间复杂度的分析方法:      
 
 - 一个算法的空间复杂度`S(n)`定义为该算法所耗费的存储空间，它也是问题规模`n`的函数。空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度。
 - 一个算法在计算机存储器上所占用的存储空间，包括存储算法本身所占用的存储空间，算法的输入输出数据所占用的存储空间和算法在运行过程中临时占用的存储空间这三个方面。
 - 一个算法的空间复杂度只考虑在运行过程中为局部变量分配的存储空间的大小，它包括为参数表中形参变量分配的存储空间和为在函数体中定义的局部变量分配的存储空间两个部分。
 
-　　算法的空间复杂度一般也以数量级的形式给出。如当一个算法的空间复杂度为一个常量，即不随被处理数据量`n`的大小而改变时，可表示为`O(1)`；
-　　当一个算法的空间复杂度与以2为底的`n`的对数成正比时，可表示为`O(log2n)`；
-　　当一个算法的空间复杂度与`n`成线性比例关系时，可表示为`O(n)`。若形参为数组，则只需要为它分配一个存储由实参传送来的一个地址指针的空间，
-　　即一个机器字长空间；若形参为引用方式，则也只需要为其分配存储一个地址的空间，用它来存储对应实参变量的地址，
-　　以便由系统自动引用实参变量。
+　　算法的空间复杂度一般也以数量级的形式给出。如当一个算法的空间复杂度为一个常量，即不随被处理数据量`n`的大小而改变时，可表示为`O(1)`；      
+　　当一个算法的空间复杂度与以2为底的`n`的对数成正比时，可表示为`O(log2n)`；      
+　　当一个算法的空间复杂度与`n`成线性比例关系时，可表示为`O(n)`。若形参为数组，则只需要为它分配一个存储由实参传送来的一个地址指针的空间，即一个机器字长空间；若形参为引用方式，则也只需要为其分配存储一个地址的空间，用它来存储对应实参变量的地址，以便由系统自动引用实参变量。      
 
-空间复杂度补充:      
+空间复杂度补充:       
 
-一个程序的空间复杂度是指运行完一个程序所需内存的大小。利用程序的空间复杂度，可以对程序的运行所需要的内存多少有个预先估计。
-一个程序执行时除了需要存储空间和存储本身所使用的指令、常数、变量和输入数据外，还需要一些对数据进行操作的工作单元和存储一些为现实计算所需信息的辅助空间。
+一个程序的空间复杂度是指运行完一个程序所需内存的大小。利用程序的空间复杂度，可以对程序的运行所需要的内存多少有个预先估计。      
+一个程序执行时除了需要存储空间和存储本身所使用的指令、常数、变量和输入数据外，还需要一些对数据进行操作的工作单元和存储一些为现实计算所需信息的辅助空间。       
 程序执行时所需存储空间包括以下两部分:      　　
 
 - 固定部分。这部分空间的大小与输入/输出的数据的个数多少、数值无关。主要包括指令空间（即代码空间）、数据空间（常量、简单变量）等所占的空间。这部分属于静态空间。
diff --git "a/JavaKnowledge/\347\272\277\347\250\213\346\261\240\347\256\200\344\273\213.md" "b/JavaKnowledge/\347\272\277\347\250\213\346\261\240\347\256\200\344\273\213.md"
index ac933943..1ec4f548 100644
--- "a/JavaKnowledge/\347\272\277\347\250\213\346\261\240\347\256\200\344\273\213.md"
+++ "b/JavaKnowledge/\347\272\277\347\250\213\346\261\240\347\256\200\344\273\213.md"
@@ -19,18 +19,18 @@
     - 任务接口（`Task`）:每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等
     - 任务队列（`TaskQueue`）:用于存放没有处理的任务。提供一种缓冲机制。
 
-    
 - 使用线程池的好处:        
-    - 减少在创建和销毁线程上所花的时间以及系统资源的开销 
-    - 如不使用线程池，有可能造成系统创建大量线程而导致消耗完系统内存以及”过度切换”。 
-	- 提交相应速度
+    - 降低资源消耗。通过重复利用减少在创建和销毁线程上所花的时间以及系统资源的开销 
+    - 提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，
+	     还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。如不使用线程池，有可能造成系统创建大量线程而导致消耗完系统内存以及”过度切换”。 
+	- 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
 	
 - 工作流程            
     线程池的任务就在于负责这些线程的创建，销毁和任务处理参数传递、唤醒和等待。
     - 创建若干线程，置入线程池
     - 任务达到时，从线程池取空闲线程
     - 取得了空闲线程，立即进行任务处理
-    - 否则新建一个线程，并置入线程池，执行3
+    - 否则新建一个线程，并置入线程池，并执行上一步
     - 如果创建失败或者线程池已满，根据设计策略选择返回错误或将任务置入处理队列，等待处理
     - 销毁线程池
 	
@@ -76,10 +76,10 @@ public class ThreadPoolExecutor extends AbstractExecutorService {
 
 上面构造器中各参数的含义:    
 
-- `corePoolSize`:核心池的大小。在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，
+- `corePoolSize`:用来表示线程池中的核心线程的数量，也可以称为可闲置的线程数量。在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，
 除非调用了`prestartAllCoreThreads()`或者`prestartCoreThread()`方法，从这2个方法的名字就可以看出，是预创建线程的意思，即在没有任务到来之前就创建`corePoolSize`个线程或者一个线程。默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到`corePoolSize`后，就会把到达的任务放到缓存队列当中；
 
-- `maximumPoolSize`:线程池最大线程数，这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程；
+- `maximumPoolSize`:来表示线程池中最多能够创建的线程数量。这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程；
 - `keepAliveTime`:表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于`corePoolSize`时，`keepAliveTime`才会起作用，直到线程池中的线程数不大于`corePoolSize`，即当线程池中的线程数大于`corePoolSize`时，如果一个线程空闲的时间达到`keepAliveTime`，则会终止，直到线程池中的线程数不超过`corePoolSize`。但是如果调用了`allowCoreThreadTimeOut(boolean)`方法，在线程池中的线程数不大于`corePoolSize`时，`keepAliveTime`参数也会起作用，直到线程池中的线程数为0；     
 - `unit`:参数`keepAliveTime`的时间单位，有7种取值，在`TimeUnit`类中有7种静态属性:      
 
@@ -100,7 +100,7 @@ public class ThreadPoolExecutor extends AbstractExecutorService {
 
 - `threadFactory`:线程工厂，主要用来创建线程
 - `handler`:表示当拒绝处理任务时的策略，有以下四种取值:      
-    
+  
     - `ThreadPoolExecutor.AbortPolicy`:丢弃任务并抛出`RejectedExecutionException`异常     
     - `ThreadPoolExecutor.DiscardPolicy`:也是丢弃任务，但是不抛出异常   
     - `ThreadPoolExecutor.DiscardOldestPolicy`:丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
@@ -111,15 +111,18 @@ public class ThreadPoolExecutor extends AbstractExecutorService {
 线程池状态
 ---
 
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/thread_poll_state.png)
+
+
+
 `ThreadPoolExecutor`中定义了一个`volatile`变量，另外定义了几个`static final`变量表示线程池的各个状态:    
 
-- `volatile int runState;`       
-- `static final int RUNNING    = -1;`当创建线程池后，初始时，线程池处于`RUNNING`状态；
+- `volatile int runState;` 表示当前线程池的状态，它是一个`volatile`变量用来保证线程之间的可见性
+- `static final int RUNNING    = -1;`此状态下，线程池可以接受新的任务，也可以处理阻塞队列中的任务。执行shutdown()方法可进入待关闭（SHUTDOWN）状态，执行shutdownNow()方法可进入停止（STOP）状态。
 - `static final int SHUTDOWN   = 0;`如果调用了`shutdown()`方法，则线程池处于`SHUTDOWN`状态，此时线程池不能够接受新的任务，它会等待所有任务执行完毕
 - `static final int STOP       = 1;`如果调用了`shutdownNow()`方法，则线程池处于`STOP`状态，此时线程池不能接受新的任务，并且会去尝试终止正在执行的任务；
-- `static final int TIDYING    = 2;`该状态表示线程池对线程进行整理优化；
-- `static final int TERMINATED = 3;`当线程池处于`SHUTDOWN`或`STOP`状态，并且所有工作线程已经销毁，任务缓存队列已经清空或执行结束后，线程池被设置为`TERMINATED`状态
-`runState`表示当前线程池的状态，它是一个`volatile`变量用来保证线程之间的可见性；
+- `static final int TIDYING    = 2;`此状态下，所有任务都已经执行完毕，且没有工作线程。执行terminated()方法进入终止（TERMINATED）状态。该状态表示线程池对线程进行整理优化；
+- `static final int TERMINATED = 3;`当线程池处于`SHUTDOWN`或`STOP`状态，并且所有工作线程已经销毁，任务缓存队列已经清空或执行结束后，线程池被设置为`TERMINATED`状态。此状态下，线程池完全终止，并完成了所有资源的释放。
 
 
 `Executors`类
@@ -170,6 +173,61 @@ public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
 实际中，如果`Executors`提供的三个静态方法能满足要求，就尽量使用它提供的三个方法，因为自己去手动配置`ThreadPoolExecutor`的参数有点麻烦，要根据实际任务的类型和数量来进行配置。
 
 
+
+## 线程池执行状态
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/thread_poll_process.png)
+
+整个过程可以拆分成以下几个部分：
+
+- 提交任务
+
+    当向线程池提交一个新的任务时，线程池有三种处理情况，分别是：创建一个工作线程来执行该任务、将任务加入阻塞队列、拒绝该任务。
+
+    提交任务的过程也可以拆分成以下几个部分：
+
+    1. 当工作线程数小于核心线程数时，直接创建新的核心工作线程。
+    2. 当工作线程数大于核心线程数时，就需要尝试将任务添加到阻塞队列中去。
+    3. 如果能够加入成功，说明队列还没满，那么就需要做以下的二次校验来保证添加进去的任务能够成功被执行。
+    4. 验证当前线程池中的运行状态，如果是非RUNNING状态，则需要将任务从阻塞队列中移除，然后拒绝该任务。
+    5. 验证当前线程池中的工作线程的个数，如果是0，则需要主动添加一个空工作线程来执行刚刚添加到阻塞队列中的任务。
+    6. 如果加入失败，说明队列已经满了，这时就需要创建新的临时工作线程来执行任务。
+    7. 如果创建成功，则直接执行该任务。
+    8. 如果创建失败，说明工作线程数已经等于最大线程数了，只能拒绝该任务了。
+
+- 创建工作线程
+
+    创建工作线程需要做一系列的判断，需要确保当前线程池可以创建新的线程之后，才能创建。
+
+    首先，当线程池的状态是SHUTDOWN或者STOP时，不能创建新的线程。
+
+    其次，当线程工厂创建线程失败时，也不能创建新的线程。
+
+    第三，拿当前工作线程的数量与核心线程数、最大线程数进行比较，如果前者大于后者的话，也不允许创建。除此之外，线程池会尝试通过CAS来自增工作线程的个数，如果自增成功了，则会创建新的工作线程，即Worker对象。
+
+    然后加锁进行二次验证是否能够创建工作线程，如果最后创建成功，则会启动该工作线程。
+
+- 启动工作线程
+
+    当工作线程创建成功后，也就是Worker对象已经创建好了，这时就需要启动该工作线程，让线程开始干活了，Worker对象中关联着一个Thread，所以要启动工作线程的话，只要通过worker.thread.start()来启动该线程即可。
+
+    启动完了之后，就会执行Worker对象的run方法，因为Worker实现了Runnable接口，所以本质上Worker也是一个线程。
+
+    通过线程start开启之后就会调用到Runnable的run方法，在Worker对象的run方法中，调用了runWorker(this)方法，也就是把当前对象传递给了runWorker()方法，让它来执行。
+
+- 获取任务并执行
+
+    在runWorker方法被调用之后，就是执行具体的任务了，首先需要拿到一个可以执行的任务，而Worker对象中默认绑定了一个任务，如果该任务不为空的话，那么就是直接执行。
+
+    执行完了之后，就会去阻塞队列中获取任务来执行。
+
+    获取任务的过程则需要考虑当前工作线程的个数：
+
+    1. 如果工作线程数大于核心线程数，那么就需要通过poll(keepAliveTime, timeUnit)来获取，因为这时需要对闲置线程进行超时回收。
+    2. 如果工作线程数小于等于核心线程数，那么就可以通过take()来获取了。因为这时所有的线程都是核心线程，不需要进行回收，前提是没有设置allowCoreThreadTimeOut（允许核心线程超时回收）为true。
+
+
+
 向线程池提交任务
 ---
 

From 53cb30b26a01160e5e6626393344b455364b86a6 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 23 Jul 2020 19:38:48 +0800
Subject: [PATCH 030/213] update images

---
 .../1. ExoPlayer\347\256\200\344\273\213.md"  |  2 +-
 ...47\350\203\275\344\274\230\345\214\226.md" | 76 ++++++++++++++++---
 2 files changed, 67 insertions(+), 11 deletions(-)

diff --git "a/VideoDevelopment/ExoPlayer/1. ExoPlayer\347\256\200\344\273\213.md" "b/VideoDevelopment/ExoPlayer/1. ExoPlayer\347\256\200\344\273\213.md"
index d3355a06..09afc156 100644
--- "a/VideoDevelopment/ExoPlayer/1. ExoPlayer\347\256\200\344\273\213.md"	
+++ "b/VideoDevelopment/ExoPlayer/1. ExoPlayer\347\256\200\344\273\213.md"	
@@ -37,7 +37,7 @@ implementation 'com.google.android.exoplayer:exoplayer-ui:2.X.X'
 - `exoplayer-smoothstreaming`:支持SmoothStreaming
 - `exoplayer-ui`:使用ExoPlayer所需的UI部分和资源
 
-上面讲到了DASH、HLS、SmoothStreaming，具体的介绍可以参考[流媒体通信协议]()
+上面讲到了DASH、HLS、SmoothStreaming，具体的介绍可以参考[流媒体通信协议](https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE)
 
 除了上面的几个类库外，ExoPlayer还有很多扩展库提供一些额外的功能，有一些可以直接通过JCenter进行依赖，有一些需要手动去编译，具体的可以通过[扩展库目录](https://github.com/google/ExoPlayer/tree/release-v2/extensions/)中的README来查看详细的内容。
 可以通过JCenter进行依赖的类库和扩展可以从[ExoPlayer的Binatry](https://bintray.com/google/exoplayer)上查看。
diff --git "a/VideoDevelopment/\346\222\255\346\224\276\345\231\250\346\200\247\350\203\275\344\274\230\345\214\226.md" "b/VideoDevelopment/\346\222\255\346\224\276\345\231\250\346\200\247\350\203\275\344\274\230\345\214\226.md"
index ba32b52d..d1c96ecb 100644
--- "a/VideoDevelopment/\346\222\255\346\224\276\345\231\250\346\200\247\350\203\275\344\274\230\345\214\226.md"
+++ "b/VideoDevelopment/\346\222\255\346\224\276\345\231\250\346\200\247\350\203\275\344\274\230\345\214\226.md"
@@ -10,10 +10,10 @@
 
 
 
-
 ### 成本优化
 
 #### 预下载控制
+
 - 不限速
 - 非高峰时段，预下载N秒
 - 高峰时段，预下载M秒
@@ -29,11 +29,43 @@
 对解码能力进行评估，来通过机型打分控制是否使用H265以及是用360p还是480p。   
 但是H265全部切换成本较高，牵扯到转码成本以及存储成本，所以可以只对热点的视频去进行编码，这样少量的视频就可以带来可观的效果。
 
+#### 防盗链
+
+
+会有一个防盗链的请求，通过 HTTP 拿到真实的播放 URL 才可以下载数据。
+
+但是在手机上执行 HTTP 请求非常耗时，这里走私有长连接通道做这个事情。
+
+#### PCDN
+
+有关CDN相关可参考[CDN及PCDN](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/CDN%E5%8F%8APCDN.md)
+
 ### 秒开
 
-能立即起播，不会产生缓冲
+能立即起播，不会产生缓冲。秒开很简单，预加载数据就行。不够快就预解封装、解码，还不够快就再加上预渲染。但是秒开又是最难的。
 播放器初始化->业务逻辑->DNS解析->CDN下载数据->解码->渲染播放
 
+“在所有环节中，短视频列表播放的体验非常重要。例如抖音，你会发现起播非常快，循环播放也很流畅。这是怎么做到的呢？这就是通过列表预加载技术实现的。常规的预加载是通过多个播放器来实现的，播放当前视频的时候去预加载下一个视频，这个方案的缺点是实现逻辑非常复杂，同时也消耗更多性能。所以，阿里云独创了列表播放器，通过简单的接口调用就可以实现列表的预加载播放。它有几个特点，首先是能够做到防卡顿的缓存策略，通过对缓存的管理，可以灵活控制卡顿期间的预缓存策略，同时优化缓冲的淘汰策略。第二是对滑动的流畅性针对性优化，保证每个视频停止的耗时在16毫秒以内。第三是采用了基于内存的预加载缓存技术，循环播放和秒开直接从内存读取数据，无需额外的文件操作。第四非常关键，是提供简单的接口，可以非常快速的实现短视频播放功能
+
+
+
+#### 预加载
+
+预加载能减少首次缓冲时间，但是预加载不能和当前播放的视频抢下载带宽，需要达到一个合适的阈值再开始下载。
+
+优先保证封面图等信息完成后再根据云控的当前缓冲的时长等信息来控制是否要启动预加载
+
+提升视频加载速度的常见手段就是预加载 ，即在用户播放之前，预先下载好一部分数据，这样在视频开播的时候就不需要等待网络请求。这里面有两个挑战，一个是预加载需要下载多少数据才算够呢？下载多了，浪费带宽；下载少了，不够拿来开播，也就无法满足快开的要求。拿 MP4来说，要解码出首帧，首先需要解析完 moov （可以理解为 header），而 moov的大小则和视频的长度相关。所以需要针对不同的视频计算出不同的预加载大小。第二个是即便视频数据已经预先下载完毕，但在开播前播放器的创建，外壳 view的布局，内核中的 MP4 解封装、解码、渲染仍然会导致有数百毫秒级别的耗时，在全屏沉浸式的场景中仍然能被用户感知到加载过程。
+为了实现极致的快开体验，我们实现了多实例的播放器，在预加载的基础上更极致地缩减开播耗时，实现了直出的开播体验。一般情况下，卡顿和视频清晰度是互斥的，清晰度越高，视频码率越高，用户越容易遇到缓冲卡顿。为了一个指标牺牲另一个指标是不被接受的。我们的视频内容在下发前会在云端预先转码成多档清晰度，并在端的播放器实现了一套在播放过程中基于用户的网络类型、平均网速、视频时长等指标动态升级或降级清晰度的策略，保证了绝大多数用户都能观看到匹配自己网络条件、最高清晰度的视频，在提升整体视频质量的同时守住了卡顿率。
+
+- 预加载时机提前
+
+    利用滑动切换视频时，在滑动松手到滑动停止这段时间（300 毫秒），在保证滑动帧率的前提下，开启子线程预加载后面的视频，利用这 300 毫秒，预加载后面的视频流，保证本地起播。相比原先预加载时机是在滑动停止，当前视频起播后才预加载后面的视频，假设视频起播时间为 500 毫秒，则相比优化前，预加载时机提前了至少 800 毫秒，这是非常可观的提升。最后测试下来，也是此优化项对于缓存命中率的提升是最为明显的。
+
+- 多播放器
+
+    空间换时间。双播放器方案原理比较简单，就是在当前视频起播之后，预准备下一个视频的播放器，两个播放器循环使用。下一个视频的播放器一旦准备好，加上视频流已加载到本地，则起播非常快，几乎是视频直出的效果。但由于播放器准备更耗时，用户滑到下一个视频时，并不能百分百保证此视频的播放器已准备好。
+
 #### MOOV后置
 
 很多手机为了偷懒，录制完视频后才知道视频信息，所以把moov放到末尾。对于moov放到视频最后的情况下，就要多一次seek，当从头开始解析的时候如果发现未找到moov信息，需要将其seek到尾部再去寻找，这样会导致起播慢。 
@@ -55,22 +87,46 @@ IP竞速
 
 DNS解析加快，通常，DNS解析，意味着要把一个域名为xxx.com解析成ip过程，平时请求网页，网络差，就会打开网页半天。
 
-#### 防盗链
 
 
-会有一个防盗链的请求，通过 HTTP 拿到真实的播放 URL 才可以下载数据。
+### 监控
+
+监控上报，肯定是不可缺少的，这是一个成熟的项目必备的要素。
+
+1. 问题定位，老板跟用户反馈说我这个视频播不了，要有一套成熟的问题定位的方式；
+    传统的捞Log方式大家都有，但是这种方式效率太低，需要等用户上线之后才能捞到Log，Log捞到之后还得花时间去分析。我们做法的是在关键问题上做一些插装，把每一类错误和每一个具体的子错误都能定义出来，这样一看错误码就知道播放错误是由什么原因导致的。还可以把每次播放视频的链路所有关键流水上报到统计系统里来，每一次播放都是一组流水，每一条流水里面就包含了例如首次缓冲发生的Seek，或下载的链接是多少，下载的时间是多少，有了这些流水之后，用户反馈播放失败，我首先可以用流水看发生了什么错误？错误在哪一步？每一步信息是什么？几秒钟就可以定位到问题。
+
+有了这个数据上报之后，还可以做一些报表。比如说可以做错误码的报表，有了报表之后就可以跟进哪个错误是在TOP的，负责人是谁，原因是什么，都可以看到。
+
+我们也有自己实时的曲线，可以看到各项数据的情况。在告警方面，基于成功率和失败率的统计，进行实时告警。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
-但是在手机上执行 HTTP 请求非常耗时，这里走私有长连接通道做这个事情。
 
-#### 预加载
 
-预加载能减少首次缓冲时间，但是预加载不能和当前播放的视频抢下载带宽，需要达到一个合适的阈值再开始下载。
 
-优先保证封面图等信息完成后再根据云控的当前缓冲的时长等信息来控制是否要启动预加载
 
-#### PCDN
 
-有关CDN相关可参考[CDN及PCDN](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/CDN%E5%8F%8APCDN.md)
 
 ---
 

From 6839d71ea8f2840a9f2e614f69894e51da17cdfb Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 26 Nov 2020 09:22:08 +0800
Subject: [PATCH 031/213] add OperatingSystem

---
 ...66\346\236\204\347\256\200\344\273\213.md" |  37 +++
 ...ps\347\232\204\345\214\272\345\210\253.md" |  39 +++
 ...15\344\275\234\347\263\273\347\273\237.md" | 287 +++++++++++++++++
 .../2.\350\277\233\347\250\213.md"            | 303 ++++++++++++++++++
 ...05\345\255\230\347\256\241\347\220\206.md" | 277 ++++++++++++++++
 .../4.\350\260\203\345\272\246.md"            |  87 +++++
 OperatingSystem/5.IO.md                       |  42 +++
 ...07\344\273\266\347\256\241\347\220\206.md" |  67 ++++
 ...45\345\274\217\347\263\273\347\273\237.md" |  27 ++
 ...8.\350\231\232\346\213\237\346\234\272.md" | 134 ++++++++
 10 files changed, 1300 insertions(+)
 create mode 100644 "Architect/1.\346\236\266\346\236\204\347\256\200\344\273\213.md"
 create mode 100644 "OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237.md"
 create mode 100644 "OperatingSystem/2.\350\277\233\347\250\213.md"
 create mode 100644 "OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
 create mode 100644 "OperatingSystem/4.\350\260\203\345\272\246.md"
 create mode 100644 OperatingSystem/5.IO.md
 create mode 100644 "OperatingSystem/6.\346\226\207\344\273\266\347\256\241\347\220\206.md"
 create mode 100644 "OperatingSystem/7.\345\265\214\345\205\245\345\274\217\347\263\273\347\273\237.md"
 create mode 100644 "OperatingSystem/8.\350\231\232\346\213\237\346\234\272.md"

diff --git "a/Architect/1.\346\236\266\346\236\204\347\256\200\344\273\213.md" "b/Architect/1.\346\236\266\346\236\204\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..f75f78d3
--- /dev/null
+++ "b/Architect/1.\346\236\266\346\236\204\347\256\200\344\273\213.md"
@@ -0,0 +1,37 @@
+1.系统架构
+===
+
+### 架构三要素
+
+#### 构件
+
+构件在软件领域是指可复用的模块，它可以是被封装的对象类、类树、一些功能模块、软件框架(framework)、软件架构(或体系结构Architectural)、文档、分析件、设计模式(Pattern)。但是，操作集合、过程、函数即使可以复用也不能成为一个构件。 
+
+##### 构件的属性: 
+1. 有用性(Usefulness):构件必须提供有用的功能。
+2. 可用性(Usability):构件必须易于理解和使用，可以正常运行。
+3. 质量(Quality):构件及其变形必须能正确工作，质量好坏与可用性相互补充。
+4. 适应性(Adaptability):构件应该易于通过参数化等方式再不同环境中进行配置，比较高端一点的复用性，接收外界各种入参，产生不同的结果，健壮性比较高。
+5. 可移植性(Portability):构件应能在不同的硬件运行平台和软件环境中工作，可移植性比较好，跨平台。
+
+
+#### 模式(Pattern)
+
+其实就是解决某一类问题的方法论，是生产经验和生活经验中经过抽象和升华提炼出来的核心知识体系。 模式就是一个完整的流程闭环，能够解决一些问题的通用方法(比如资本运作、玩家不同的需求等)，软件中的模式大多源于生活，是人类智慧的结晶。  
+
+#### 规划
+
+规划是系统架构中最重要的组成部分，是个人或者组织制定的比较全民长远的发展计划，是对未来整体性、长期性、基本性问题的思考和考量。设计未来整套行动的方案。很早就有规划这个概念了，例如:国家的十一五规划等。当然软件开发也和生活紧密联系，一个大型的系统也需要良好的规划，规划可以说是基石，是系统架构的前提。 
+
+
+系统架构虽然是软件系统的结构，行为，属性的高级抽象，但其根本就是在需求分析的基础行为下，制定技术框架，对需求的技术实现。 
+
+
+
+
+		
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/JavaKnowledge/Http\344\270\216Https\347\232\204\345\214\272\345\210\253.md" "b/JavaKnowledge/Http\344\270\216Https\347\232\204\345\214\272\345\210\253.md"
index 90346bfb..417c7785 100644
--- "a/JavaKnowledge/Http\344\270\216Https\347\232\204\345\214\272\345\210\253.md"
+++ "b/JavaKnowledge/Http\344\270\216Https\347\232\204\345\214\272\345\210\253.md"
@@ -9,8 +9,14 @@ HTTP与HTTPS的区别
 
 - 1997年发布HTTP/1.1: 持久连接(长连接)、节约带宽、HOST域、管道机制、分块传输编码。
 
+    长连接是指的TCP连接，也就是说复用的是TCP连接。即长连接情况下，多个HTTP请求可以复用同一个TCP连接，这就节省了很多TCP连接建立和断开的消耗。
+
+    此外，长连接并不是永久连接的。如果一段时间内（具体的时间长短，是可以在header当中进行设置的，也就是所谓的超时时间），这个连接没有HTTP请求发出的话，那么这个长连接就会被断掉。
+
 - 2015年发布HTTP/2:多路复用、服务器推送、头信息压缩、二进制协议等。
 
+
+
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/http1.1vs2.jpg)
 
 多路复用：通过单一的HTTP/2连接请求发起多重的请求-响应消息，多个请求stream共享一个TCP连接，实现多留并行而不是依赖建立多个TCP连接。
@@ -27,6 +33,25 @@ HTTP与HTTPS的区别
 
 - 传输速度快
 
+
+
+### HTTP请求响应过程
+
+你是不是很好奇，当你在浏览器中输入网址后，到底发生了什么事情？你想要的内容是如何展现出来的？让我们通过一个例子来探讨一下，我们假设访问的 URL 地址为 `http://www.someSchool.edu/someDepartment/home.index`，当我们输入网址并点击回车时，浏览器内部会进行如下操作
+
+- DNS服务器会首先进行域名的映射，找到访问`www.someSchool.edu`所在的地址，然后HTTP 客户端进程在 80 端口发起一个到服务器 `www.someSchool.edu` 的 TCP 连接（80 端口是 HTTP 的默认端口）。在客户和服务器进程中都会有一个`套接字`与其相连。
+- HTTP 客户端通过它的套接字向服务器发送一个 HTTP 请求报文。该报文中包含了路径 `someDepartment/home.index` 的资源，我们后面会详细讨论 HTTP 请求报文。
+- HTTP 服务器通过它的套接字接受该报文，进行请求的解析工作，并从其`存储器(RAM 或磁盘)`中检索出对象 [www.someSchool.edu/someDepartment/home.index，然后把检索出来的对象进行封装，封装到](http://www.someSchool.edu/someDepartment/home.index，然后把检索出来的对象进行封装，封装到) HTTP 响应报文中，并通过套接字向客户进行发送。
+- HTTP 服务器随即通知 TCP 断开 TCP 连接，实际上是需要等到客户接受完响应报文后才会断开 TCP 连接。
+- HTTP 客户端接受完响应报文后，TCP 连接会关闭。HTTP 客户端从响应中提取出报文中是一个 HTML 响应文件，并检查该 HTML 文件，然后循环检查报文中其他内部对象。
+- 检查完成后，HTTP 客户端会把对应的资源通过显示器呈现给用户。
+
+至此，键入网址再按下回车的全过程就结束了。上述过程描述的是一种简单的`请求-响应`全过程，真实的请求-响应情况可能要比上面描述的过程复杂很多。
+
+
+
+
+
 ## HTTPS
 
 Https并非是应用层的一种新协议。只是http通信接口部分用SSL(安全套接字层)和TLS(安全传输层协议)代替而已。即添加了加密及认证机制的HTTP称为HTTPS(HTTP Secure).    
@@ -135,7 +160,21 @@ HTTP + 加密 + 认证 + 完整性保护 = HTTPS
 
 
 
+### Https 请求慢的解决办法
+
+1. 不通过DNS解析，直接访问IP
+
+2. 解决连接无法复用
+
+    http/1.0协议头里可以设置Connection:Keep-Alive或者Connection:Close，选择是否允许在一定时间内复用连接（时间可由服务器控制）。但是这对App端的请求成效不大，因为App端的请求比较分散且时间跨度相对较大。
+
+    方案1.基于tcp的长连接 (主要） 移动端建立一条自己的长链接通道，通道的实现是基于tcp协议。基于tcp的socket编程技术难度相对复杂很多，而且需要自己定制协议。但信息的上报和推送变得更及时，请求量爆发的时间点还能减轻服务器压力（避免频繁创建和销毁连接）
+
+    方案2.http long-polling 客户端在初始状态发送一个polling请求到服务器，服务器并不会马上返回业务数据，而是等待有新的业务数据产生的时候再返回，所以链接会一直被保持。一但结束当前连接，马上又会发送一个新的polling请求，如此反复，保证一个连接被保持。 存在问题： 1）增加了服务器的压力 2）网络环境复杂场景下，需要考虑怎么重建健康的连接通道 3）polling的方式稳定性不好 4）polling的response可能被中间代理cache住 ……
+
+    方案3.http streaming 和long-polling不同的是，streaming方式通过再server response的头部增加“Transfer Encoding:chuncked”来告诉客户端后续还有新的数据到来 存在问题： 1）有些代理服务器会等待服务器的response结束之后才将结果推送给请求客户端。streaming不会结束response 2）业务数据无法按照请求分割 ……
 
+    方案4.web socket 和传统的tcp socket相似，基于tcp协议，提供双向的数据通道。它的优势是提供了message的概念，比基于字节流的tcp socket使用更简单。技术较新，不是所有浏览器都提供了支持。
 
 
 
diff --git "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237.md" "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237.md"
new file mode 100644
index 00000000..00696a2d
--- /dev/null
+++ "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237.md"
@@ -0,0 +1,287 @@
+
+
+# 1.操作系统
+
+
+
+操作系统(Operating System, 简称OS)是管理和控制计算机硬件与软件资源的计算机程序，是一种由引导程序（bootloader）启动并管理计算机中所有程序生命周期的系统程序。任何其他软件都必须在操作系统的支持下才能运行，操作系统能有效组织和管理系统中的各种软、硬件资源，合理组织计算机系统的工作流程并控制程序的执行，为用户提供一个良好的操作环境。 目前比较为人所知的操作系统有Microsoft的Windows系统、Apple的Mac及以Linux为内核的各种Linux发行版(Centos/Ubuntu等)。 现代计算机系统由一个或多个处理器、主存、打印机、键盘、鼠标、显示器、网络接口及各种输入\输出设备构成。
+
+作用:    它可以帮我们管理计算机的各种资源，协助我们完成各种复杂繁琐的任务。
+
+
+
+### 以现代标准而言，一个标准PC的操作系统应该提供以下功能
+
+
+
+### 用户界面(User interface)
+
+
+
+普通用户操作电脑是需要用户界面的，没有用户界面的电脑对于普通用户来说就是灾难。你能想象家里的老人或者上了年纪的人用电脑却没有鼠标的场景吗？你能想象使用黑框框来做 PPT 吗？你能想象使用黑框框来浏览网页吗？
+专业的 IT 工作者有时候会使用黑框框纯粹是工作需要，在有些场景下，黑框框比用户界面更有效率一些。而类似于服务器场景的开发工作基本上是没有用户界面的，当然一直强调的是专业场景，这个世界上能流畅使用黑框框的人占总人口的比例太少太少。
+用户界面这项伟大的发明诞生于施乐公司，经乔布斯和比尔盖茨商业化运作后得以让世人发现它的伟大之处。用户界面的发明就相当于简体汉字的出现一般，简体汉字的推行让中国的文盲率大幅降低，而用户界面的发明则大幅降低了计算机的使用难度，所以你很难想象现代的操作系统没有用户界面。
+
+
+
+#### 进程管理(Processing management)
+
+
+
+先来解释一下什么是进程。进程是计算机进行资源管理以及调度的基本单位，是程序的执行实体。这种说法比较正统，或者你可以将一个进程看成是计算机正在进行的一项任务。计算机里面有很多各式各样功能的进程，那么多进程如何比较好的运行是个深奥的学问。
+你可以想象一下：你打开了微信、word 文档、音乐软件，你想一边跟同事进行交流文档的内容应该如何写，一边在 word  文档敲下你的构思，然后在这个过程中你还听着音乐。在这个过程中，计算机需要将微信的网络保持连接，持续收发微信的信息，随时保存你的 word  文档到磁盘上，解码音乐流并播放出来。这一系列程序运转如何能让你产生一个假象：你以为它们是在同时运行的，但其实它们在同一时刻只有一个在运行。这就是进程管理和调度。
+
+
+
+#### 内存管理(Memory management)
+
+内存是计算机很重要的一个资源，因为程序只有被加载到内存中才可以运行，此外 CPU  所需要的指令与数据也都是来自内存的。内存的并不是无限制的，它受限于硬件和寻址位数。但是现代操作系统会让每一个进程都觉得自己在独占整个内存，这就是虚拟内存技术。值得注意的是，这里的虚拟内存与 swap 这种虚拟内存是不一样的，虽然两个都是成为虚拟内存，但是完全是两个不同方向的技术。
+进程的运行需要分配内存，内存分配的快慢都与内存管理方式有着巨大的影响。两个不同进程对应的内存区域是不能相互访问的，操作系统必须得提供这样的保证，否则很容易出问题，比如：运行着的 dota  游戏如果可以被另外一个进程访问它的内存区域的话，那就可以直接将内存区域中的某个数值进行修改，比如将游戏中的玩家生命值变为无限，这样对手怎么打都打不死自己的英雄。例如前段时间火热的吃鸡游戏，外挂软件可以让角色在决赛圈外进行锁血，这个就是游戏内存被修改的最好示例。当然这是通过比较专业的手段来绕过操作系统的限制，这也从另外一个方面来说明，其实现在的操作系统安全性也是有很大提升空间的。
+进程退出销毁时，内存的回收也是很重要的，否则很容易就会产生内存溢出，占着茅坑不拉屎，导致其他的进程都憋死。
+
+
+
+#### 文件系统(File system)
+
+
+
+文件系统与用户的距离很近，每个人平常在使用计算机的时候或多或少都会留下一些数据，而这些数据通常会保留在磁盘里面。磁盘如果不进行格式化的话，普通人是没法使用的。磁盘里面其实就是一些布满磁性物质的盘片，在计算机的世界里数据是 0 和 1 组成的，那对应的在磁盘里面就是磁性的正负极，也就是说计算机的一个文本数据要保存到磁盘中，那就需要将文本数据的电气化信号 0 和 1 通过磁盘翻译为磁性正负极并保存起来。
+磁盘格式化的过程就是将文件系统架设到磁盘上，这样可以更好的管理磁盘的数据。你可以将磁盘未格式化之前的数据看做是一堆杂乱无章散落在地上的书，而文件系统就是一个有编排顺序的书架，格式化的过程就是将这堆书一本本按编排顺序放到书架上。这个比喻不太恰当，因为格化式操作通常来说会清掉数据，就相当于将书里面的字都清掉了，放到书架上的书里面都是空白页，所以格式化的时候请谨慎。
+
+
+
+#### 网络通信(Networking)
+
+
+
+我们常见的网络通信场景有：微信聊天、浏览网页、玩网络游戏等，可以说现在的操作系统如果不能上网感觉就没了灵魂。网络通信是个很复杂的过程，连很多专业的程序猿都说不清楚当他上网时网页是如何显示出来的，更别说整个网络的拓扑结构了。
+整个网络通信其实是一套约定好的通信协议，很多人第一次听说协议时觉得很高级，其实没什么高级的，简单的说，类似于我们军训时当教官喊立正我们必须得做出相应动作一样，一个指令对应一个动作。由于网络太复杂了，某位哲人说过如果某样东西太复杂可以通过分层来解决，于是网络分了 5 层。有人也许会说是 7 层，那是 OSI 标准，在实际应用中一般都是 5 层。由于网络这块内容实在是太复杂，后面我会另开一个专栏进行讲解。
+
+
+
+#### 设备管理
+
+
+
+计算机上有很多设备，比如CPU、内存、网卡、声卡、显卡、硬盘等。那什么是设备管理？
+在计算机中除了 CPU 和内存，对于其他一切输入输出设备的管理统称为设备管理。
+计算机中的设备分为输入和输出设备。以 CPU 为中心，凡是向 CPU 输送数据的设备统称为输入设备，例如鼠标、键盘、摄像头等；同样以 CPU 为中心，凡是从 CPU 获取数据的设备统称为输出设备，如显示器等。有些设备既是输入设备也是输入设备，比如网卡等。 
+一个比较常见的场景是当我们将 U盘插进电脑的 USB 插孔时，电脑能实时识别出 U 盘设备，那计算机为啥能实时识别出这些设备呢？之后会有章节讨论一下这个话题。
+
+
+
+## 计算机的组成
+
+
+
+计算机由处理器、存储器和输入\输出部件组成，每类部件都有一个或多个模块。这些部件以某种方式互连，以实现计算机执行程序的主要功能。因此，计算机有4个主要的结构化部件: 
+
+- 处理器(Processor)：控制计算机的操作，执行数据处理功能。只有一个处理器时，它通常指中央处理器(CPU)
+- 内存（Main memory):存储数据和程序。此类存储器通常是易失性的，即当计算机关机时，存储器的内容会丢失。相对于此的是磁盘存储器，当计算机关机时，它的内容不会丢失。内存通常也成为实存储器(real memory)或主存储器(primary memory)。
+- 输入\输出模块(I/O modules):在计算机和外部环境之间移动数据。外部环境由各种外部设备组成，包括辅助存储器设备(如硬盘)、通信设备和终端。
+- 系统总线(System bus)在处理器、内存和输入\输出模块间提供通信的设施。 
+
+
+
+处理器的一种功能是与存储器叫唤数据。为此，它通常使用两个内部寄存器: 
+
+- 存储器地址寄存器(Memory Address Register, MAR),用于确定下一次读/写的存储器地址。
+- 存储器缓冲寄存器(Memory Buffer Register,MBR),存放要写入存储器的数据或从存储器中读取的数据。
+
+同理，输入/输出地址存储器(I/O Address Register，简称I/O AR或I/O地址寄存器)用于确定一个特定的输入/输出设备，输入/输出缓冲寄存器(I/O Buffer Register，简称I/O BR或I/O缓冲寄存器)用于在输入/输出模块和处理器间交换数据。 
+
+
+
+内存模块由一组单元组成，这些单元由顺序编号的地址定义。每个单元包含一个二进制数，它可解释为一个指令或数据。输入/输出模块在外部设备与处理器和存储器之间传送数据。输入/输出模块包含内存缓冲区，用于临时保存数据，直到它们被发送出去。
+
+![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/computer_cpu_memory_io.png?raw=true)
+
+
+
+### 计算机打开电源后的执行
+
+在每台计算机上有一块双亲板（在政治因素影响到计算机产业之前，它们曾称为“母版”）。在双亲板上有一个称为基本输入输出系统（Basic Input Output System， BIOS）的程序。在BIOS内有底层I/O软件，包括读键盘、写屏幕、进行磁盘I/O以及其他过程。在计算机启动时，BIOS开始运行。它首先检查所安装的RAM数量、键盘和其他基本设备是否已安装并正常相应。接着，它开始扫描PCIe和PCI总线并找出连在上面的所有设备。即插即用设备也被记录下来。如果现有的设备和系统上一次启动时的设备不同，则新的设备将被配置。然后BIOS通过尝试存储在CMOS存储器中的设备清单决定启动设备。用户可以在系统刚启动之后进入一个BIOS配置程序，对设备清单进行修改。典型的，如果存在CD-ROM（有时是USB），则系统试图从中启动（之前重装系统就是这么操作的）。如果失败，系统将从硬盘启动。启动设备上的第一个扇区被读入内存并执行。这个扇区中包含一个对保存在启动扇区末尾的分区表检查的程序，以确定哪个分区是活动的。然后，从该分区读入第二个启动装载模块。来自活动分区的这个装载模块被读入操作系统，并启动之。 
+
+然后，操作系统询问BIOS，以获得配置信息。对于每种设备，系统检查对应的设备驱动程序是否存在。如果没有，系统要求用户插入含有该驱动程序的CD-ROM（由设备供应商提供）或者从网络上下载驱动程序。一旦有了全部的设备驱动程序，操作系统就将它们调入内核。然后初始化有关表格，创建需要的任何背景进程，并在每个终端上启动登陆程序或GUI。
+
+1. X86 PC开机时CPU处于实模式，开机时会将cs=0xffff，ip=0x0000
+2. 寻址0xFFFF0(ROM BIOS营社区)
+3. 检查RAM、键盘、显示器、磁盘、主板等硬件
+4. 将磁盘0磁道0扇区(操作系统引导扇区)读入0x7c00处
+5. 设置 cs=0x07c0，ip=0x0000开始执行
+
+
+
+## CPU(Central Processing Unit)
+
+CPU 是计算机的大脑，它主要和内存进行交互，从内存中提取指令并执行它。CPU(中央处理器)是一块超大规模的集成电路Integrated Circuit)，是信息处理、程序运行的最终执行单元。其功能主要是解释计算机指令以及处理计算机软件中的数据。从功能方面来看，CPU的内部主要由寄存器，控制器，运算器构成，各部分之间由电流信号相互连通。其中运算器负责算术运算和逻辑运算，控制器负责计算指令的解析，产生各种控制指令，寄存器组用来临时存放参加运算的数据和计算的中间结果。CPU计算结果最终需要写到内存中，内存的存取速度远低于CPU，为提升数据交换速率，CPU内部一般还集成了高速缓存（CACHE）,其中缓存分为一级缓存和二级缓存，一级缓存和CPU速率相当，二级缓存次之。其实在现在一些CPU中，一级缓存也会分为一级数据缓存和一级指令缓存。
+
+由于访问内存获取执行或数据要比执行指令花费的时间长，因此所有的 CPU 内部都会包含一些`寄存器`来保存关键变量和临时结果。因此，在指令集中通常会有一些指令用于把关键字从内存中加载到寄存器中，以及把关键字从寄存器存入到内存中。
+
+
+
+**程序是把寄存器作为对象来描述的**
+
+使用高级语言编写的程序会在编译后转化成机器语言，然后通过CPU内部的寄存器来处理。不同类型的CPU，其内部寄存器的数量，种类以及寄存器存储的数值范围都是不同的。根据功能的不同，我们可以将寄存器大致划分为八类。
+
+**累加寄存器：**存储执行运算的数据和运算后的数据。
+
+**标志寄存器：**存储运算处理后的CPU的状态。
+
+**程序计数器：**存储下一条指令所在内存的地址。
+
+**基址寄存器：**存储数据内存的起始地址。
+
+**变址寄存器：**存储基址寄存器的相对地址。
+
+**通用寄存器：**存储任意数据。
+
+**指令寄存器：**存储指令。CPU内部使用，程序员无法通过程序对该寄存器进行读写操作。
+
+**栈寄存器：**存储栈区域的起始地址。
+
+其中，程序计数器，累加寄存器，标志寄存器，指令寄存器和栈寄存器都只有一个，其他的寄存器一般有多个。
+
+
+
+**计算机执行的原理是: 取指执行   **
+
+处理器执行的程序是由一组保存在存储器中的指令组成的。最简单的指令处理包括两步: 处理器从存储器中一次读(取)一条指令，然后执行每条指令。程序执行是由不断重复的取指令和执行指令的过程组成的。指令执行可能涉及很多操作，具体取决于指令本身。 
+
+在典型的处理器中，程序计数器(Program Counter, PC)保存下一次要取的指令地址。除非出现其它情况，否则处理器在每次取值令后总是递增PC，以便能按顺序取下一条指令(即位于下一个存储器地址的指令)。取到的指令放在处理器的一个寄存器中，这个寄存器称为指令寄存器(Instruction Register,IR)。指令中包含确定处理器将要执行的操作的位，处理器解释指令并执行对应的操作。大体上，这些动作可分为4类:  
+
+- 处理器-存储器:数据可以从处理器传送到存储器，或从存储器传送到处理器。
+- 处理器-I/O:通过处理器和I/O模块间的数据传送，数据可以输出到外部设备，或从外部设备向处理器输入数据。
+- 数据处理:处理器可以执行很多与数据相关的算术操作或逻辑操作。
+- 控制: 某些指令可以改变执行顺序。例如，处理器从地址为149的存储单元中取出一条指令，该指令指向下一条指令应该从地址为182的存储单元中取，这样处理器就会把程序计数器置为182.因此在下一个取指阶段，将从地址182的存储单元而非150的存储单元中取指令。 
+
+
+
+## CPU 指令执行过程
+
+那么 CPU 是如何执行一条条的指令的呢？
+
+几乎所有的冯·诺伊曼型计算机的CPU，其工作都可以分为5个阶段：**取指令、指令译码、执行指令、访存取数、结果写回**。
+
+- `取指令`阶段是将内存中的指令读取到 CPU 中寄存器的过程，程序寄存器用于存储下一条指令所在的地址
+- `指令译码`阶段，在取指令完成后，立马进入指令译码阶段，在指令译码阶段，指令译码器按照预定的指令格式，对取回的指令进行拆分和解释，识别区分出不同的指令类别以及各种获取操作数的方法。
+- `执行指令`阶段，译码完成后，就需要执行这一条指令了，此阶段的任务是完成指令所规定的各种操作，具体实现指令的功能。
+- `访问取数`阶段，根据指令的需要，有可能需要从内存中提取数据，此阶段的任务是：根据指令地址码，得到操作数在主存中的地址，并从主存中读取该操作数用于运算。
+- `结果写回`阶段，作为最后一个阶段，结果写回（Write Back，WB）阶段把执行指令阶段的运行结果数据“写回”到某种存储形式：结果数据经常被写到CPU的内部寄存器中，以便被后续的指令快速地存取；
+
+
+
+## 存储器
+
+在任何一种计算机中，第二种主要部件都是存储器。在理想情况下，存储器应该极为迅速（快于执行一条指令，这样CPU就不会受到存储器的限制），充分大并且非常便宜。但是目前的技术无法同时满足这三个目标。
+
+- 存取时间越快，每“位”的价格越高
+- 容量越大，每“位”的价格越低
+- 容量越大，存取速度越慢
+
+
+
+![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/computer_storage_type.png?raw=true)
+
+于是出现了多级存储器组织结构:
+
+- 寄存器： 最快、最小和最贵的存储器类型由位于处理器内部的寄存器组成。它们用预CPU相同的材料制成，所以和CPU一样快。显然，访问它们是没有时延的。其典型的存储容量是，在32位CPU中为32*32位，而在64位CPU中为64*64位。在这两种情况下，其存储容量都小于1KB。典型情况下，一个处理器包含多个寄存器，某些处理器包含上百个寄存器。
+
+- 高速缓存，它多数由硬件控制。
+
+- 主存：这是存储器系统的主力。主存通常称为随机访问存储器(Random Access Memory，RAM），内存是计算机中主要的内部内部存储器系统。内存中的每个单元位置都有唯一的地址对应，而且大多数机器指令会访问一个或多个内存地址。内存通常是告诉的、容量较小的告诉缓存的扩展。
+
+- 磁盘：磁盘同RAM相比，成本降低了，但是随机访问数据时间也慢了。其低速的原因是因为磁盘是一种机械装置。一个磁盘中有一个或多个金属盘片，他们以一定的速度旋转，从边缘开始有一个机械臂悬横在盘面上，这类似于老式播放塑料唱片的唱片机。
+
+    
+
+    ![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/changpianji.jpg?raw=true)
+
+    有时，还有一些实际上不是磁盘的磁盘，比如固态硬盘（Solid State Disk，SSD）。固态硬盘并没有可以移动的部分，外形也不像唱片那样，并且数据是存储在存储器（闪存）中的。与磁盘唯一的相似之处就是它也存储了大量即使在电源关闭时也不会丢失的数据。
+
+这里要说一下闪存(flash memory)，在便捷式电子设备中，闪存通常作为存储媒介。闪存是数吗相机中的胶卷。是便捷式音乐播放器的磁盘。这仅仅是闪存用途的两项。闪存在速度上介于RAM和磁盘之间。另外，与磁盘存储器不同的是，如果闪存擦除次数过多，就被磨损了。
+
+
+
+
+
+## 内存
+
+
+
+内存包括主存(内存条,基于DRAM(动态RAM))与高速缓存(Cache,基于SRAM(静态RAM，静态RAM速度很快但是成本很高，所以用于在CPU内部充当缓冲))两部分。可能是由于Cache相较内存条容量很小，毕竟内存容量只计内存条大小，加上重要性也不及内存条，一般人或许不知道Cache,所以就忽略了高速缓存Cache，直接将主存--内存条等同了内存吧。计算器内存条采用的是DRAM(动态随机存储器)，即计算机的主存。通常所说的内存容量即指内存条DRAM的大小。
+
+高速缓冲存储器Cache主要是为了解决CPU和主存速度不匹配而设计的。Cache一般由SRAM(静态随机存储器)芯片实现，它的存取速度接近CPU，快于DRAM，存储容量小于DRAM。它比主存的优先级高，CPU存取信息时优先访问Cache，找不到的话再去主存DRAM中找，同时把信息周围的数据块从主存复制到Cache中。 现代计算机系统基本都采用Cache-主存-辅存(即外存储器)三级存储系统。其中CPU可直接访问Cache和主存，辅存则通过主存与CPU交换信息。
+
+
+
+![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/memory_type.png?raw=true)
+
+
+
+### 主存的分类
+
+- RAM(Random-access memory) 
+
+    随机存取存储器，一般使用动态半导体存储器件（DRAM），对于CPU来说，RAM是主要存放数据和程序的地方，所以也叫做“主存”，因为CPU工作的速度比RAM的读写速度快，所以CPU读写RAM时需要花费时间等待，这样就使CPU的工作速度下降。人们为了提高CPU读写程序和数据的速度，在RAM和CPU之间增加了高速缓存（Cache）部件。Cache的内容是随机存储器（RAM）中部分存储单元内容的副本
+
+- ROM(Read-Only Memory)
+
+    只读存储器，出厂时其内容由厂家用掩膜技术写好，只可读出，但无法改写。信息已固化在存储器中，一般用于存放系统程序BIOS和用于微程序，断电也没有关系，放ROM的数据一辈子都不会变
+
+
+
+### 缓存
+
+位于CPU与内存之间的临时存储器，它的容量比内存小的多但是交换速率却比内存要快得多。缓存的出现主要是为了解决CPU运算速率与内存读写速率不匹配的矛盾，缓存往往使用的是RAM，L1　Cache(一级缓存)是CPU第一层高速缓存，一般L1缓存的容量通常在32—256KB，L1分为数据Cache,指令Cache,L2　Cache(二级缓存)是CPU的第二层高速缓存，分内部和外部两种芯片，内部的芯片二级缓存运行速率与主频相同，而外部的二级缓存则只有主频的一半,缓存只是内存中少部分数据的复制品。二级缓存是比一级缓存速率更慢，容量更大的内存，主要就是做一级缓存和内存之间数据临时交换的地方用。为了适应速率更快的处理器。
+
+
+
+![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/cpu_cache_memory.png?raw=true)
+
+
+
+缓存基本上都是采用SRAM存储器，SRAM是英文Static  RAM的缩写，它是一种具有静态存取功能的存储器，不需要刷新电路即能保存它内部存储的数据。不像DRAM内存那样需要刷新电路，每隔一段时间，固定要对DRAM刷新充电一次，否则内部的数据即会消失，因此SRAM具有较高的性能，但是SRAM也有它的缺点，即它的集成度较低，相同容量的DRAM内存可以设计为较小的体积，但是SRAM却需要很大的体积，这也是不能将缓存容量做得太大的重要原因。它的特点归纳如下：优点是节能、速率快、不必配合内存刷新电路、可提高整体的工作效率，缺点是集成度低、相同的容量体积较大、而且价格较高，只能少量用于关键性系统以提高效率。
+
+
+
+缓存的工作原理是当CPU要读取一个数据时，首先从CPU缓存中查找，找到就立即读取并送给CPU处理；没有找到，就从速率相对较慢的内存中读取并送给CPU处理，同时把这个数据所在的数据块调入缓存中，可以使得以后对整块数据的读取都从缓存中进行，不必再调用内存。正是这样的读取机制使CPU读取缓存的命中率非常高，一般把静态RAM缓存叫一级缓存，而把后来增加的动态RAM叫二级缓存。
+
+
+
+
+
+
+
+## 系统软件和应用软件
+
+
+
+- 系统软件是指控制和协调计算机以及外部设备，支持应用软件开发和运行的系统，是无需用户干预的各种程序的集合。主要功能是调度、监控和维护计算机系统。例如: 操作系统和一系列的基本工具(编译器、数据库管理、存储器格式化、用户身份验证、网络连接)。
+- 应用软件是和系统软件相对的，是用户可以使用的各种程序设计语言，以及用各种程序设计语言编译的应用程序的集合，分为应用软件包和用户程序。例如:互联网软件、多媒体软件、协作软件等。 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/OperatingSystem/2.\350\277\233\347\250\213.md" "b/OperatingSystem/2.\350\277\233\347\250\213.md"
new file mode 100644
index 00000000..cad290fc
--- /dev/null
+++ "b/OperatingSystem/2.\350\277\233\347\250\213.md"
@@ -0,0 +1,303 @@
+# 1.进程
+
+
+
+狭义定义：进程是正在运行的程序的实例（an instance of a computer program that is being executed）。
+
+广义定义：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是[操作系统](https://baike.baidu.com/item/操作系统/192)动态执行的[基本单元](https://baike.baidu.com/item/基本单元)，在传统的[操作系统](https://baike.baidu.com/item/操作系统)中，进程既是基本的[分配单元](https://baike.baidu.com/item/分配单元)，也是基本的执行单元。
+
+进程的概念主要有两点：第一，进程是一个实体。每一个进程都有它自己的地址空间，一般情况下，包括[文本](https://baike.baidu.com/item/文本)区域（text region）、数据区域（data region）和[堆栈](https://baike.baidu.com/item/堆栈)（stack region）。文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分配的内存；堆栈区域存储着活动过程调用的指令和本地变量。第二，进程是一个“执行中的程序”。程序是一个没有生命的实体，只有[处理](https://baike.baidu.com/item/处理)器赋予程序生命时（操作系统执行之），它才能成为一个活动的实体，我们称其为[进程](https://baike.baidu.com/item/进程)。
+
+
+
+进程是60年代初首先由[麻省理工学院](https://baike.baidu.com/item/麻省理工学院)的[MULTICS系统](https://baike.baidu.com/item/MULTICS系统)和IBM公司的[CTSS](https://baike.baidu.com/item/CTSS)/360系统引入的。 [2] 
+
+进程是一个具有独立功能的程序关于某个数据集合的一次运行活动。它可以申请和拥有系统资源，是一个动态的概念，是一个活动的实体。它不只是程序的[代码](https://baike.baidu.com/item/代码)，还包括当前的活动，通过[程序计数器](https://baike.baidu.com/item/程序计数器)的值和处理[寄存器](https://baike.baidu.com/item/寄存器)的内容来表示。
+
+进程由三部分组成: 
+
+- 一段可执行的程序
+- 程序所需要的相关数据(变量、工作空间、缓冲区等)
+- 程序的执行上下文
+
+最后一部分是根本。执行上下文(execution context)又称为进程状态(process state)，是操作系统用来管理和控制进程所需的内部数据。这种内部信息和进程是分开的，因为操作系统信息不允许被进程直接访问。上下文包括操作系统管理进程及处理器正确执行进程所需的所有信息，包括各种处理器寄存器的内容，如程序计数器和数据寄存器。它还包括操作系统使用的信息，如进程优先级及进程是否在等待I/O事件的完成。
+
+
+
+在任何多道程序设计系统中，CPU由一个进程快速切换至另一个进程，使每个进程各运行几十或几百毫秒。严格来说，在某一个瞬间，CPU只能运行一个进程。但在1秒钟内，它可能运行多个进程，这样就产生并行的错觉。CPU在各进程之间来回切换，这种快速的切换称为多道程序设计。
+
+## 多道程序设计模型
+
+采用多道程序设计可以提高CPU利用率。严格地说，如果进程用于计算的平均时间是进程在内存中停留时间的20%，且内存中同时有5个进程，则CPU将一直满负载运行。然而，这个模型在现实中过于乐观，因为它假设这5个进程不会同时等待I/O。
+
+更好的模型是从概率的角度来看CPU的利用率。假设一个进程等待I/O操作的时间与其停留在内存的时间比为p。当内存中同时有n个进程时，则所有n个进程都在等待I/O（此时CPU空转）的概率为p的n次方。
+
+![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/duodao_module.png?raw=true)
+
+从上图中可以看到，如果进程花费80%的时间等待I/O，为使CPU的浪费低于10%，至少要有10个进程同时在内存中。
+
+
+
+## 进程的特性
+
+1. 动态性
+
+    动态性是进程的最基本特征，它是程序执行过程，它是有一定的生命期。它由创建而产生、由调度而执行，因得不到资源而暂停，并由撤消而死亡。而程序是静态的，它是存放在介质上一组有序指令的集合，无运动的含义。
+
+2. 并发性
+
+    并发性是进程的重要特征，同时也是OS的重要特征。并发性指多个进程实体同存于内存中，能在一段时间内同时运行。而程序是不能并发执行。
+
+3. 独立性
+
+    进程是一个能独立运行的基本单位，即是一个独立获得资源和独立调度的单位，而程序不作为独立单位参加运行。
+
+4. 异步性
+
+    进程按各自独立的不可预知的速度向前推进，即进程按异步方式进行，正是这一特征，将导致程序执行的不可再现性，因此OS必须采用某种措施来限制各进程推进序列以保证各程序间正常协调运行。
+
+
+
+进程控制块 (Process Control Block, PCB) 描述进程的基本信息和运行状态，所谓的创建进程和撤销进程，都是指对 PCB 的操作。
+
+## 进程的状态
+
+
+
+- 就绪态：进程做好了准备，只要有机会就开始执行
+- 运行态：进程正在执行
+- 堵塞/等待态：进程在某些事件发生前补鞥呢执行，如I/O操作完成
+- 新建态：刚刚创建的进程，操作系统还未把他加入可执行进程组，它通常是进程控制块已经创建但还未加载到内存中的新进程
+- 退出态：操作系统从可执行进程组中释放出的进程，要么它自身已停止，要么它因某种原因被取消
+
+### 进程由哪几部分组成？
+
+进程是程序的一次运行过程，它是由程序段、数据段和进程控制块 PCB 组成的一个实体，其中：
+
+- 程序段：对应程序的操作代码部分，用于描述进程所需要完成的功能。
+- 数据段：对应程序执行时所需要的数据部分，包括数据，堆栈和工作区。
+- 进程控制块：记录了进程运行时所需要的全部信息，它是进程存在的唯一标识，与进程一一对应。
+
+##### 进程控制块
+
+进程执行的任意时刻，都可由如下元素来表征:  
+
+- 标识符:与进程相关的唯一标识符，用来区分其他进程
+- 状态:若进程正在执行，则进程处于运行态
+- 优先级:相对于其他进程的优先顺序
+- 程序计数器:程序中即将执行的下一条指令的地址
+- 内存指针:包括程序代码和进程相关数据的指针，以及与其他进程共享内存块的指针
+- 上下文数据:进程执行时处理器的寄存器中的数据
+- I/O状态信息:包括显式I/O请求、分配给进程的I/O设备和被进程使用的文件列表等
+- 记账信息:包括处理器时间总和、使用的时钟数总和、时间限制、及账号等
+
+上述列表信息存放在一个被称为进程控制块(process control block)的数据结构中，控制块由操作系统创建和管理。进程控制块（PCB）是进程实体的重要组成部分，它记录了操作系统所需要的、用于描述进程情况及控制进程所需要的全部信息。原来不能独立运行的程序或数据，通过 PCB 就可以成为一个可以独立运行的基本单位。系统通过 PCB 感知进程的存在，并对其进行有效管理和控制。系统创建一个新进程时，为它建立一个  PCB；当进程结束时，系统又收回其 PCB，该进程也随之消亡。简单的总结就是进程控制块主要包括下述四个方面的信息：
+
+1. 进程标识符信息：用于标识、区分一个进程，通常有外部标识符和内部标识符两类。外部标识符通常是由字母、数字所组成的一个字符串，用户或其他进程访问该进程时使用。内部标识符是操作系统为每个进程赋予的唯一一个整数，是作为内部识别而设置的。
+
+2. 进程调度信息：用于描述与进程调度有关的状态信息，包括进程状态、进程优先权、调度信息和等待事件等。进程状态指明进程当前的状态，作为进程调度和对换时的依据；进程优先权说明进程使用 CPU 的优先级别，其中优先权高的进程将优先获得  CPU；调度信息描述与进程调度算法相关的信息，如进程等待时间、已运行的时间等；等待事件是指进程由运行态转变为阻塞态时所等待发生的事件。
+
+3. CPU 状态信息：用于保留进程运行时 CPU 的各种信息，使得进程暂停运行后，下次重新运行时能从上次停止的地方继续运行。CPU  状态信息通常包含通用寄存器、控制和状态寄存器、用户栈指针等。CPU  状态字记载了程序执行的状态信息，如条件码、外中断屏蔽标识、执行状态（核心态或用户态）标识等。
+
+4. 进程控制信息(process control information)：包括进程资源、控制机制等一些进程运行时所需要的信息，如:     
+    - 程序和数据地址：该进程的程序和数据所在的内存和外存地址，以便该进程在次运行时，能够找到程序和数据。
+    - 进程同步和通信机制：实现进程同步和通信时所采用的机制，如消息队列指针、信号量等。
+    - 资源清单：除 CPU 外，进程所需的全部资源和已经分配到的资源。
+    - 链接指针：用于指向该进程所在队列的下一个进程的 PCB 首地址。
+
+
+
+## 进程创建
+
+操作系统决定创建一个新进程时，会按如下步骤操作:  
+
+1. 为新进程分配一个唯一的进程标识符。此时，主进程表中会添加一个新表项，每个进程一个表项。
+2. 为进程分配空间。这包括进程映像中的所有元素。因此，操作系统必须知道私有用户地址空间(程序和数据)和用户栈需要多少空间。
+3. 初始化进程控制块。进程表示部分包括进程id和其他相关的id，如父进程id等。处理器状态信息部分的多数项目通常初始化为0，但程序计数器(置为程序入口点)和系统栈指针(定义进程栈边界)除外。进程控制信息部分根据标准的默认值和该进程请求的特性来初始化。例如，进程的状态通常初始化为就绪或就绪/挂起。
+4. 设置正确的链接。例如，若操作系统将每个调度队列都维护为一个链表，则新进程必须放在继续或就绪/挂起链表中。
+5. 创建或扩充其他数据结构。例如，操作系统可因编制账单和/或评估性能，为每个进程维护一个记账文件。
+
+
+
+## 进程切换
+
+
+
+表面上看，进程切换很简单。在某个时刻，操作系统中断一个正在运行的进程，将另一个进程置于运行模式，并把控制权交给后者。然而，这会引发若干个问题。首先，什么事件触发了进程的切换？ 其次，必须认识到模式切换和进程切换键的区别。
+
+
+
+进程切换可在操作系统从当前正运行进程中获得控制权的任何时刻发生。首先考虑系统终端。实际上，大多数操作系统都会区分两种系统终端：一种称为终端，另一种称为陷阱。前者与当前正运行进程无关的某种外部事件相关，如完成一次I/O操作。后者与当前正运行进程产生的错误或异常条件相关，如非法的文件访问。对于普通终端，控制权首先转给终端处理器，终端处理器完成一些基本的辅助工作后，再将控制权给与已发生的特定中断相关的操作系统进程。示例如下:  
+
+- 时钟中断：操作系统确定当前正运行进程的执行时间是否已超过最大允许时间段(时间片，即进程中断前可以执行的最大时间段)。若超过，进程就切换到就绪态，并调入另一个进程。
+- I/O中断：操作系统确定是否已发生I/O活动。若I/O活动是一个或多个进程正在等待的事件，则操作系统就把所处于堵塞态的进程转换为就绪态( 堵塞/挂起态进程转换为就绪/挂起态)。操作系统必须决定是继续执行当前处于运行态的进程，还是让具有高优先级的就绪态进程抢占这个进程。
+- 内存失效：处理器遇到一个引用不在内存中的字的虚存地址时，操作系统就必须从外村中把包含这一引用的内存块(页或段)调入内存。发出调入内存块的I/O请求后，内存失效进程将进入堵塞态。操作系统然后切换进程，恢复另一个进程的执行。期望的块调入内存后，该进程置为就绪态。
+
+对于陷阱(trap)，操作系统则确定错误或异常条件是否致命。致命时，当前正运行进程置为退出态，并切换进程。不致命时，操作系统的动作将取决于错误的性质和操作系统的设计，操作系统可能会尝试恢复程序，或简单的通知用户。操作系统可能会切换进程或继续当前运行的进程。 
+
+
+
+## 并发
+
+在单处理器多道程序设计系统中，进程会被交替的执行，因而表现出一种并发执行的外部特征。即使不能实现真正的并行处理，并且在进程间来回切换也需要一定的开销，但是交替执行在处理效率和程序结构上还是会带来很多好处。在多处理系统中，不仅可以交替的执行进程，而且可以重叠执行进程。
+
+进程的相对执行速度不可预测，它取决于其他进程的活动、操作系统处理中断的方式以及操作系统的调度策略，这样就会有以下问题: 
+
+1. 全局资源的共享充满了危险。例如，如果两个进程都使用同一个全局变量，并且都对该变量执行读写操作，那么不同的读写执行顺序是非常关键的。 
+2. 操作系统很难对资源进行最优化分配。例如，进程A可能请求使用一个特定的I/O通道，并获取控制权，但它在使用这个通道前已被堵塞，而操作系统仍然锁定这个通道以防止其他进程使用，这是最难以令人满意的。事实上，这种情况有可能导致死锁。
+3. 定位程序设计错误非常困难。这是因为结果通常是不确定的和不可再现的。
+
+所以由于并发带来的这些问题，操作系统必须关注的问题如下: 
+
+1. 操作系统必须能够跟踪不同的进程，这可以使用进程控制块来实现。
+2. 操作系统必须为每个活动进程分配和释放各种资源。
+3. 操作系统必须保护每个进程的数据和物理资源，避免其他进程的无意干扰。
+4. 一个进程的功能和输出结果必须与执行速度无关。
+
+
+
+### 互斥的要求
+
+1. 必须强制实施互斥。在于相同资源或共享对象的临界区有关的所有进程中，一次只允许一个进程进入临界区。
+2. 一个在非临界区停止的进程不能干啥其他进程。
+3. 绝不允许出现需要访问临界区的进程被无限延迟的情况，即不会死锁或饥饿。
+4. 没有进程在临界区中时，任何需要进入临界区的进程必须能够立即进入。
+5. 对相关进程的执行速度和处理器的数量没有任何要求和限制。
+6. 一个进程驻留在临界区中的时间必须是有限的。
+
+
+
+## 进程间通信(Inter Process Communication，IPC)
+
+
+
+进程间的信息交换，具体内容分为：控制信息交换和数据交换，控制信息的交换为低级通信，数据的交换为高级通信。
+
+
+
+高级通信方式
+
+- 共享存储系统
+
+多台服务器访问同一个存储设备的同一分区
+
+- 消息传递系统
+
+进程与其它的进程进行通信而不必借助共享数据，通过互相发送和接收消息，建立一条通信链路。
+
+- 管道通信
+
+发送进程以字符流形式将大量数据送入管道，接收进程可从管道接收数据，二者利用管道进行通信，管道是单向的、先进先出的，它把一个进程的输出和另一个进程的输入连接在一起。一个进程（写进程）在管道的尾部写入数据，另一个进程（读进程）从管道的头部读出数据。每次只有一个进程能够真正地进入管道，其他的只能等待。
+
+管道分为无名管道和命名管道，前者用于父子进程通信，后者用于任意进程通信。
+
+
+
+**操作系统最底层的就是调度程序**，在它上面有许多进程。所有关于中断处理、启动进程和停止进程的具体细节都隐藏在调度程序中。事实上，调度程序只是一段非常小的程序。
+
+
+
+### 进程的实现
+
+操作系统为了执行进程间的切换，会维护着一张表格，这张表就是 `进程表(process table)`。每个进程占用一个进程表项。该表项包含了进程状态的重要信息，包括程序计数器、堆栈指针、内存分配状况、所打开文件的状态、账号和调度信息，以及其他在进程由运行态转换到就绪态或阻塞态时所必须保存的信息，从而保证该进程随后能再次启动，就像从未被中断过一样。
+
+
+
+**操作系统最底层的就是调度程序**，在它上面有许多进程。所有关于中断处理、启动进程和停止进程的具体细节都隐藏在调度程序中。事实上，调度程序只是一段非常小的程序。
+
+
+
+操作系统为了执行进程间的切换，会维护着一张表格，这张表就是 `进程表(process table)`。每个进程占用一个进程表项。该表项包含了进程状态的重要信息，包括程序计数器、堆栈指针、内存分配状况、所打开文件的状态、账号和调度信息，以及其他在进程由运行态转换到就绪态或阻塞态时所必须保存的信息，从而保证该进程随后能再次启动，就像从未被中断过一样。
+
+
+
+## 进程调度
+
+进程调度就是处理器调度(上下文切换)
+
+### 调度级别
+
+- 高级调度
+
+作业调度,把后备作业调入内存运行
+
+- 中级调度
+
+在虚拟存储器中引入，在内，外存交换区进行进程对换
+
+- 低级调度
+
+进程调度，把就绪队列里的某个进程获得CPU执行权
+
+### 调度方式
+
+- 可剥夺
+
+    当一个进程运行时，基于某种原则，剥夺已经分配给它的处理器，将之分配给其他进程，原则有：优先权原则，短进程优先原则，时间片原则。
+
+- 不可剥夺
+
+一单处理器分配给某进程，遍让它一直运行下去，直到进程完成或者发生某种时间而阻塞，才分配给其他进程。
+
+### 调度算法
+
+- 先进先出
+
+按照进入就绪队列的进程顺序，不加其他条件干涉
+
+- 短进程优先
+
+优先选出就绪队列中CPU执行时间最短的进程，例如：就绪队列有4个进程P1，P2，P3，P4，执行时间为：16,12,4,3 按照短进程优先，则周转时间(从进程提交到进程完成的时间间隔)分别为：35,19,7,3
+平均周转时间：16，平均周转时间越小，调度性能越好
+
+- 轮转法
+    - 简单轮转： 就绪进程按FIFO排队，按照一定时间间隔让处理机分配给队列中的进程，就绪队列中**所有队列均可获得一个时间片的处理器运行**
+    - 多级队列： 让系统中所有进程分成若干类，每类一级
+
+## 死锁
+
+两个以上的进程相互请求对方已经占有的资源，导致无限期的等待。
+
+### 产生条件
+
+- 互斥条件 
+- 请求保持
+- 不可剥夺
+- 环路条件
+
+### 解决方法
+
+- 鸵鸟策略：不理睬
+- 预防策略：破坏产生条件中任意一个
+- 避免策略： 精心分配资源，动态避免死锁
+- 检测与解除死锁：系统自动检测，并且解除
+
+
+
+
+
+
+
+## 进程和线程的区别
+
+线程比进程更轻量级，所以它们比进程更容易（更快）创建，也更容易撤销。在许多系统中，创建一个线程比创建一个进程要快10~100倍。
+
+
+
+进程和线程的主要差别在于它们是不同的操作系统资源管理方式。进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其它进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程之间没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序要比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。
+
+1. 简而言之,一个程序至少有一个进程,一个进程至少有一个线程。
+2. 线程的划分尺度小于进程，使得多线程程序的并发性高。
+3. 另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。
+4. 线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
+5. 从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md" "b/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
new file mode 100644
index 00000000..a4b40e39
--- /dev/null
+++ "b/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
@@ -0,0 +1,277 @@
+# 3. 内存管理
+
+常用概念: 
+
+- 页框：内存中固定长度的快
+- 页：固定长度的数据库，存储在二级存储器中（如磁盘）。数据页可以临时赋值到内存的页框中。
+- 段：变长数据块，存储在二级存储器中。整个段可以临时复制到内存的一个可用区域中（分段），或可以将一个段分为许多页，然后将每页单独复制到内存中（分段与分页相结合）
+
+
+
+内存管理的主要操作是处理器把程序装入内存中执行。内存管理的功能有：
+1、内存空间的分配与回收：由操作系统完成主存储器空间的分配和管理，使程序员摆脱存储分配的麻烦，提高编程效率。
+2、地址转换：在多道程序环境下，程序中的逻辑地址与内存中的物理地址不可能一致，因此存储管理必须提供地址变换功能，把逻辑地址转换成相应的物理地址。
+3、内存空间的扩充：利用虚拟存储技术或自动覆盖技术，从逻辑上扩充内存。
+4、存储保护：保证各道作业在各自的存储空间内运行，互不干扰。
+
+
+
+进程对应的内存空间中所包含的5种不同的数据区：  
+
+- 代码段(code segment):又称文本段，用来存放指令，运行代码的一块内存空间。此空间大小在代码运行前就已经确定。内存空间一般属于只读，某些架构的代码也允许可写。
+
+- 数据段(data segment): 存储初始化的全局变量和初始化的static变量。数据段中的数据的生存期是随程序持续性(随进程持续性):进程创建就存在，进程死亡就消失。
+
+- BSS段(bss segment)：存储未初始化的全局变量和未初始化的static变量。bss段中数据的生存期随进程持续性。bss段中的数据一般默认为0.
+- rodata段:只读数据 比如 printf 语句中的格式字符串和开关语句的跳转表。也就是常量区。例如，全局作用域中的 const int ival = 10，ival  存放在 .rodata 段；再如，函数局部作用域中的 printf("Hello world %d\n", c); 语句中的格式字符串  "Hello world %d\n"，也存放在 .rodata 段。
+
+- 堆（heap）：堆是用于存放进程运行中被动态分配的内存段，它的大小并不固定，可动态扩张或缩减。当进程调用malloc、realloc等函数分配内存时，新分配的内存就被动态添加到堆上（堆被扩张）；当利用free等函数释放内存时，被释放的内存从堆中被剔除（堆被缩减）
+
+- 栈(stack):栈是用户存放程序临时创建的局部变量，也就是说我们函数括弧“{}”中定义的变量（但不包括static声明的变量，static意味着在数据段中存放变量）。栈的生存期随代码块持续性，代码块运行就给你分配空间，代码块结束就自动回收空间。除此以外，在函数被调用时，其参数也会被压入发起调用的进程栈中，并且待到调用结束后，函数的返回值也会被存放回栈中。由于栈的先进先出特点，所以栈特别方便用来保存/恢复调用现场。从这个意义上讲，我们可以把堆栈看成一个寄存、交换临时数据的内存区。
+
+上述几种内存区域中数据段、BSS和堆通常是被连续存储的——内存位置上是连续的，而代码段和栈往往会被独立存放。有趣的是，堆和栈两个区域关系很“暧昧”，他们一个向下“长”（i386体系结构中栈向下、堆向上），一个向上“长”，相对而生。但你不必担心他们会碰头，因为他们之间间隔很大（到底大到多少，你可以从下面的例子程序计算一下），绝少有机会能碰到一起。
+
+
+
+## 内存的演变
+
+在早些的操作系统中，并没有引入内存抽象的概念。程序直接访问和操作的都是物理内存，内存的管理也非常简单，除去操作系统所用的内存之外，全部给用户程序使用，想怎么折腾都行，只要别超出最大的容量。这种内存操作方式使得操作系统中存在多进程变得完全不可能，比如MS-DOS，你必须执行完一条指令后才能接着执行下一条。如果是多进程的话，由于直接操作物理内存地址，当一个进程给内存地址1000赋值后，另一个进程也同样给内存地址赋值，那么第二个进程对内存的赋值会覆盖第一个进程所赋的值，这回造成两条进程同时崩溃。随着计算机技术发展，要求操作系统支持多进程的需求，所谓多进程，并不需要同时运行这些进程，只要它们都处于 ready  状态，操作系统快速地在它们之间切换，就能达到同时运行的假象。每个进程都需要内存，Context Switch  时，之前内存里的内容怎么办？简单粗暴的方式就是先 dump 到磁盘上，然后再从磁盘上 restore 之前 dump  的内容（如果有的话），但效果并不好，太慢了！那怎么才能不慢呢？把进程对应的内存依旧留在物理内存中，需要的时候就切换到特定的区域。这就涉及到了内存的保护机制，毕竟进程之间可以随意读取、写入内容就乱套了，非常不安全。因此操作系统需要对物理内存做一层抽象，也就是「地址空间」(Address Space)，一个进程的地址空间包含了该进程所有相关内存，比如 code / stack / heap。一个 16 KB  的地址空间可能长这样：
+
+![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/memory_1.jpg?raw=true)
+
+Stack 和 Heap 中间有一块 free space，即使没有用，也被占着，那如何才能解放这块区域呢，进入虚拟内存。
+
+
+
+Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自互不干涉的进程地址空间。该空间是块大小为4G的线性虚拟空间，用户所看到和接触到的都是该虚拟地址，无法看到实际的物理内存地址。利用这种虚拟地址不但能起到保护操作系统的效果（用户不能直接访问物理内存），而且更重要的是，用户程序可使用比实际物理内存更大的地址空间（具体的原因请看硬件基础部分）。
+
+在讨论进程空间细节前，这里先要澄清下面几个问题：
+
+l     第一、4G的进程地址空间被人为的分为两个部分——用户空间与内核空间。用户空间从0到3G（0xC0000000），内核空间占据3G到4G。用户进程通常情况下只能访问用户空间的虚拟地址，不能访问内核空间虚拟地址。只有用户进程进行系统调用（代表用户进程在内核态执行）等时刻可以访问到内核空间。
+
+l     第二、用户空间对应进程，所以每当进程切换，用户空间就会跟着变化；而内核空间是由内核负责映射，它并不会跟着进程改变，是固定的。内核空间地址有自己对应的页表（init_mm.pgd），用户进程各自有不同的页表。
+
+l     第三、每个进程的用户空间都是完全独立、互不相干的。不信的话，你可以把上面的程序同时运行10次（当然为了同时运行，让它们在返回前一同睡眠100秒吧），你会看到10个进程占用的线性地址一模一样。
+
+
+
+![](https://imgconvert.csdnimg.cn/aHR0cHM6Ly9pbWFnZXMyMDE3LmNuYmxvZ3MuY29tL2Jsb2cvMTMxMTQxMi8yMDE4MDIvMTMxMTQxMi0yMDE4MDIxNTEyMjY1NDM1OS0xNDcxMTE4NzM4LnBuZw?x-oss-process=image/format,png)
+
+
+
+### 固定分区
+
+
+
+大多数内存管理方案都假定操作系统占据内存中的某些固定部分，而内存中的其余部分则供多个用户进程使用。管理用户内存空间的最简单的方案就是对它分区，以形成若干边界固定的区域。
+
+固定分区分为两种： 
+
+- 使用大小相等的分区：此时小于等于分区大小的任何进程都可以装入任何可用的分区中。若所有分区都已满且没有进程处于就绪态或运行态，则操作系统可以换出一个进程的所有分区，并装入另一个进程，使得处理器有事可做。但是大小相等的分区有两个难点： 
+
+    - 程序可能太大而不能放到一个分区中。此时程序员必须使用覆盖技术设计程序，使得任何时候该程序只有一部分需要放到内存中。当需要的模块不在时，用户程序必须把这个模块装入程序的分区，覆盖该分区中的任何程序和数据。
+
+    - 内存的利用率非常低。任何程序，急事很小，都需要占据一个完整的分区。由于装入的数据块小于分区大小，因而导致分区内部存在空间浪费，这种现象称为内部碎片(internal fragmentation)。
+
+- 使用大小不等的分区：大小不等的分区可以缓解上面的两个问题，但是不能完全解决。
+
+虽然大小不等的分区带来了一定的灵活性，但是分区的数量在系统生成阶段已经确定，因而限制了系统中活动（未挂起）进程的数量。而且由于分区大小是在系统生成阶段事先设置的，因而小作业不能有效的利用分区空间。
+
+
+
+### 动态分区
+
+为了克服固定分区的确定，提出了动态分区。对于动态分区，分区长度和数量是可变的。程序装入内存时，系统会给它分配一块与其所需容量完全相等的内存空间。但是对于一个64MB的内存，如果装入前三个进程已经占用了很大一部分，剩下的部分对于第四个进程来说又太小，这样在内存的末尾就剩下一个“空洞”。而等第二个进程结束后腾出的足够的空间来装入第四个进程，但是由于第四个进程比第二个进程小，所有这里又形成了另一个小"空洞"。这样最终在内存中就会形成许多小空洞。随着时间的推移，内存中形成了越来越多的碎片，内存的利用率随之下降。这种现象称为外部碎片(external fragmentation)，指在所有分区外的存储空间变成了越来越多的碎片，这与前面所讲的内部碎片正好对应。 
+
+客服外部碎片的一种技术就是压缩(compaction)。操作系统不时的移动进程，使得进程占用的空间连续，并使所有空闲空间连成一片。但是压缩的困难之处在于，它是一个非常费时的过程，且会浪费处理器时间。
+
+
+
+### 伙伴系统
+
+固定分区和动态分区方案都有缺陷。固定分区方案限制了活动进程数量，且如果可用分区的大小与进程大小很不匹配，那么内存空间的利用率会非常低。动态分区的维护特别复杂，并且会引入进行压缩的额外开销。更有吸引力的一种折中方案是伙伴系统。 
+
+
+
+### 重定位
+
+
+
+在大小相等的分区中一个进程在其声明周期中可能占据不同的分区。首次创建一个进程映像时，它被装入内存中的摸个分区。以后该进程可能被换出，当它再次被换入时，可能被指定到与上一次不同的分区中。动态分区也存在同样的情况，压缩后内存中的进程也可能发生移动。因此，进程访问（指令和数据单元）的位置不是固定的。进程被换入或在内存中移动时，指令和数据单元的位置也发生变化。为了解决这个问题，需要区分几种地址类型： 
+
+- 逻辑地址（logical address）是指与当前数据再内存中的物理分配地址无关的访问地址，在执行对内存的访问之前必须把它转换为物理地址。
+- 相对地址（relative address）是逻辑地址的一个特例，他是相对于某些已知点（通常是程序的开始处）的存储单元。
+- 物理地址（physical address）或绝对地址是数据在内存中的实际位置。
+
+系统采用运行时动态加载的方式把使用相对地址的程序加载到内存。通常情况下，被加载进程中所有内存访问都相对于程序的开始点。因此，在执行包括这类访问的指令时，需要有把相对地址转换为物理内存地址的硬件机制。这类地址转换就需要一个特殊的处理器寄存器（基址寄存器），其内容是程序在内存中的起始地址。还有一个界限寄存器指明程序的终止位置。
+
+
+
+### 分页
+
+大小不等的固定分区和大小可变的分区技术在内存的使用上都是低效的，前者会产生内部碎片，后者会产生外部碎片。但是，如果内存被划分成大小固定、相等的块，切块相对比较小，每个进程也被分成同样大小的小块，那么进程中称为页的块可以分配到内存中称为页框的可用块。这样在使用分页技术时，每个进程在内存中浪费的空间，仅仅是进程最后一页的一小部分形成的内部碎片。没有任何外部碎片。
+
+这样操作系统需要为每个进程维护一个页表（page table）。页表给出了该进程的每页所对应页框的位置。在程序中每个逻辑地址包括一个页号和该页中的偏移量。在分页中，逻辑地址到物理地址的转换仍然由处理器硬件完成，给出逻辑地址（页号，偏移量）后，处理器使用页表产生物理地址（页框号，偏移量）。
+
+
+
+![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/page_memory_1.png?raw=true)
+
+采用分页技术的分区相当小，一个程序可以占据多个分区，并且这些分区不需要是连续的。
+
+为了使分页方案更加方便，规定页和页框的大小必须是2的幂，以便容易的表示出相对地址。
+
+
+
+### 分段
+
+细分用户程序的另一种可选方案是分段。采用分段技术，可以把程序和与其相关的数据划分到几个段（fragment）中。尽管短有最大长度限制，但并不要求所有程序的所有段的长度都相等。和分页一样，采用分段技术时的逻辑地址也是由两部分组成：段号和偏移量。 
+
+由于使用大小不等的段，分段类似于动态分区。在未采用覆盖方案或使用虚存的情况下，为执行一个程序，需要把它的所有段都装入内存。与动态分区不同的是，在分段方案中，一个程序可以占据多个分区，并且这些分区不要求是连续的。分段消除了内部碎片，但是和动态分区一样，他会产生外部碎片。不过由于进程被分成多个小块，因此外部碎片也会很小。
+
+采用大小不等的段的另一个结果是，逻辑地址和物理地址间不再是简单的对应关系。类似于分页，在简单的分段方案中，每个进程都有一个段表，系统也会维护一个内存中的空闲块列表。每个段表都必须给出相应段在内存中的起始地址，还必须指明段的长度，以确保不会使用无效地址。
+
+
+
+
+
+分页和分段的两个特点: 
+
+- 进程中的所有内存访问的都是逻辑地址，这些逻辑地址会在运行时动态地址转换为物理地址。这意味着一个进程可被换入或换出内存，因此进程可在执行过程中的不同时刻占据内存中的不同区域。
+- 一个进程可划分为许多块（页和段），在执行过程中，这些块不需要连续的位于内存中。动态运行时地址转换和页表或段表的使用使得这一点成为可能。
+
+由于上面这两个特点的存在，那么在一个进程的执行过程中，该进程不需要所有页或段都在内存中。如果内存中保存有待取的下一条指令所在块（段或页）及待访问的下一个数据单元所在块，那么执行至少可以暂时继续下去。我们用术语“块”来表示页或段。处理器在需要访问一个不在内存中的逻辑地址时，会产生一个中断，这表明出现了内存访问故障。操作系统会把被中断的进程置于堵塞态。要继续执行这个进程，操作系统必须把包含引发访问故障的逻辑地址的进程块读入内存。为此操作系统产生一个磁盘I/O读请求。产生I/O请求后，在执行磁盘I/O期间，操作系统可以调度另一个进程运行。在需要的块读入内存后，产生一个I/O中断，控制权交回给操作系统，而操作系统则把由于缺少该块而被堵塞的进程置为就绪态。这样的话就会有两种提高系统利用率的方法: 
+
+- 在内存中保留多个进程。由于对任何特定的进程都仅装入它的某些块，因此有足够的空间来放置更多的进程。这样，在任何时刻这些进程中至少有一个处于就绪态，于是处理器就得到了更有效的利用。
+- 进程可以比内存的全部空间还大。程序占用的内存空间的大小是程序设计的最大限制之一。没有这种方案时，程序员必须清楚的知道有多少内存空间可用。若编写的程序太大，程序员就必须设计出能把程序分成块的方法，这些块可按某种覆盖策略分别加载。通过基于分页或分段的虚拟内存，这项工作可由操作系统和硬件完成。对程序员而言，他所处理的是一个巨大的内存，大小与磁盘存储器有关。操作系统在需要时会自动的把进程块装入内存。 
+
+由于进程只能在内存中执行，因此这个存储器成为实存储器（real memory），简称实存。但程序员或用户感觉到的是一个更大的内存，且通常分配在磁盘上，这称为虚拟内存（virtual memory），简称虚存。虚存支持更有效的系统并发度，并能解除用户与内存之间没有必要的紧密约束。 
+
+
+
+![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/page_vs_fragment.png?raw=true)
+
+
+
+
+
+## 虚拟内存
+
+面对越来越大的程序,常常产生程序>内存的问题,为解决这种问题,虚拟内存的概念得到普及.
+
+要有效的使用处理器和I/O设备，就需要在内存中保留尽可能多的进程。此外，还需要解除程序在开发时对程序使用内存大小的限制。解决这两个问题的途径就是虚拟内存技术。采用虚拟内存技术时，所有的地址访问都是逻辑访问，并在运行时转换为实地址。
+
+虚拟内存机制使得期望运行大于物理内存的程序称为可能。其方法是将程序放在磁盘上，而将主存作为一种缓存，用来保存最频繁使用的部分程序。这种机制需要快速的映像内存地址，以便把程序生成的地址转换为有关字节在RAM中的物理地址。这种映像由CPU中的一个称为存储器管理单元（Memory Management Unit，MMU）的部件来完成。
+
+**虚拟内存**的**基本思想**是:每个程序都拥有自己的地址空间,这个空间被分割成多个 块,每个块被成为一页或页面.
+
+**程序运行时,并不是所有页都在物理内存中**:
+
+- 当程序引用一部分在物理内存的地址空间时,由硬件直接执行必要的映射;
+- 当程序引用一部分不在物理内存的地址空间时,有操作系统将缺失的页装入物理内存,并重新运行
+
+虚拟内存基于分段和分页这两种基本技术或基于这两种技术中的一种。虚拟内存机制允许程序以逻辑方式访问存储器，而不考虑物理内存上可用的空间数量。虚存的构想是为了满足有多个用户作业同时驻留在内存中的要求，因此在一个进程被写出到副主存储器中且后续进程被读入时，连续的进程执行之间将不会脱节。进程大小不同时，若处理器在很多进程间切换，则很难把它们紧密的压入内存，因此人们引入了分页系统。在分页系统中，进程由许多固定大小的块组成。这些块成为页。程序通过虚地址(virtual address)访问，虚地址由页号和页中的偏移量组成。进程的每页都可置于内存中的任何地方，分页系统提供了程序中使用的虚地址和内存中的实地址(real address)或物理地址之间的动态映射。
+
+
+
+### 分页访问过程:
+
+1. CPU中包含**MMU内存管理单元**,用于管理虚拟地址空间到物理内存地址的映射.
+2. 假设物理内存地址大小为32k,每4k为一个页框.虚拟地址空间分页,每个页面大小等于一个页框
+3. 当程序想要访问一个虚拟地址x,
+4. 指令将x送到MMU,
+5. MMU根据x的虚拟地址,判断其对应的页面是否在物理内存中:
+6. 若在,MMU将x转化为物理内存地址y
+7. 若不在,则进行缺页中断,操作系统在物理内存中找到一个使用较少的页面回收掉,将需要访问的页面读到被回收的页面处,再将x转化为物理内存地址访问
+
+
+
+
+
+### 虚拟内存的操作系统策略
+
+#### 1. 读取策略
+
+读取策略决定某页何时取入内存，常用的方法有如下两种：  
+
+- 请求分页
+
+    只有当访问到某页中的一个单元时才将改页取入内存。若内存管理的其他策略比较合适，将发生下述情况：当一个进程首次启动时，会在一段时间出现大量的缺页中断，取入越来越多的页后，局部性原理表明大多数将来访问的页都是最近去读的页。因此在一段时间后错误会逐渐减少，缺页中断的数量会降低到很低。
+
+- 预先分页
+
+    对于预先分页，读取的页并不是缺页中断请求的页。预先分页利用了大多数辅存设备（如磁盘）的特性，这些设备有寻道时间和合理的延迟。若一个进程的页连续存储在辅存中，则一次读取许多连续的页要比隔一段时间读取一页有效。当然，若大多数额外读取的页未引用到，则这个策略是低效的。进程首次启动时，可采用预先分页策略，此时程序员须以某种方式制定需要的页。
+
+#### 2. 放置策略
+
+防止策略决定一个进程块驻留在实存中的什么位置。在纯分页系统或段页式系统中，如何放置通常无关紧要，因为地址转换硬件和内存访问硬件能以相同的效率为任何页框组合执行相应的功能。
+
+#### 3. 置换策略
+
+以便处理在必须读取一个新页时，应该置换内存中的哪一页。当内存中的所有页框都被占据，且需要读取一个新页以处理一次缺页中断时，置换策略决定置换当前内存中的哪一页。所有策略的目标都是移出最近最不能访问的页。
+
+
+
+#### 4. 驻留集管理
+
+对于分页式虚拟内存，在准备执行时，不需要也不可能把一个进程的所有页都读入内存。因此，操作系统必须决定读取多少页，即决定给特定的进程分配多大的内存空间。
+
+
+
+#### 5.清楚策略
+
+与读取策略相反，清楚策略用于确定何时将已修改的一页写回辅存。通常有两种选择： 
+
+- 请求式清楚
+
+    只有当一页被选择用于置换时才能被写回辅存。
+
+- 预约式清楚
+
+    将这些已修改的多页在需要使用他们所占据的页框之前成批写回辅存。
+
+#### 6.加载控制
+
+加载控制会影响到驻留内存中的进程数量，这称为系统并发度。加载控制策略在有效的内存管理中非常重要。如果某一时刻驻留的进程太少，那么所有进程都处于堵塞态的概率就较大，因为会有许多时间话费在交换上。另一方面，如果驻留的进程太多，平均每个进程的驻留集大小将会不够用，此时会频繁发生缺页中断，从而导致系统抖动。
+
+
+
+
+
+## Android内存管理
+
+Android包含了标准Linux内核中内存管理设施的许多扩展，具体如下: 
+
+- ASHMem：这个功能提供匿名共享内存，它将内存抽象为文件描述符。文件描述符可以传递给另一个进程以共享内存。
+- Pmen：这个功能分配虚拟内存，使的它在物理上是连续的，因此对于那些不支持虚拟内存的设备非常实用。
+- Low Memory Killer：大部分移动设备不具备置换能力（因为闪存的使用寿命因素）。主存耗尽时，使用大量内存的应用不是让步对内存的使用就是被终结。这个功能可让系统通知应用释放内存，如果应用不配合，则终结应用。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/OperatingSystem/4.\350\260\203\345\272\246.md" "b/OperatingSystem/4.\350\260\203\345\272\246.md"
new file mode 100644
index 00000000..bb435432
--- /dev/null
+++ "b/OperatingSystem/4.\350\260\203\345\272\246.md"
@@ -0,0 +1,87 @@
+# 4.调度
+
+
+
+在多道程序设计系统中，内存中有多个进程，每个进程要么正在处理器上运行，要么正在等待某些事件的发生，比如I/O完成。处理器调度的目的是：以满足系统目标（如响应时间、吞吐率、处理器效率）的方式，把进程分配到一个或多个处理器上执行。处理器（或处理器组）通过执行某个进程而保持忙状态，而此时其他进程处理堵塞状态。典型的调度有四种： 
+
+### 长程调度
+
+决定哪个程序可以进入系统中处理，因此它控制了系统的并发度。一旦允许进入，作业或用户程序就成为进程，并添加到供短程调度程序使用的队列中，等待调度。
+
+
+
+### 中程调度
+
+决定加入部分或全部位于内存中的进程集合。它是交换功能的一部分。典型情况下，换入（swapping-in）决定取决于管理系统并发度的需求。
+
+
+
+### 短程调度
+
+决定处理器执行哪个可运行进程。
+
+长程调度程序执行的频率相对较低，并且只是大致决定是否接受新进程和接受哪个新进程。要进行交换决定，中程调度程序需要执行的稍频繁一些。短程调度程序，也成为分派程序（dispatcher），执行的最频繁，它精确的决定下次执行哪个进程。导致当前进程堵塞或抢占当前运行进程的事发生时，调用短程调度程序。这类事件包括: 
+
+- 时钟中断
+- I/O中断
+- 操作系统调用
+- 信号（如信号量）
+
+
+
+### I/O调度
+
+决定可用I/O设备处理哪个进程挂起的I/O请求
+
+
+
+## 多处理器调度
+
+
+
+多处理器系统分为以下几类: 
+
+- 松耦合、分布式多处理器、集群：又一系列相对自治的系统组成，每个处理器都有自身的内存和I/O通道。
+- 专用处理器：I/O处理器是一个典型的例子。此时，有一个通用的主处理器，专用处理器由主处理器控制，并为主处理器提供服务。
+- 紧耦合多处理器：由一些列共享同一个内存并受操作系统完全控制的处理器组成。
+
+
+
+多处理器中的调度设计三个相互关联的问题： 
+
+- 把进程分配到处理器
+
+    假设多处理器的结构是统一的，即没有哪个处理器在访问内核和I/O设备时具有物理上的特别优势，那么最简单的调度方法是把处理器视为一个资源池，并按照要求把进程分配到相应的处理器。但是这样就牵扯到静态还是动态的问题。如果一个进程从被激活到完成，一直被分配给同一个处理器，那么就需要为每个处理器维护一个专门的短程队列。这种方法的优点是调度的开销较小，因为相对于所有进程，关于处理器的分配只进行一次。静态分配的缺点就是一个处理器可能处于空闲状态，这时其队列为空，而另一个处理器却积压了许多工作。为了防止这种情况，需要使用一个公共队列。所有进程都进入一个全局队列，然后调度到任何一个可用的处理器中。这样，在一个进程的声明周期中，它可以在不同的时间于不同的处理器上执行。另一种分配策略是动态负载平衡，在该策略中，线程能在不同处理器所对应的队列之间转移。Linux采用的就是这种动态分配策略。
+
+    
+
+- 在单处理器上使用多道程序设计
+
+    单处理器能够在许多进程间切换，以达到较高的利用率和更好的性能。
+
+- 一个进程的实际分派
+
+    与多处理器调度相关的最后一个设计问题是选择哪个进程运行。在多道程序单处理器上，与简单的先来先服务策略相比，使用优先级或基于使用历史的高级调度算法可以提高性能。考虑多处理器时，这些复杂性可能是不必要的，甚至可能起到相反的效果，而相对比较简单的方法可能会更有效，而且开销比较低。
+
+
+
+
+
+### 线程调度
+
+在多处理器线程调度和处理器分配的各种方案中，有四个比较突出的方法：
+
+- 负载分配：进程不分配到某个特定的从处理器。系统维护一个就绪线程的全局队列，每个处理器只要空闲就从队列中选择一个线程。
+- 组调度：一组相关的的线程基于一对一的原则，同时调度到一组处理器上运行。
+- 专用处理器分配：这种方法与负载分配方法正好相反，它通过把线程指定到处理器来定义隐式的调度。每个程序在其执行过程中，都分配给一组处理器，处理器的数量与程序中线程的数量相等。程序终止时，处理器返回总处理器池，以便分配给另一个程序。
+- 动态调度：在执行期间，进程中线程的数据可以改变，允许动态地改变进程中的线程数量，这就使得操作系统可以通过调整负载情况来提高利用率。
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git a/OperatingSystem/5.IO.md b/OperatingSystem/5.IO.md
new file mode 100644
index 00000000..bf043437
--- /dev/null
+++ b/OperatingSystem/5.IO.md
@@ -0,0 +1,42 @@
+# 5.I/O
+
+
+
+计算机系统中参与I/O的外设大体上可分为如下三类： 
+
+- 人可读：适用于计算机用户间的交互，如打印机和终端。终端又包括显示器和键盘，以及其他一些可能的设备，如鼠标。
+- 机器可读：适用于与电子设备通信，如磁盘驱动器、USB密钥、传感器、控制器和执行器。
+- 通信：适用于与远程设备通信，如数字线路驱动器和调制解调器。
+
+执行I/O的三种技术： 
+
+- 程序控制I/O：处理器代表一个进程给I/O模块发送一个I/O命令，该进程进入忙等待，直到操作完成才能继续执行。
+- 中断驱动I/O：处理器代表进程向I/O模块发出一个I/O命令。有两种可能性：若来自进程的I/O指令是非堵塞的，则处理器继续执行发出I/O命令的进程的后续指令。若I/O指令是堵塞的，则处理器执行的下一条指令来自操作系统，它将当前的进程设置为堵塞态并调度其他进程。
+- 直接存储器访问（DMA）：一个DMA模块控制内存和I/O模块之间的数据交换。为传送一块数据，处理器给DMA模块发请求，且只有在整个数据块传送结束后，它才被中断。
+
+
+
+### 磁盘高速缓存
+
+
+
+高速缓冲存储器（cache memory）通常指比内存小且比内存块的存储器，它位于内存和处理器之间。这种高速缓冲存储器利用局部性原理来减少平均存储器的存取时间。同样的原理也适用于磁盘存储器。磁盘高速缓存是内存中为磁盘扇区设置的一个缓冲区，它包含有磁盘中某些扇区的副本。出现对某一特定扇区的I/O请求时，首先会进行检测，以确定该扇区是否在磁盘的告诉缓存中。若在则该请求可通过这个告诉缓存来满足。若不在，则把被请求的扇区从磁盘读到磁盘高速缓存中。
+
+
+
+磁盘的高速缓存有两个问题： 
+
+- 当一个I/O请求从磁盘高速缓存中得到满足时，磁盘高速缓存中的数据必须传送到发送请求的进程。这可以通过在内存中把这一块数据从磁盘高速缓存传送到分配给该用户进程的存储空间中，或简单地使用一个共享内存，传送指向磁盘高速缓存中相应项的指针。
+- 置换策略。当一个新扇区被读入磁盘高速缓存时，必须换出一个已存在的块。因此这就需要一个页面置换算法。
+    - 最近最少使用算法(LRU，Least Recently Used)
+    - 最不常使用页面置换算法（LFU， Least Frequently Used）
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/OperatingSystem/6.\346\226\207\344\273\266\347\256\241\347\220\206.md" "b/OperatingSystem/6.\346\226\207\344\273\266\347\256\241\347\220\206.md"
new file mode 100644
index 00000000..50a05239
--- /dev/null
+++ "b/OperatingSystem/6.\346\226\207\344\273\266\347\256\241\347\220\206.md"
@@ -0,0 +1,67 @@
+# 6.文件管理
+
+文件管理系统是一组系统软件，它为使用文件的用户和应用程序提供服务，包括文件访问、目录维护和访问控制。文件管理系统通常被视为一个由操作系统提供服务的系统服务，而不是操作系统的一部分，但是在任何系统中，至少有一部分文件管理功能是由操作系统执行的。
+
+
+
+文件系统不但提供存储数据（组织为文件）的手段，而且提供一系列对文件进行操作的功能接口。典型的操作如下：
+
+- 创建
+- 删除
+- 打开
+- 关闭
+- 读
+- 写
+
+
+
+### 文件系统架构
+
+![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/file_system.png?raw=true)
+
+
+
+
+
+- 设备驱动（device drivers)：程序直接与外围设备通信。设备驱动程序负责启动设备上的I/O操作，处理I/O请求的完成。
+- 基本文件系统或物理I/O层：是与计算机系统外部环境的基本接口。这一层处理在磁盘间或磁带系统间交换的数据块，因此它关注的是这些块在辅存和内存缓冲区中的位置，而非数据的内容或所涉及的文件结构。
+- 基本I/O管理程序(basic I/O supervisor)；负责所有文件I/O的初始化和终止。在这一层，需要一定的控制结构来维护设备的输入/输出、调度和文件状态。基本I/O管理程序是操作系统的一部分。
+- 逻辑I/O（logical I/O）使用户和应用程序能够访问记录。因此基本文件系统处理的是数据块，而逻辑I/O模块处理的是文件记录。逻辑I/O提供一种通用的记录I/O的能。
+
+
+
+
+
+## Android文件系统
+
+Android使用了Linux中的文件管理功能。Android文件系统目录与Linux安装目录类似，只是前者有一些特有的特性。 
+
+![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_file_system.png?raw=true)
+
+Android文件系统目录的顶层部分： 
+
+- system目录包含操作系统的核心部分，核心部分包括系统的二进制文件、系统库文件和配置文件。它还包含Android的基本应用，如闹钟、计算器和相机。系统映像是锁定的，文件系统只为用户提供只读权限。
+- data目录是应用程序存储文件时的首选位置。当系统中安装了一个新的应用程序时，以下这些操作都有data目录有关: 
+    - .apk文件放置在/data/app中
+    - 以应用为中心的库文件安装在/data/data/<应用名称>目录中。这个目录是特定应用程序的沙盒区域，只有该应用可以访问，其他应用不能访问。 
+    - 建立应用相关的文件数据库。
+- cache目录用于存储应用的临时数据。该区域存储Android系统频繁访问的数据和应用组件。清理高速缓存不会影响到个人数据，而只会简单地清理其中的已有数据，继续使用设备时，其中的数据会自动创建。
+- mnt/sdcard目录不是设备内部的内存分区，而是sd卡的分区，sd卡是一种用于android设备的非易失性的存储卡。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/OperatingSystem/7.\345\265\214\345\205\245\345\274\217\347\263\273\347\273\237.md" "b/OperatingSystem/7.\345\265\214\345\205\245\345\274\217\347\263\273\347\273\237.md"
new file mode 100644
index 00000000..5cddf7fc
--- /dev/null
+++ "b/OperatingSystem/7.\345\265\214\345\205\245\345\274\217\347\263\273\347\273\237.md"
@@ -0,0 +1,27 @@
+# 7.嵌入式系统
+
+
+
+为完成某个特定功能而设计的，或许有附加机制或其他部分的计算机硬件和软件结合体。在许多情况下，嵌入式系统是一个更大系统或产品中的一部分，如汽车中的防抱死系统。
+
+
+
+## 嵌入式Linux
+
+嵌入式Linux是指运行在嵌入式系统中的Linux。嵌入式Linux是Linux的一个版本，是基于嵌入式设备的大小和硬件限制而定制的，它同时包括一些软件包，用于支持设备商运行的服务和应用。因此嵌入式Linux的内核比普通Linux的内核要小得多。
+
+台式机/服务器Linux与嵌入式Linux的一个关键区别是： 台式机/服务器软件通常是在运行平台上编译的，而嵌入式Linux通常在一个平台上编译，但运行于另一个平台，后者称为交叉编译。
+
+
+
+Android是基于Linux内核的一个嵌入式系统，因此我们可以认为Android是嵌入式Linux的一个例子。但是，很多嵌入式Linux开发人员不认为Android系统是嵌入式Linux的实例。他们认为，传统的嵌入式系统拥有固定的功能，而且在出厂时就已确定。Adnroid能支持各种的应用，因此要比普通平台性操作系统强大得多。而且，Android是垂直一体化的系统，包括针对Linux内核的特定修改。
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/OperatingSystem/8.\350\231\232\346\213\237\346\234\272.md" "b/OperatingSystem/8.\350\231\232\346\213\237\346\234\272.md"
new file mode 100644
index 00000000..73d02145
--- /dev/null
+++ "b/OperatingSystem/8.\350\231\232\346\213\237\346\234\272.md"
@@ -0,0 +1,134 @@
+# 8.虚拟机
+
+通常而言，应用程序直接运行在PC或服务器的操作系统上。每台PC或服务器在同一时间只运行一个操作系统。因此，应用程序供应商需要为每个操作系统或平台重写应用程序的部分代码，才能使应用能够得到系统支持的运行。要支持多种操作系统，应用程序供应商需要创建、管理和维护多种硬件与操作系统基础设施，这一过程需要耗费昂贵的代价和大量的资源。处理这个问题的有效策略之一称为虚拟化(virtualization)，虚拟化技术可使一台PC或服务器同时运行多个操作系统或一个系统的多个会话。一台运行虚拟化软件的机器能在同一平台上运行大量的应用程序，包括那些运行在不同操作系统上的应用程序。实际上，主机操作系统能支持多个虚拟机(virtual machines)，每个虚拟机都有特定操作系统的特性。 
+
+启用虚拟化的解决方案是虚拟机监视器(VMM),现在通常称为虚拟机管理程序(Hypervisor)。该软件介于硬件和虚拟机之间，以资源代理的形式存在。简而言之，它使多个虚拟机安全地共存于一台物理服务器主机并共享主机的资源。
+
+
+
+![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/virtual_1.png?raw=true)
+
+
+
+## Java虚拟机
+
+
+
+尽管Java虚拟机（JVM）用“虚拟机”作为其名称的一部分，但其实现和用途与我们前面所讲的模型不同。虚拟机管理程序支持在主机上运行一个或多个虚拟机。这些虚拟机独立的处理工作负载，支持操作系统和应用，且在它们自身看来，访问一系列提供计算、存储和输入/输出的资源。Java虚拟机的目的是，无须更改任何Java代码就可在任意硬件平台的任意操作系统上，提供运行时空间。两种模型的目的都是通过使用某种程度的抽象化来实现平台无关性。       
+
+JVM可描述为一个抽象的计算设备，它包含指令集、一个PC（程序计数器）寄存器、一个用来保存变量和结果的栈、一个保存运行时数据和垃圾手机的堆、一个存储代码和常量的方法区。 
+
+JVM支持多个线程，每个线程都有自己的寄存器和堆栈区，且所有线程共享栈和方法区。
+
+
+
+## Android虚拟机
+
+
+
+Android平台的虚拟机称为Dalvik，Dalvik VM(DVM)执行格式为Dalvik Executable(.dex格式)的文件，即为高效存储和内存映射执行而优化的格式。DVM可以运行由Java编译器编译的类，该编译器以用“dx”工具转换为本地格式。
+
+虚拟机运行在Linux内核的顶部，它依赖于底层的功能（如线程和底层的内存管理）。Dalvik核心类库的目的是，为那些使用标准Java编程的人员提供熟悉的开发环境，但它是专门为满足小型移动设备的需要而设计的。
+
+
+
+每个Android应用程序都运行在自己的进程中，有自己的Dalvik运行实例。Dalvik是可以在一台设备上高效执行多个副本的虚拟机。 
+
+
+
+
+
+### dex文件系统
+
+DVM运行Java语言的应用和代码。标准的Java编译器将源代码（写在文本文件中）转换为字节码，然后将字节码翻译成DVM虚拟机可读和可用的.dex文件。本质上，类文件被转换为.dex文件(像Java虚拟机中的jar文件)，然后在DVM上读取和执行。类文件中的重复数据在.dex文件中只包含一次，以节省空间开销。在安装时，这个可执行文件还可根据移动设备进一步修改和优化。
+
+
+
+![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/java_vs_dalvik.png?raw=true)
+
+上图中的.jar文件的布局，它包含一个或多个类文件。这些类文件聚合为一个.dex文件，并存储为一个android安装包文件(.apk)。所有类文件中的不同常量池集中为单个常量池，在.dex文件中组织为常量类型。允许类的常量池共享，因此可使常量值的重复减至最低。类似的，类文件中的类、域、方法、属性也在.dex文件中集中到一起。
+
+
+
+
+
+## Android进程结构
+
+如同传统的Linux系统一样，Android的第一个用户空间进程是init，它是所有其他进程的根。然而，Android的init启动的守护进程是不同的，这些守护进程更多的聚焦于底层细节（管理文件系统和硬件访问），而不是高层用户设施，例如调度定时任务。Android还有一层额外的进程，它们运行Dalvik的Java语言环境，负责执行系统中所有以Java实现的部分。
+
+
+
+![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_process.png?raw=true)
+
+
+
+如上图，首先是init进程，它产生了一些底层守护进程。其中一个守护进程是zygote，它是高级Java语言进程的根。Android的init不以传统的方法运行shell，因为典型的Android设备没有本地控制台用于shell访问。作为替代，系统进程adbd监听请求shell访问的远程连接（例如通过USB），按要求为它们创建shell进程。因为Android大部分是用Java语言编写的，所以zygote守护进程以及由它启动的进程是系统的中心。由zygote启动的第一个进程称为system_server，它包含全部核心操作服务，其关键部分是电源管理、包管理、窗口管理和活动管理。
+
+其他进程在需要的时候由zygote创建。这些进程中有一些是“持久的”进程，它们是基本操作系统的组成部分，例如phone进程中的电话栈，它必须保持始终运行。另外的应用程序进程将在系统运行的过程中按需创建和终止。
+
+应用程序通过调用操作系统提供的库与操作系统进行交互，这些库合起来构成Android框架（Android framework）。这些库中有一些可以在进程内部执行其工作，但是许多库需要与其他进程执行进程间通信，作者通常是在system_server进程中提供服务的。
+
+
+
+### Zygote
+
+Zygote是在启动时就运行在DVM上的一个进程。每当出现创建进程的请求时，Zygote就会产生一个新的DVM虚拟机。Zygote通过在内存中尽可能多的共享内容来最小化产生一个新DVM所消耗的时间。通常而言，许多应用程序都会使用核心库的类和相应的堆结构，而这些内容都是只读的。也就是说，被大部分应用程序使用的这些共享数据和类都是只读而不能改变的。因此，当Zygote加载时，就预加载和初始化了应用程序运行时可能用到的Java核心库和资源。当Zygote创建一个新的DVM时，这部分类不会被分配到新内存。Zygote只是简单地把子进程的这些内存页映射到父进程的相应位置。
+
+实际上，几乎不需要更多的映射页。如果一个类被一个子进程自己的DVM改写，那么Zygote会将受影响的内存复制到子进程中。这种即写即复制的行为在使得最大化共享内存的同时，还能保证应用程序间不会相互影响，并在跨应用程序和进程的边界时保证安全性。
+
+
+
+## Android进程模型
+
+
+
+Linux的传统进程模型是用fork指令来创建新进程，然后用exec指令使用待运行的源码初始化该进程并开始执行。shell负责实现进程执行、创建新进程、执行所需的进程来运行shell指令。当指令结束时，进程被从Linux中移除。
+
+Android使用的进程有些不同。活动管理器是Android负责正在运行的应用程序的管理的一部分。活动管理器协调新应用程序进程的启动，决定哪些应用程序能在其中运行，哪些已不再需要。
+
+
+
+### 启动进程
+
+为了启动新进程，活动管理器需要与zygote通信。活动管理器首先开始，它创建一个与zygote相连的专用接口，通过接口发送一条指令，表示它需要启动一个进程。这条指令主要描述需要创建的沙箱、新进程运行所需要的UID以及需要遵守的安全性制约。zygote需要作为根来运行：创建新进程时，它合理配置运行所需的UID，最终下放权限，将进程改为该UID。
+
+![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_start_process.png?raw=true)
+
+上图展示了一个新进程中启动活动的流程： 
+
+1. 某个现有进程（如应用程序启动器）调用活动管理器，发出意图，描述它想要启动的新活动。
+2. 活动管理器要求封装管理器将这个意图解析为一个明确的组件。
+3. 活动管理器判断这个应用程序的进程并未正在运行，然后向zygote请求一个具有合适UID的新锦成。
+4. zygote进行一次fork指令，克隆自己来创造一个新进程，下方权限并配置新进程的UID和沙箱，初始化该进程的Dalvik，使得Java runtime开始完全执行。例如，它需要在fork后启动垃圾收集等线程。
+5. 新进程如今是一个zygote的克隆，并运行着完全配置好的Java环境。它回调活动管理器，询问后者“我该做什么”。
+6. 活动管理器返回即将启动的应用程序的完整信息，如源码位置等。
+7. 新进程读取应用程序的源码，开始运行。
+8. 活动管理器将所有即将进行的操作发送给新进程，在此处为“启动活动X”。
+9. 新进程收到指令，启动活动，实体化合适的Java类并执行。
+
+注意，当活动启动时，应用程序的进程可能正在运行了。在这种情况下，活动管理器会直接跳转到末尾，向该进程发送一条新指令，让它实体化并执行合适的组件。如果合适，这会导致一个额外的活动实例在应用程序中运行。
+
+
+
+### 进程声明周期
+
+活动管理器也负责判断何时进程不再被需要。活动管理器记录一个进程中运行的所有活动、接收器、服务以及内容提供其，据此可判断该进程的重要程度。
+
+Android内核中的内存溢出强制结束指令是使用一个进程的oom_adj进行严格排序，决定哪个进程需要优先强制结束。活动管理器负责基于每个进程的状态，通过将其归类于几个主要用途，从而合理设定器oom_adj。/proc/<pid>/oom_adj:   
+
+- 取值是-17到+15，取值越高，越容易被干掉。如果是-17，则表示不能被kill
+- 该设置参数的存在是为了和旧版本的内核兼容
+
+![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_process_adj.png?raw=true)
+
+让RAM内存不足时，系统已经完成了进程的配置，使得内存溢出强制结束命令优先中止缓存(cache)类型的进程，尝试重新取得足够的所需内存，随后中止界面(home)类别、服务(service)类别，以此类推。在同一个oom_adj水平中，它将优先中止内存占用较大的进程。
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 

From 357e4fed3bae520c57beffca1d9947f4c47fee5e Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 26 Nov 2020 09:36:25 +0800
Subject: [PATCH 032/213] update README

---
 ...73\347\273\237\347\256\200\344\273\213.md" |  2 +-
 ...13\344\270\216\347\272\277\347\250\213.md" |  2 +-
 OperatingSystem/{5.IO.md => 5.I:O.md}         |  0
 README.md                                     | 28 +++++++++++++++----
 4 files changed, 25 insertions(+), 7 deletions(-)
 rename "OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237.md" => "OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md" (99%)
 rename "OperatingSystem/2.\350\277\233\347\250\213.md" => "OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md" (99%)
 rename OperatingSystem/{5.IO.md => 5.I:O.md} (100%)

diff --git "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237.md" "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
similarity index 99%
rename from "OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237.md"
rename to "OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
index 00696a2d..d1351546 100644
--- "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237.md"
+++ "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
@@ -1,6 +1,6 @@
 
 
-# 1.操作系统
+# 1.操作系统简介
 
 
 
diff --git "a/OperatingSystem/2.\350\277\233\347\250\213.md" "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
similarity index 99%
rename from "OperatingSystem/2.\350\277\233\347\250\213.md"
rename to "OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
index cad290fc..5f19d32d 100644
--- "a/OperatingSystem/2.\350\277\233\347\250\213.md"
+++ "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
@@ -1,4 +1,4 @@
-# 1.进程
+# 2.进程与线程
 
 
 
diff --git a/OperatingSystem/5.IO.md b/OperatingSystem/5.I:O.md
similarity index 100%
rename from OperatingSystem/5.IO.md
rename to OperatingSystem/5.I:O.md
diff --git a/README.md b/README.md
index 316ffbc9..41171f32 100644
--- a/README.md
+++ b/README.md
@@ -13,7 +13,6 @@ Android学习笔记
 
 - [史上最适合Android开发者学习的Go语言教程](https://github.com/CharonChui/GolangStudyNote)
 - [史上最适合Android开发者学习的iOS开发教程](https://github.com/CharonChui/iOSStudyNote)
-
 - [源码解析][43] 
     - [自定义View详解][1]
     - [Activity界面绘制过程详解][2]
@@ -32,7 +31,6 @@ Android学习笔记
         - [Volley源码分析][15]
         - [Retrofit详解(上)][16]
         - [Retrofit详解(下)][17]
-
 - [Dagger2][199]        
     - [1.Dagger2简介(一).md][200]
     - [2.Dagger2入门demo(二).md][201]    
@@ -43,7 +41,6 @@ Android学习笔记
     - [7.Dagger2之dagger-android(七).md][206]            
     - [8.Dagger2与MVP(八).md][207]    
     - [9.Dagger2原理分析(九).md][212]
-
 - [音视频开发][44]
     - [搭建nginx+rtmp服务器][18]
     - [视频播放相关内容总结][19]
@@ -98,6 +95,18 @@ Android学习笔记
         - [11.OpenGL ES滤镜][242]
     - [弹幕][243]
         - [Android弹幕实现][244]
+- [操作系统][263]
+    - [1.操作系统简介][264]
+    - [2.进程与线程][265]
+    - [3.内存管理][266]
+    - [4.调度][267]
+    - [5.I/O][268]
+    - [6.文件管理][269]
+    - [7.嵌入式系统][270]
+    - [8.虚拟机][271]
+- [架构设计][272]
+    - [1.架构简介][273]
+
 -  [图片加载][45]
     - [Glide简介(上)][25]
     - [Glide简介(下)][26]
@@ -556,8 +565,17 @@ Android学习笔记
 [260]:https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E8%A7%86%E9%A2%91%E7%BC%96%E7%A0%81/H265.md  "H265"
 [261]:  https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/P2P%E6%8A%80%E6%9C%AF/P2P.md "P2P"
 [262]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/P2P%E6%8A%80%E6%9C%AF/P2P%E5%8E%9F%E7%90%86_NAT%E7%A9%BF%E9%80%8F.md "P2P原理_NAT穿透"
-
-
+[263]: https://github.com/CharonChui/AndroidNote/tree/master/OperatingSystem "操作系统"
+[264]: https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/1.%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F.md "1.操作系统简介"
+[265]: https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/2.%E8%BF%9B%E7%A8%8B.md "2.进程和线程"
+[266]: https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/3.%E5%86%85%E5%AD%98%E7%AE%A1%E7%90%86.md "3.内存管理"
+[267]: https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/4.%E8%B0%83%E5%BA%A6.md "4.调度"
+[268]: https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/5.IO.md "5.I/O"
+[269]: https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/6.%E6%96%87%E4%BB%B6%E7%AE%A1%E7%90%86.md "6.文件管理"
+[270]: https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/7.%E5%B5%8C%E5%85%A5%E5%BC%8F%E7%B3%BB%E7%BB%9F.md "7.嵌入式系统"
+[271]: https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/8.%E8%99%9A%E6%8B%9F%E6%9C%BA.md "8.虚拟机"
+[272]: https://github.com/CharonChui/AndroidNote/tree/master/Architect "架构设计"
+[273]: https://github.com/CharonChui/AndroidNote/blob/master/Architect/1.%E6%9E%B6%E6%9E%84%E7%AE%80%E4%BB%8B.md "1.架构简介"
 
 
 Developed By

From a13218a2a97024f7288ee69e52a41a4c2342f579 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 26 Nov 2020 09:40:53 +0800
Subject: [PATCH 033/213] update README

---
 README.md | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 41171f32..91a59d53 100644
--- a/README.md
+++ b/README.md
@@ -566,11 +566,13 @@ Android学习笔记
 [261]:  https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/P2P%E6%8A%80%E6%9C%AF/P2P.md "P2P"
 [262]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/P2P%E6%8A%80%E6%9C%AF/P2P%E5%8E%9F%E7%90%86_NAT%E7%A9%BF%E9%80%8F.md "P2P原理_NAT穿透"
 [263]: https://github.com/CharonChui/AndroidNote/tree/master/OperatingSystem "操作系统"
-[264]: https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/1.%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F.md "1.操作系统简介"
-[265]: https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/2.%E8%BF%9B%E7%A8%8B.md "2.进程和线程"
+[264]: https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/1.%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E7%AE%80%E4%BB%8B.md "1.操作系统简介"
+[265]: https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/2.%E8%BF%9B%E7%A8%8B%E4%B8%8E%E7%BA%BF%E7%A8%8B.md "2.进程和线程"
 [266]: https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/3.%E5%86%85%E5%AD%98%E7%AE%A1%E7%90%86.md "3.内存管理"
 [267]: https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/4.%E8%B0%83%E5%BA%A6.md "4.调度"
-[268]: https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/5.IO.md "5.I/O"
+
+[268]: https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/5.I:O.md "5.I/O"
+
 [269]: https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/6.%E6%96%87%E4%BB%B6%E7%AE%A1%E7%90%86.md "6.文件管理"
 [270]: https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/7.%E5%B5%8C%E5%85%A5%E5%BC%8F%E7%B3%BB%E7%BB%9F.md "7.嵌入式系统"
 [271]: https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/8.%E8%99%9A%E6%8B%9F%E6%9C%BA.md "8.虚拟机"

From 9d6f06a3625eebf1c80612e7da8d02e9cba8bc28 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 26 Nov 2020 10:19:46 +0800
Subject: [PATCH 034/213] update README

---
 ...73\347\273\237\347\256\200\344\273\213.md" | 70 ++++++++++---------
 ...13\344\270\216\347\272\277\347\250\213.md" |  2 +
 2 files changed, 38 insertions(+), 34 deletions(-)

diff --git "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md" "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
index d1351546..b6dd93ea 100644
--- "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
+++ "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
@@ -35,7 +35,7 @@
 
 #### 内存管理(Memory management)
 
-内存是计算机很重要的一个资源，因为程序只有被加载到内存中才可以运行，此外 CPU  所需要的指令与数据也都是来自内存的。内存的并不是无限制的，它受限于硬件和寻址位数。但是现代操作系统会让每一个进程都觉得自己在独占整个内存，这就是虚拟内存技术。值得注意的是，这里的虚拟内存与 swap 这种虚拟内存是不一样的，虽然两个都是成为虚拟内存，但是完全是两个不同方向的技术。
+内存是计算机很重要的一个资源，因为程序只有被加载到内存中才可以运行，此外 CPU  所需要的指令与数据也都是来自内存的。内存的并不是无限制的，它受限于硬件和寻址位数。但是现代操作系统会让每一个进程都觉得自己在独占整个内存，这就是虚拟内存技术。值得注意的是，这里的虚拟内存与 swap 这种虚拟内存是不一样的，虽然两个都是称为虚拟内存，但是完全是两个不同方向的技术。
 进程的运行需要分配内存，内存分配的快慢都与内存管理方式有着巨大的影响。两个不同进程对应的内存区域是不能相互访问的，操作系统必须得提供这样的保证，否则很容易出问题，比如：运行着的 dota  游戏如果可以被另外一个进程访问它的内存区域的话，那就可以直接将内存区域中的某个数值进行修改，比如将游戏中的玩家生命值变为无限，这样对手怎么打都打不死自己的英雄。例如前段时间火热的吃鸡游戏，外挂软件可以让角色在决赛圈外进行锁血，这个就是游戏内存被修改的最好示例。当然这是通过比较专业的手段来绕过操作系统的限制，这也从另外一个方面来说明，其实现在的操作系统安全性也是有很大提升空间的。
 进程退出销毁时，内存的回收也是很重要的，否则很容易就会产生内存溢出，占着茅坑不拉屎，导致其他的进程都憋死。
 
@@ -55,7 +55,7 @@
 
 
 我们常见的网络通信场景有：微信聊天、浏览网页、玩网络游戏等，可以说现在的操作系统如果不能上网感觉就没了灵魂。网络通信是个很复杂的过程，连很多专业的程序猿都说不清楚当他上网时网页是如何显示出来的，更别说整个网络的拓扑结构了。
-整个网络通信其实是一套约定好的通信协议，很多人第一次听说协议时觉得很高级，其实没什么高级的，简单的说，类似于我们军训时当教官喊立正我们必须得做出相应动作一样，一个指令对应一个动作。由于网络太复杂了，某位哲人说过如果某样东西太复杂可以通过分层来解决，于是网络分了 5 层。有人也许会说是 7 层，那是 OSI 标准，在实际应用中一般都是 5 层。由于网络这块内容实在是太复杂，后面我会另开一个专栏进行讲解。
+整个网络通信其实是一套约定好的通信协议，很多人第一次听说协议时觉得很高级，其实没什么高级的，简单的说，类似于我们军训时当教官喊立正我们必须得做出相应动作一样，一个指令对应一个动作。由于网络太复杂了，某位哲人说过如果某样东西太复杂可以通过分层来解决，于是网络分了 5 层。有人也许会说是 7 层，那是 OSI 标准，在实际应用中一般都是 5 层。
 
 
 
@@ -74,16 +74,16 @@
 
 
 
-计算机由处理器、存储器和输入\输出部件组成，每类部件都有一个或多个模块。这些部件以某种方式互连，以实现计算机执行程序的主要功能。因此，计算机有4个主要的结构化部件: 
+计算机由处理器、存储器和输入/输出部件组成，每类部件都有一个或多个模块。这些部件以某种方式互连，以实现计算机执行程序的主要功能。因此，计算机有4个主要的结构化部件: 
 
 - 处理器(Processor)：控制计算机的操作，执行数据处理功能。只有一个处理器时，它通常指中央处理器(CPU)
-- 内存（Main memory):存储数据和程序。此类存储器通常是易失性的，即当计算机关机时，存储器的内容会丢失。相对于此的是磁盘存储器，当计算机关机时，它的内容不会丢失。内存通常也成为实存储器(real memory)或主存储器(primary memory)。
-- 输入\输出模块(I/O modules):在计算机和外部环境之间移动数据。外部环境由各种外部设备组成，包括辅助存储器设备(如硬盘)、通信设备和终端。
-- 系统总线(System bus)在处理器、内存和输入\输出模块间提供通信的设施。 
+- 内存（Main memory):存储数据和程序。此类存储器通常是易失性的，即当计算机关机时，存储器的内容会丢失。相对于此的是磁盘存储器，当计算机关机时，它的内容不会丢失。内存通常也称为实存储器(real memory)或主存储器(primary memory)。
+- 输入/输出模块(I/O modules):在计算机和外部环境之间移动数据。外部环境由各种外部设备组成，包括辅助存储器设备(如硬盘)、通信设备和终端。
+- 系统总线(System bus):在处理器、内存和输入/输出模块间提供通信的设施。 
 
 
 
-处理器的一种功能是与存储器叫唤数据。为此，它通常使用两个内部寄存器: 
+处理器的一种功能是与存储器交换数据。为此，它通常使用两个内部寄存器: 
 
 - 存储器地址寄存器(Memory Address Register, MAR),用于确定下一次读/写的存储器地址。
 - 存储器缓冲寄存器(Memory Buffer Register,MBR),存放要写入存储器的数据或从存储器中读取的数据。
@@ -100,12 +100,14 @@
 
 ### 计算机打开电源后的执行
 
-在每台计算机上有一块双亲板（在政治因素影响到计算机产业之前，它们曾称为“母版”）。在双亲板上有一个称为基本输入输出系统（Basic Input Output System， BIOS）的程序。在BIOS内有底层I/O软件，包括读键盘、写屏幕、进行磁盘I/O以及其他过程。在计算机启动时，BIOS开始运行。它首先检查所安装的RAM数量、键盘和其他基本设备是否已安装并正常相应。接着，它开始扫描PCIe和PCI总线并找出连在上面的所有设备。即插即用设备也被记录下来。如果现有的设备和系统上一次启动时的设备不同，则新的设备将被配置。然后BIOS通过尝试存储在CMOS存储器中的设备清单决定启动设备。用户可以在系统刚启动之后进入一个BIOS配置程序，对设备清单进行修改。典型的，如果存在CD-ROM（有时是USB），则系统试图从中启动（之前重装系统就是这么操作的）。如果失败，系统将从硬盘启动。启动设备上的第一个扇区被读入内存并执行。这个扇区中包含一个对保存在启动扇区末尾的分区表检查的程序，以确定哪个分区是活动的。然后，从该分区读入第二个启动装载模块。来自活动分区的这个装载模块被读入操作系统，并启动之。 
+在每台计算机上有一块双亲板（在政治因素影响到计算机产业之前，它们曾称为“母版”）。在双亲板上有一个称为基本输入输出系统（Basic Input Output System， BIOS）的程序。在BIOS内有底层I/O软件，包括读键盘、写屏幕、进行磁盘I/O以及其他过程。在计算机启动时，BIOS开始运行。它首先检查所安装的RAM数量、键盘和其他基本设备是否已安装并正常响应。接着，它开始扫描PCIe和PCI总线并找出连在上面的所有设备。即插即用设备也被记录下来。如果现有的设备和系统上一次启动时的设备不同，则新的设备将被配置。然后BIOS通过尝试存储在CMOS存储器中的设备清单决定启动设备。用户可以在系统刚启动之后进入一个BIOS配置程序，对设备清单进行修改。典型的，如果存在CD-ROM（有时是USB），则系统试图从中启动（之前重装系统就是这么操作的）。如果失败，系统将从硬盘启动。启动设备上的第一个扇区被读入内存并执行。这个扇区中包含一个对保存在启动扇区末尾的分区表检查的程序，以确定哪个分区是活动的。然后，从该分区读入第二个启动装载模块。来自活动分区的这个装载模块被读入操作系统，并启动之。 
 
 然后，操作系统询问BIOS，以获得配置信息。对于每种设备，系统检查对应的设备驱动程序是否存在。如果没有，系统要求用户插入含有该驱动程序的CD-ROM（由设备供应商提供）或者从网络上下载驱动程序。一旦有了全部的设备驱动程序，操作系统就将它们调入内核。然后初始化有关表格，创建需要的任何背景进程，并在每个终端上启动登陆程序或GUI。
 
+如果是从普通硬盘启动，可简单列举为如下步骤:  
+
 1. X86 PC开机时CPU处于实模式，开机时会将cs=0xffff，ip=0x0000
-2. 寻址0xFFFF0(ROM BIOS营社区)
+2. 寻址0xFFFF0(ROM BIOS映射区)
 3. 检查RAM、键盘、显示器、磁盘、主板等硬件
 4. 将磁盘0磁道0扇区(操作系统引导扇区)读入0x7c00处
 5. 设置 cs=0x07c0，ip=0x0000开始执行
@@ -114,9 +116,7 @@
 
 ## CPU(Central Processing Unit)
 
-CPU 是计算机的大脑，它主要和内存进行交互，从内存中提取指令并执行它。CPU(中央处理器)是一块超大规模的集成电路Integrated Circuit)，是信息处理、程序运行的最终执行单元。其功能主要是解释计算机指令以及处理计算机软件中的数据。从功能方面来看，CPU的内部主要由寄存器，控制器，运算器构成，各部分之间由电流信号相互连通。其中运算器负责算术运算和逻辑运算，控制器负责计算指令的解析，产生各种控制指令，寄存器组用来临时存放参加运算的数据和计算的中间结果。CPU计算结果最终需要写到内存中，内存的存取速度远低于CPU，为提升数据交换速率，CPU内部一般还集成了高速缓存（CACHE）,其中缓存分为一级缓存和二级缓存，一级缓存和CPU速率相当，二级缓存次之。其实在现在一些CPU中，一级缓存也会分为一级数据缓存和一级指令缓存。
-
-由于访问内存获取执行或数据要比执行指令花费的时间长，因此所有的 CPU 内部都会包含一些`寄存器`来保存关键变量和临时结果。因此，在指令集中通常会有一些指令用于把关键字从内存中加载到寄存器中，以及把关键字从寄存器存入到内存中。
+CPU(中央处理器)是计算机的大脑，它主要和内存进行交互，从内存中提取指令并执行它。它是一块超大规模的集成电路Integrated Circuit)，是信息处理、程序运行的最终执行单元。其功能主要是解释计算机指令以及处理计算机软件中的数据。由于访问内存获取执行或数据要比执行指令花费的时间长，因此所有的 CPU 内部都会包含一些寄存器来保存关键变量和临时结果。因此，在指令集中通常会有一些指令用于把关键字从内存中加载到寄存器中，以及把关键字从寄存器存入到内存中。从功能方面来看，CPU的内部主要由寄存器，控制器，运算器构成，各部分之间由电流信号相互连通。其中运算器负责算术运算和逻辑运算，控制器负责计算指令的解析，产生各种控制指令，寄存器组用来临时存放参加运算的数据和计算的中间结果。CPU计算结果最终需要写到内存中，内存的存取速度远低于CPU，为提升数据交换速率，CPU内部一般还集成了高速缓存（CACHE）,其中缓存分为一级缓存和二级缓存，一级缓存和CPU速率相当，二级缓存次之。
 
 
 
@@ -124,27 +124,27 @@ CPU 是计算机的大脑，它主要和内存进行交互，从内存中提取
 
 使用高级语言编写的程序会在编译后转化成机器语言，然后通过CPU内部的寄存器来处理。不同类型的CPU，其内部寄存器的数量，种类以及寄存器存储的数值范围都是不同的。根据功能的不同，我们可以将寄存器大致划分为八类。
 
-**累加寄存器：**存储执行运算的数据和运算后的数据。
+***累加寄存器***：存储执行运算的数据和运算后的数据。
 
-**标志寄存器：**存储运算处理后的CPU的状态。
+***标志寄存器***：存储运算处理后的CPU的状态。
 
-**程序计数器：**存储下一条指令所在内存的地址。
+***程序计数器***：存储下一条指令所在内存的地址。
 
-**基址寄存器：**存储数据内存的起始地址。
+***基址寄存器***：存储数据内存的起始地址。
 
-**变址寄存器：**存储基址寄存器的相对地址。
+***变址寄存器***：存储基址寄存器的相对地址。
 
-**通用寄存器：**存储任意数据。
+***通用寄存器***：存储任意数据。
 
-**指令寄存器：**存储指令。CPU内部使用，程序员无法通过程序对该寄存器进行读写操作。
+***指令寄存器***：存储指令。CPU内部使用，程序员无法通过程序对该寄存器进行读写操作。
 
-**栈寄存器：**存储栈区域的起始地址。
+***栈寄存器***：存储栈区域的起始地址。
 
 其中，程序计数器，累加寄存器，标志寄存器，指令寄存器和栈寄存器都只有一个，其他的寄存器一般有多个。
 
 
 
-**计算机执行的原理是: 取指执行   **
+***计算机执行的原理是: 取指执行***
 
 处理器执行的程序是由一组保存在存储器中的指令组成的。最简单的指令处理包括两步: 处理器从存储器中一次读(取)一条指令，然后执行每条指令。程序执行是由不断重复的取指令和执行指令的过程组成的。指令执行可能涉及很多操作，具体取决于指令本身。 
 
@@ -163,11 +163,11 @@ CPU 是计算机的大脑，它主要和内存进行交互，从内存中提取
 
 几乎所有的冯·诺伊曼型计算机的CPU，其工作都可以分为5个阶段：**取指令、指令译码、执行指令、访存取数、结果写回**。
 
-- `取指令`阶段是将内存中的指令读取到 CPU 中寄存器的过程，程序寄存器用于存储下一条指令所在的地址
-- `指令译码`阶段，在取指令完成后，立马进入指令译码阶段，在指令译码阶段，指令译码器按照预定的指令格式，对取回的指令进行拆分和解释，识别区分出不同的指令类别以及各种获取操作数的方法。
-- `执行指令`阶段，译码完成后，就需要执行这一条指令了，此阶段的任务是完成指令所规定的各种操作，具体实现指令的功能。
-- `访问取数`阶段，根据指令的需要，有可能需要从内存中提取数据，此阶段的任务是：根据指令地址码，得到操作数在主存中的地址，并从主存中读取该操作数用于运算。
-- `结果写回`阶段，作为最后一个阶段，结果写回（Write Back，WB）阶段把执行指令阶段的运行结果数据“写回”到某种存储形式：结果数据经常被写到CPU的内部寄存器中，以便被后续的指令快速地存取；
+- 取指令阶段是将内存中的指令读取到 CPU 中寄存器的过程，程序寄存器用于存储下一条指令所在的地址
+- 指令译码阶段，在取指令完成后，立马进入指令译码阶段，在指令译码阶段，指令译码器按照预定的指令格式，对取回的指令进行拆分和解释，识别区分出不同的指令类别以及各种获取操作数的方法。
+- 执行指令阶段，译码完成后，就需要执行这一条指令了，此阶段的任务是完成指令所规定的各种操作，具体实现指令的功能。
+- 访问取数阶段，根据指令的需要，有可能需要从内存中提取数据，此阶段的任务是：根据指令地址码，得到操作数在主存中的地址，并从主存中读取该操作数用于运算。
+- 结果写回阶段，作为最后一个阶段，结果写回（Write Back，WB）阶段把执行指令阶段的运行结果数据“写回”到某种存储形式：结果数据经常被写到CPU的内部寄存器中，以便被后续的指令快速地存取；
 
 
 
@@ -185,7 +185,7 @@ CPU 是计算机的大脑，它主要和内存进行交互，从内存中提取
 
 于是出现了多级存储器组织结构:
 
-- 寄存器： 最快、最小和最贵的存储器类型由位于处理器内部的寄存器组成。它们用预CPU相同的材料制成，所以和CPU一样快。显然，访问它们是没有时延的。其典型的存储容量是，在32位CPU中为32*32位，而在64位CPU中为64*64位。在这两种情况下，其存储容量都小于1KB。典型情况下，一个处理器包含多个寄存器，某些处理器包含上百个寄存器。
+- 寄存器： 最快、最小和最贵的存储器类型由位于处理器内部的寄存器组成。它们用与CPU相同的材料制成，所以和CPU一样快。显然，访问它们是没有时延的。其典型的存储容量是，在32位CPU中为32x32位，而在64位CPU中为64x64位。在这两种情况下，其存储容量都小于1KB。典型情况下，一个处理器包含多个寄存器，某些处理器包含上百个寄存器。
 
 - 高速缓存，它多数由硬件控制。
 
@@ -197,9 +197,11 @@ CPU 是计算机的大脑，它主要和内存进行交互，从内存中提取
 
     ![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/changpianji.jpg?raw=true)
 
-    有时，还有一些实际上不是磁盘的磁盘，比如固态硬盘（Solid State Disk，SSD）。固态硬盘并没有可以移动的部分，外形也不像唱片那样，并且数据是存储在存储器（闪存）中的。与磁盘唯一的相似之处就是它也存储了大量即使在电源关闭时也不会丢失的数据。
-
-这里要说一下闪存(flash memory)，在便捷式电子设备中，闪存通常作为存储媒介。闪存是数吗相机中的胶卷。是便捷式音乐播放器的磁盘。这仅仅是闪存用途的两项。闪存在速度上介于RAM和磁盘之间。另外，与磁盘存储器不同的是，如果闪存擦除次数过多，就被磨损了。
+    有时，还有一些实际上不是磁盘的磁盘，比如固态硬盘（Solid State Disk，SSD）。固态硬盘并没有可以移动的部分，外形也不像唱片那样，并且数据是存储在存储器（闪存）中的。与磁盘唯一的相似之处就是它也存储了大量即使在电源关闭时也不会丢失的数据。  
+    
+    这里要说一下闪存(flash memory)，闪存是一种基于硅芯片的存储介质，可以用电写入或擦除。在便捷式电子设备中，闪存通常作为存储媒介。闪存是数吗相机中的胶卷。是便捷式音乐播放器的磁盘。这仅仅是闪存用途的两项。闪存在速度上介于RAM和磁盘之间。另外，与磁盘存储器不同的是，如果闪存擦除次数过多，就被磨损了。
+    
+    那闪存和固态硬盘有什么区别？固态硬盘也是将数据存储在闪存中。在存储行业中使用的最简单的类比之一是闪存就像鸡蛋，而SSD硬盘就像煎蛋卷一样。煎蛋卷主要是由鸡蛋制作的，而SSD硬盘主要由闪存支制成的。
 
 
 
@@ -223,11 +225,11 @@ CPU 是计算机的大脑，它主要和内存进行交互，从内存中提取
 
 - RAM(Random-access memory) 
 
-    随机存取存储器，一般使用动态半导体存储器件（DRAM），对于CPU来说，RAM是主要存放数据和程序的地方，所以也叫做“主存”，因为CPU工作的速度比RAM的读写速度快，所以CPU读写RAM时需要花费时间等待，这样就使CPU的工作速度下降。人们为了提高CPU读写程序和数据的速度，在RAM和CPU之间增加了高速缓存（Cache）部件。Cache的内容是随机存储器（RAM）中部分存储单元内容的副本
+    随机存取存储器，一般使用动态半导体存储器件（DRAM），对于CPU来说，RAM是主要存放数据和程序的地方，所以也叫做“主存”。
 
 - ROM(Read-Only Memory)
 
-    只读存储器，出厂时其内容由厂家用掩膜技术写好，只可读出，但无法改写。信息已固化在存储器中，一般用于存放系统程序BIOS和用于微程序，断电也没有关系，放ROM的数据一辈子都不会变
+    只读存储器，出厂时其内容由厂家用掩膜技术写好，只可读出，但无法改写。信息已固化在存储器中，一般用于存放系统程序BIOS和用于微程序，断电也没有关系，放ROM的数据一辈子都不会变。
 
 
 
@@ -241,7 +243,7 @@ CPU 是计算机的大脑，它主要和内存进行交互，从内存中提取
 
 
 
-缓存基本上都是采用SRAM存储器，SRAM是英文Static  RAM的缩写，它是一种具有静态存取功能的存储器，不需要刷新电路即能保存它内部存储的数据。不像DRAM内存那样需要刷新电路，每隔一段时间，固定要对DRAM刷新充电一次，否则内部的数据即会消失，因此SRAM具有较高的性能，但是SRAM也有它的缺点，即它的集成度较低，相同容量的DRAM内存可以设计为较小的体积，但是SRAM却需要很大的体积，这也是不能将缓存容量做得太大的重要原因。它的特点归纳如下：优点是节能、速率快、不必配合内存刷新电路、可提高整体的工作效率，缺点是集成度低、相同的容量体积较大、而且价格较高，只能少量用于关键性系统以提高效率。
+缓存基本上都是采用SRAM存储器，它是一种具有静态存取功能的存储器，不需要刷新电路即能保存它内部存储的数据。不像DRAM内存那样需要刷新电路，每隔一段时间，固定要对DRAM刷新充电一次，否则内部的数据即会消失，因此SRAM具有较高的性能，但是SRAM也有它的缺点，即它的集成度较低，相同容量的DRAM内存可以设计为较小的体积，但是SRAM却需要很大的体积，这也是不能将缓存容量做得太大的重要原因。它的特点归纳如下：优点是节能、速率快、不必配合内存刷新电路、可提高整体的工作效率，缺点是集成度低、相同的容量体积较大、而且价格较高，只能少量用于关键性系统以提高效率。
 
 
 
@@ -272,7 +274,7 @@ CPU 是计算机的大脑，它主要和内存进行交互，从内存中提取
 
 
 
-
+- [下一篇:2.进程与线程][https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/2.%E8%BF%9B%E7%A8%8B%E4%B8%8E%E7%BA%BF%E7%A8%8B.md]
 
 
 
diff --git "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md" "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
index 5f19d32d..92e17b16 100644
--- "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
+++ "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
@@ -294,7 +294,9 @@
 
 
 
+- [上一篇:1.操作系统简介][https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/1.%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E7%AE%80%E4%BB%8B.md]
 
+- [下一篇:2.进程与线程][https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/2.%E8%BF%9B%E7%A8%8B%E4%B8%8E%E7%BA%BF%E7%A8%8B.md]
 
 
 ---

From db0f8bb241c36c4701b22274b39d6572986954e7 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 26 Nov 2020 13:28:20 +0800
Subject: [PATCH 035/213] update operation syste

---
 ...73\347\273\237\347\256\200\344\273\213.md" |   2 +-
 ...13\344\270\216\347\272\277\347\250\213.md" | 137 +++++++++++-------
 ...05\345\255\230\347\256\241\347\220\206.md" |  62 ++++----
 .../4.\350\260\203\345\272\246.md"            |   5 +-
 OperatingSystem/5.I:O.md                      |   3 +
 ...07\344\273\266\347\256\241\347\220\206.md" |   5 +
 ...45\345\274\217\347\263\273\347\273\237.md" |   3 +
 ...8.\350\231\232\346\213\237\346\234\272.md" |  75 +---------
 8 files changed, 137 insertions(+), 155 deletions(-)

diff --git "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md" "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
index b6dd93ea..1129070f 100644
--- "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
+++ "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
@@ -274,7 +274,7 @@ CPU(中央处理器)是计算机的大脑，它主要和内存进行交互，从
 
 
 
-- [下一篇:2.进程与线程][https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/2.%E8%BF%9B%E7%A8%8B%E4%B8%8E%E7%BA%BF%E7%A8%8B.md]
+- [下一篇:2.进程与线程](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/2.%E8%BF%9B%E7%A8%8B%E4%B8%8E%E7%BA%BF%E7%A8%8B.md)
 
 
 
diff --git "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md" "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
index 92e17b16..316d0c47 100644
--- "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
+++ "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
@@ -10,7 +10,7 @@
 
 
 
-进程是60年代初首先由[麻省理工学院](https://baike.baidu.com/item/麻省理工学院)的[MULTICS系统](https://baike.baidu.com/item/MULTICS系统)和IBM公司的[CTSS](https://baike.baidu.com/item/CTSS)/360系统引入的。 [2] 
+进程是60年代初首先由[麻省理工学院](https://baike.baidu.com/item/麻省理工学院)的[MULTICS系统](https://baike.baidu.com/item/MULTICS系统)和IBM公司的[CTSS](https://baike.baidu.com/item/CTSS)/360系统引入的。
 
 进程是一个具有独立功能的程序关于某个数据集合的一次运行活动。它可以申请和拥有系统资源，是一个动态的概念，是一个活动的实体。它不只是程序的[代码](https://baike.baidu.com/item/代码)，还包括当前的活动，通过[程序计数器](https://baike.baidu.com/item/程序计数器)的值和处理[寄存器](https://baike.baidu.com/item/寄存器)的内容来表示。
 
@@ -58,8 +58,6 @@
 
 
 
-进程控制块 (Process Control Block, PCB) 描述进程的基本信息和运行状态，所谓的创建进程和撤销进程，都是指对 PCB 的操作。
-
 ## 进程的状态
 
 
@@ -76,34 +74,22 @@
 
 - 程序段：对应程序的操作代码部分，用于描述进程所需要完成的功能。
 - 数据段：对应程序执行时所需要的数据部分，包括数据，堆栈和工作区。
-- 进程控制块：记录了进程运行时所需要的全部信息，它是进程存在的唯一标识，与进程一一对应。
+- 进程控制块(Process Control Block, PCB) ：描述进程的基本信息和运行状态，记录了进程运行时所需要的全部信息，它是进程存在的唯一标识，与进程一一对应。所谓的创建进程和撤销进程，都是指对 PCB 的操作。
 
-##### 进程控制块
+#### 进程控制块
 
 进程执行的任意时刻，都可由如下元素来表征:  
 
-- 标识符:与进程相关的唯一标识符，用来区分其他进程
-- 状态:若进程正在执行，则进程处于运行态
-- 优先级:相对于其他进程的优先顺序
+- 标识符:与进程相关的唯一标识符，用于标识、区分一个进程，通常有外部标识符和内部标识符两类。外部标识符通常是由字母、数字所组成的一个字符串，用户或其他进程访问该进程时使用。内部标识符是操作系统为每个进程赋予的唯一一个整数，是作为内部识别而设置的。
+- 状态:若进程正在执行，则进程处于运行态。进程状态指明进程当前的状态，作为进程调度和对换时的依据；
+- 优先级:相对于其他进程的优先顺序，说明进程使用CPU的优先级别，其中优先级高的进程将优先获得CPU。
 - 程序计数器:程序中即将执行的下一条指令的地址
 - 内存指针:包括程序代码和进程相关数据的指针，以及与其他进程共享内存块的指针
 - 上下文数据:进程执行时处理器的寄存器中的数据
 - I/O状态信息:包括显式I/O请求、分配给进程的I/O设备和被进程使用的文件列表等
 - 记账信息:包括处理器时间总和、使用的时钟数总和、时间限制、及账号等
 
-上述列表信息存放在一个被称为进程控制块(process control block)的数据结构中，控制块由操作系统创建和管理。进程控制块（PCB）是进程实体的重要组成部分，它记录了操作系统所需要的、用于描述进程情况及控制进程所需要的全部信息。原来不能独立运行的程序或数据，通过 PCB 就可以成为一个可以独立运行的基本单位。系统通过 PCB 感知进程的存在，并对其进行有效管理和控制。系统创建一个新进程时，为它建立一个  PCB；当进程结束时，系统又收回其 PCB，该进程也随之消亡。简单的总结就是进程控制块主要包括下述四个方面的信息：
-
-1. 进程标识符信息：用于标识、区分一个进程，通常有外部标识符和内部标识符两类。外部标识符通常是由字母、数字所组成的一个字符串，用户或其他进程访问该进程时使用。内部标识符是操作系统为每个进程赋予的唯一一个整数，是作为内部识别而设置的。
-
-2. 进程调度信息：用于描述与进程调度有关的状态信息，包括进程状态、进程优先权、调度信息和等待事件等。进程状态指明进程当前的状态，作为进程调度和对换时的依据；进程优先权说明进程使用 CPU 的优先级别，其中优先权高的进程将优先获得  CPU；调度信息描述与进程调度算法相关的信息，如进程等待时间、已运行的时间等；等待事件是指进程由运行态转变为阻塞态时所等待发生的事件。
-
-3. CPU 状态信息：用于保留进程运行时 CPU 的各种信息，使得进程暂停运行后，下次重新运行时能从上次停止的地方继续运行。CPU  状态信息通常包含通用寄存器、控制和状态寄存器、用户栈指针等。CPU  状态字记载了程序执行的状态信息，如条件码、外中断屏蔽标识、执行状态（核心态或用户态）标识等。
-
-4. 进程控制信息(process control information)：包括进程资源、控制机制等一些进程运行时所需要的信息，如:     
-    - 程序和数据地址：该进程的程序和数据所在的内存和外存地址，以便该进程在次运行时，能够找到程序和数据。
-    - 进程同步和通信机制：实现进程同步和通信时所采用的机制，如消息队列指针、信号量等。
-    - 资源清单：除 CPU 外，进程所需的全部资源和已经分配到的资源。
-    - 链接指针：用于指向该进程所在队列的下一个进程的 PCB 首地址。
+上述列表信息存放在一个被称为进程控制块(process control block)的数据结构中，控制块由操作系统创建和管理。系统通过 PCB 感知进程的存在，并对其进行有效管理和控制。系统创建一个新进程时，为它建立一个PCB；当进程结束时，系统又收回其PCB，该进程也随之消亡。
 
 
 
@@ -121,7 +107,9 @@
 
 ## 进程切换
 
+操作系统为了执行进程间的切换，会维护着一张表格，这张表就是 进程表(process table)。每个进程占用一个进程表项。该表项包含了进程状态的重要信息，包括程序计数器、堆栈指针、内存分配状况、所打开文件的状态、账号和调度信息，以及其他在进程由运行态转换到就绪态或阻塞态时所必须保存的信息，从而保证该进程随后能再次启动，就像从未被中断过一样。
 
+**操作系统最底层的就是调度程序**，在它上面有许多进程。所有关于中断处理、启动进程和停止进程的具体细节都隐藏在调度程序中。事实上，调度程序只是一段非常小的程序。
 
 表面上看，进程切换很简单。在某个时刻，操作系统中断一个正在运行的进程，将另一个进程置于运行模式，并把控制权交给后者。然而，这会引发若干个问题。首先，什么事件触发了进程的切换？ 其次，必须认识到模式切换和进程切换键的区别。
 
@@ -159,7 +147,7 @@
 ### 互斥的要求
 
 1. 必须强制实施互斥。在于相同资源或共享对象的临界区有关的所有进程中，一次只允许一个进程进入临界区。
-2. 一个在非临界区停止的进程不能干啥其他进程。
+2. 一个在非临界区停止的进程不能干涉其他进程。
 3. 绝不允许出现需要访问临界区的进程被无限延迟的情况，即不会死锁或饥饿。
 4. 没有进程在临界区中时，任何需要进入临界区的进程必须能够立即进入。
 5. 对相关进程的执行速度和处理器的数量没有任何要求和限制。
@@ -193,24 +181,6 @@
 
 
 
-**操作系统最底层的就是调度程序**，在它上面有许多进程。所有关于中断处理、启动进程和停止进程的具体细节都隐藏在调度程序中。事实上，调度程序只是一段非常小的程序。
-
-
-
-### 进程的实现
-
-操作系统为了执行进程间的切换，会维护着一张表格，这张表就是 `进程表(process table)`。每个进程占用一个进程表项。该表项包含了进程状态的重要信息，包括程序计数器、堆栈指针、内存分配状况、所打开文件的状态、账号和调度信息，以及其他在进程由运行态转换到就绪态或阻塞态时所必须保存的信息，从而保证该进程随后能再次启动，就像从未被中断过一样。
-
-
-
-**操作系统最底层的就是调度程序**，在它上面有许多进程。所有关于中断处理、启动进程和停止进程的具体细节都隐藏在调度程序中。事实上，调度程序只是一段非常小的程序。
-
-
-
-操作系统为了执行进程间的切换，会维护着一张表格，这张表就是 `进程表(process table)`。每个进程占用一个进程表项。该表项包含了进程状态的重要信息，包括程序计数器、堆栈指针、内存分配状况、所打开文件的状态、账号和调度信息，以及其他在进程由运行态转换到就绪态或阻塞态时所必须保存的信息，从而保证该进程随后能再次启动，就像从未被中断过一样。
-
-
-
 ## 进程调度
 
 进程调度就是处理器调度(上下文切换)
@@ -219,15 +189,15 @@
 
 - 高级调度
 
-作业调度,把后备作业调入内存运行
+    作业调度,把后备作业调入内存运行
 
 - 中级调度
 
-在虚拟存储器中引入，在内，外存交换区进行进程对换
+    在虚拟存储器中引入，在内，外存交换区进行进程对换
 
 - 低级调度
 
-进程调度，把就绪队列里的某个进程获得CPU执行权
+    进程调度，把就绪队列里的某个进程获得CPU执行权
 
 ### 调度方式
 
@@ -237,18 +207,18 @@
 
 - 不可剥夺
 
-一单处理器分配给某进程，遍让它一直运行下去，直到进程完成或者发生某种时间而阻塞，才分配给其他进程。
+    一单处理器分配给某进程，遍让它一直运行下去，直到进程完成或者发生某种时间而阻塞，才分配给其他进程。
 
 ### 调度算法
 
 - 先进先出
 
-按照进入就绪队列的进程顺序，不加其他条件干涉
+    按照进入就绪队列的进程顺序，不加其他条件干涉
 
 - 短进程优先
 
-优先选出就绪队列中CPU执行时间最短的进程，例如：就绪队列有4个进程P1，P2，P3，P4，执行时间为：16,12,4,3 按照短进程优先，则周转时间(从进程提交到进程完成的时间间隔)分别为：35,19,7,3
-平均周转时间：16，平均周转时间越小，调度性能越好
+    优先选出就绪队列中CPU执行时间最短的进程，例如：就绪队列有4个进程P1，P2，P3，P4，执行时间为：16,12,4,3 按照短进程优先，则周转时间(从进程提交到进程完成的时间间隔)分别为：35,19,7,3
+    平均周转时间：16，平均周转时间越小，调度性能越好
 
 - 轮转法
     - 简单轮转： 就绪进程按FIFO排队，按照一定时间间隔让处理机分配给队列中的进程，就绪队列中**所有队列均可获得一个时间片的处理器运行**
@@ -274,7 +244,76 @@
 
 
 
+## Android进程结构
+
+如同传统的Linux系统一样，Android的第一个用户空间进程是init，它是所有其他进程的根。然而，Android的init启动的守护进程是不同的，这些守护进程更多的聚焦于底层细节（管理文件系统和硬件访问），而不是高层用户设施，例如调度定时任务。Android还有一层额外的进程，它们运行Dalvik的Java语言环境，负责执行系统中所有以Java实现的部分。
+
+
+
+![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_process.png?raw=true)
+
+
+
+如上图，首先是init进程，它产生了一些底层守护进程。其中一个守护进程是zygote，它是高级Java语言进程的根。Android的init不以传统的方法运行shell，因为典型的Android设备没有本地控制台用于shell访问。作为替代，系统进程adbd监听请求shell访问的远程连接（例如通过USB），按要求为它们创建shell进程。因为Android大部分是用Java语言编写的，所以zygote守护进程以及由它启动的进程是系统的中心。由zygote启动的第一个进程称为system_server，它包含全部核心操作服务，其关键部分是电源管理、包管理、窗口管理和活动管理。
+
+其他进程在需要的时候由zygote创建。这些进程中有一些是“持久的”进程，它们是基本操作系统的组成部分，例如phone进程中的电话栈，它必须保持始终运行。另外的应用程序进程将在系统运行的过程中按需创建和终止。
+
+应用程序通过调用操作系统提供的库与操作系统进行交互，这些库合起来构成Android框架（Android framework）。这些库中有一些可以在进程内部执行其工作，但是许多库需要与其他进程执行进程间通信，作者通常是在system_server进程中提供服务的。
+
+
+
+### Zygote
+
+Zygote是在启动时就运行在DVM上的一个进程。每当出现创建进程的请求时，Zygote就会产生一个新的DVM虚拟机。Zygote通过在内存中尽可能多的共享内容来最小化产生一个新DVM所消耗的时间。通常而言，许多应用程序都会使用核心库的类和相应的堆结构，而这些内容都是只读的。也就是说，被大部分应用程序使用的这些共享数据和类都是只读而不能改变的。因此，当Zygote加载时，就预加载和初始化了应用程序运行时可能用到的Java核心库和资源。当Zygote创建一个新的DVM时，这部分类不会被分配到新内存。Zygote只是简单地把子进程的这些内存页映射到父进程的相应位置。
+
+实际上，几乎不需要更多的映射页。如果一个类被一个子进程自己的DVM改写，那么Zygote会将受影响的内存复制到子进程中。这种即写即复制的行为在使得最大化共享内存的同时，还能保证应用程序间不会相互影响，并在跨应用程序和进程的边界时保证安全性。
+
+
+
+## Android进程模型
+
+
+
+Linux的传统进程模型是用fork指令来创建新进程，然后用exec指令使用待运行的源码初始化该进程并开始执行。shell负责实现进程执行、创建新进程、执行所需的进程来运行shell指令。当指令结束时，进程被从Linux中移除。
+
+Android使用的进程有些不同。活动管理器是Android负责正在运行的应用程序的管理的一部分。活动管理器协调新应用程序进程的启动，决定哪些应用程序能在其中运行，哪些已不再需要。
+
+
+
+### 启动进程
+
+为了启动新进程，活动管理器需要与zygote通信。活动管理器首先开始，它创建一个与zygote相连的专用接口，通过接口发送一条指令，表示它需要启动一个进程。这条指令主要描述需要创建的沙箱、新进程运行所需要的UID以及需要遵守的安全性制约。zygote需要作为根来运行：创建新进程时，它合理配置运行所需的UID，最终下放权限，将进程改为该UID。
+
+![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_start_process.png?raw=true)
+
+上图展示了一个新进程中启动活动的流程： 
+
+1. 某个现有进程（如应用程序启动器）调用活动管理器，发出意图，描述它想要启动的新活动。
+2. 活动管理器要求封装管理器将这个意图解析为一个明确的组件。
+3. 活动管理器判断这个应用程序的进程并未正在运行，然后向zygote请求一个具有合适UID的新锦成。
+4. zygote进行一次fork指令，克隆自己来创造一个新进程，下方权限并配置新进程的UID和沙箱，初始化该进程的Dalvik，使得Java runtime开始完全执行。例如，它需要在fork后启动垃圾收集等线程。
+5. 新进程如今是一个zygote的克隆，并运行着完全配置好的Java环境。它回调活动管理器，询问后者“我该做什么”。
+6. 活动管理器返回即将启动的应用程序的完整信息，如源码位置等。
+7. 新进程读取应用程序的源码，开始运行。
+8. 活动管理器将所有即将进行的操作发送给新进程，在此处为“启动活动X”。
+9. 新进程收到指令，启动活动，实体化合适的Java类并执行。
+
+注意，当活动启动时，应用程序的进程可能正在运行了。在这种情况下，活动管理器会直接跳转到末尾，向该进程发送一条新指令，让它实体化并执行合适的组件。如果合适，这会导致一个额外的活动实例在应用程序中运行。
+
+
+
+### 进程生命周期
+
+活动管理器也负责判断何时进程不再被需要。活动管理器记录一个进程中运行的所有活动、接收器、服务以及内容提供其，据此可判断该进程的重要程度。
+
+Android内核中的内存溢出强制结束指令是使用一个进程的oom_adj进行严格排序，决定哪个进程需要优先强制结束。活动管理器负责基于每个进程的状态，通过将其归类于几个主要用途，从而合理设定器oom_adj。/proc/<pid>/oom_adj:   
+
+- 取值是-17到+15，取值越高，越容易被干掉。如果是-17，则表示不能被kill
+- 该设置参数的存在是为了和旧版本的内核兼容
+
+![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_process_adj.png?raw=true)
 
+让RAM内存不足时，系统已经完成了进程的配置，使得内存溢出强制结束命令优先中止缓存(cache)类型的进程，尝试重新取得足够的所需内存，随后中止界面(home)类别、服务(service)类别，以此类推。在同一个oom_adj水平中，它将优先中止内存占用较大的进程。
 
 
 
@@ -294,9 +333,9 @@
 
 
 
-- [上一篇:1.操作系统简介][https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/1.%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E7%AE%80%E4%BB%8B.md]
+- [上一篇:1.操作系统简介](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/1.%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E7%AE%80%E4%BB%8B.md)
 
-- [下一篇:2.进程与线程][https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/2.%E8%BF%9B%E7%A8%8B%E4%B8%8E%E7%BA%BF%E7%A8%8B.md]
+- [下一篇:2.进程与线程](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/2.%E8%BF%9B%E7%A8%8B%E4%B8%8E%E7%BA%BF%E7%A8%8B.md)
 
 
 ---
diff --git "a/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md" "b/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
index a4b40e39..3a54aa0e 100644
--- "a/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
+++ "b/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
@@ -2,28 +2,31 @@
 
 常用概念: 
 
-- 页框：内存中固定长度的快
-- 页：固定长度的数据库，存储在二级存储器中（如磁盘）。数据页可以临时赋值到内存的页框中。
+- 页框：内存中固定长度的块
+- 页：固定长度的数据块，存储在二级存储器中（如磁盘）。数据页可以临时赋值到内存的页框中。
 - 段：变长数据块，存储在二级存储器中。整个段可以临时复制到内存的一个可用区域中（分段），或可以将一个段分为许多页，然后将每页单独复制到内存中（分段与分页相结合）
 
 
 
-内存管理的主要操作是处理器把程序装入内存中执行。内存管理的功能有：
-1、内存空间的分配与回收：由操作系统完成主存储器空间的分配和管理，使程序员摆脱存储分配的麻烦，提高编程效率。
-2、地址转换：在多道程序环境下，程序中的逻辑地址与内存中的物理地址不可能一致，因此存储管理必须提供地址变换功能，把逻辑地址转换成相应的物理地址。
-3、内存空间的扩充：利用虚拟存储技术或自动覆盖技术，从逻辑上扩充内存。
-4、存储保护：保证各道作业在各自的存储空间内运行，互不干扰。
+## 内存管理的功能
+
+内存管理的主要操作是处理器把程序装入内存中执行。内存管理的功能有：    
+
+1. 内存空间的分配与回收：由操作系统完成主存储器空间的分配和管理，使程序员摆脱存储分配的麻烦，提高编程效率。
+2. 地址转换：在多道程序环境下，程序中的逻辑地址与内存中的物理地址不可能一致，因此存储管理必须提供地址变换功能，把逻辑地址转换成相应的物理地址。
+3. 内存空间的扩充：利用虚拟存储技术或自动覆盖技术，从逻辑上扩充内存。
+4. 存储保护：保证各道作业在各自的存储空间内运行，互不干扰。
 
 
 
 进程对应的内存空间中所包含的5种不同的数据区：  
 
-- 代码段(code segment):又称文本段，用来存放指令，运行代码的一块内存空间。此空间大小在代码运行前就已经确定。内存空间一般属于只读，某些架构的代码也允许可写。
+- 代码段(code segment):用来存放程序运行代码的一块内存空间。此空间大小在代码运行前就已经确定。内存空间一般属于只读，某些架构的代码也允许可写。
 
 - 数据段(data segment): 存储初始化的全局变量和初始化的static变量。数据段中的数据的生存期是随程序持续性(随进程持续性):进程创建就存在，进程死亡就消失。
 
-- BSS段(bss segment)：存储未初始化的全局变量和未初始化的static变量。bss段中数据的生存期随进程持续性。bss段中的数据一般默认为0.
-- rodata段:只读数据 比如 printf 语句中的格式字符串和开关语句的跳转表。也就是常量区。例如，全局作用域中的 const int ival = 10，ival  存放在 .rodata 段；再如，函数局部作用域中的 printf("Hello world %d\n", c); 语句中的格式字符串  "Hello world %d\n"，也存放在 .rodata 段。
+- BSS段(bss segment)：存储未初始化的全局变量和未初始化的static变量。bss段中数据的生存期随进程持续性。bss段中的数据一般默认为0.这里很奇怪，一般的书上都会说全局变量和静态变量是会自动初始化的，怎么突然来了个未初始化的变量？其实变量的初始化可以分为显式初始化和隐式初始化，全局变量和静态变量如果程序员自己不初始化的话也会被初始化，那就是不管什么类型都初始化为默认值，这种没有显示初始化的就是这里所说的未初始化。例如整数型的全局变量未初始化的默认隐式初始化的值为0，都是0就没必要把每个0都存储起来，从而节省磁盘空间，这是BSS的主要作用）。BSS的全称是Block Started by Symbol，它属于静态内存分配。BSS节不包含任何数据，只是简单的维护开始和结束的地址，即总大小，以便内存能在运行时分配并被有效的清零。BSS节在应用程序的二进制映像文件中并不存在，既不占用磁盘空间，而只在运行的时候占用内存空间，所以如果全局变量和静态变量未初始化那么其可执行文件要小很多。
+- rodata段(read only data):常量区，存放只读数据。比如程序中定义为const的全局变量，“Hello Word”的字符串常量。有些系统中rodata段是多个进程共享的，目的是为了提高空间利用率。在有的嵌入式系统中，rodata放在ROM中，运行时直接读取，不须加载到RAM内存中。所以在嵌入式开发中，常将已知的常量系数，表格数据等加以const关键字。存放在ROM中，避免占用RAM空间。
 
 - 堆（heap）：堆是用于存放进程运行中被动态分配的内存段，它的大小并不固定，可动态扩张或缩减。当进程调用malloc、realloc等函数分配内存时，新分配的内存就被动态添加到堆上（堆被扩张）；当利用free等函数释放内存时，被释放的内存从堆中被剔除（堆被缩减）
 
@@ -39,19 +42,17 @@
 
 ![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/memory_1.jpg?raw=true)
 
-Stack 和 Heap 中间有一块 free space，即使没有用，也被占着，那如何才能解放这块区域呢，进入虚拟内存。
-
+Stack 和 Heap 中间有一块 free space，即使没有用，也被占着，那如何才能解放这块区域呢，那就是虚拟内存。
 
-
-Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自互不干涉的进程地址空间。该空间是块大小为4G的线性虚拟空间，用户所看到和接触到的都是该虚拟地址，无法看到实际的物理内存地址。利用这种虚拟地址不但能起到保护操作系统的效果（用户不能直接访问物理内存），而且更重要的是，用户程序可使用比实际物理内存更大的地址空间（具体的原因请看硬件基础部分）。
+Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自互不干涉的进程地址空间。该空间是块大小为4G的线性虚拟空间，用户所看到和接触到的都是该虚拟地址，无法看到实际的物理内存地址。利用这种虚拟地址不但能起到保护操作系统的效果（用户不能直接访问物理内存），而且更重要的是，用户程序可使用比实际物理内存更大的地址空间。
 
 在讨论进程空间细节前，这里先要澄清下面几个问题：
 
-l     第一、4G的进程地址空间被人为的分为两个部分——用户空间与内核空间。用户空间从0到3G（0xC0000000），内核空间占据3G到4G。用户进程通常情况下只能访问用户空间的虚拟地址，不能访问内核空间虚拟地址。只有用户进程进行系统调用（代表用户进程在内核态执行）等时刻可以访问到内核空间。
+1. 4G的进程地址空间被人为的分为两个部分——用户空间与内核空间。用户空间从0到3G（0xC0000000），内核空间占据3G到4G。用户进程通常情况下只能访问用户空间的虚拟地址，不能访问内核空间虚拟地址。只有用户进程进行系统调用（代表用户进程在内核态执行）等时刻可以访问到内核空间。
 
-l     第二、用户空间对应进程，所以每当进程切换，用户空间就会跟着变化；而内核空间是由内核负责映射，它并不会跟着进程改变，是固定的。内核空间地址有自己对应的页表（init_mm.pgd），用户进程各自有不同的页表。
+2. 用户空间对应进程，所以每当进程切换，用户空间就会跟着变化；而内核空间是由内核负责映射，它并不会跟着进程改变，是固定的。内核空间地址有自己对应的页表（init_mm.pgd），用户进程各自有不同的页表。
 
-l     第三、每个进程的用户空间都是完全独立、互不相干的。不信的话，你可以把上面的程序同时运行10次（当然为了同时运行，让它们在返回前一同睡眠100秒吧），你会看到10个进程占用的线性地址一模一样。
+3. 每个进程的用户空间都是完全独立、互不相干的。不信的话，你可以把上面的程序同时运行10次（当然为了同时运行，让它们在返回前一同睡眠100秒吧），你会看到10个进程占用的线性地址一模一样。
 
 
 
@@ -71,7 +72,7 @@ l     第三、每个进程的用户空间都是完全独立、互不相干的
 
     - 程序可能太大而不能放到一个分区中。此时程序员必须使用覆盖技术设计程序，使得任何时候该程序只有一部分需要放到内存中。当需要的模块不在时，用户程序必须把这个模块装入程序的分区，覆盖该分区中的任何程序和数据。
 
-    - 内存的利用率非常低。任何程序，急事很小，都需要占据一个完整的分区。由于装入的数据块小于分区大小，因而导致分区内部存在空间浪费，这种现象称为内部碎片(internal fragmentation)。
+    - 内存的利用率非常低。任何程序，即使很小，都需要占据一个完整的分区。由于装入的数据块小于分区大小，因而导致分区内部存在空间浪费，这种现象称为内部碎片(internal fragmentation)。
 
 - 使用大小不等的分区：大小不等的分区可以缓解上面的两个问题，但是不能完全解决。
 
@@ -83,7 +84,7 @@ l     第三、每个进程的用户空间都是完全独立、互不相干的
 
 为了克服固定分区的确定，提出了动态分区。对于动态分区，分区长度和数量是可变的。程序装入内存时，系统会给它分配一块与其所需容量完全相等的内存空间。但是对于一个64MB的内存，如果装入前三个进程已经占用了很大一部分，剩下的部分对于第四个进程来说又太小，这样在内存的末尾就剩下一个“空洞”。而等第二个进程结束后腾出的足够的空间来装入第四个进程，但是由于第四个进程比第二个进程小，所有这里又形成了另一个小"空洞"。这样最终在内存中就会形成许多小空洞。随着时间的推移，内存中形成了越来越多的碎片，内存的利用率随之下降。这种现象称为外部碎片(external fragmentation)，指在所有分区外的存储空间变成了越来越多的碎片，这与前面所讲的内部碎片正好对应。 
 
-客服外部碎片的一种技术就是压缩(compaction)。操作系统不时的移动进程，使得进程占用的空间连续，并使所有空闲空间连成一片。但是压缩的困难之处在于，它是一个非常费时的过程，且会浪费处理器时间。
+克服外部碎片的一种技术就是压缩(compaction)。操作系统不时的移动进程，使得进程占用的空间连续，并使所有空闲空间连成一片。但是压缩的困难之处在于，它是一个非常费时的过程，且会浪费处理器时间。
 
 
 
@@ -97,9 +98,9 @@ l     第三、每个进程的用户空间都是完全独立、互不相干的
 
 
 
-在大小相等的分区中一个进程在其声明周期中可能占据不同的分区。首次创建一个进程映像时，它被装入内存中的摸个分区。以后该进程可能被换出，当它再次被换入时，可能被指定到与上一次不同的分区中。动态分区也存在同样的情况，压缩后内存中的进程也可能发生移动。因此，进程访问（指令和数据单元）的位置不是固定的。进程被换入或在内存中移动时，指令和数据单元的位置也发生变化。为了解决这个问题，需要区分几种地址类型： 
+在大小相等的分区中一个进程在其声明周期中可能占据不同的分区。首次创建一个进程映像时，它被装入内存中的某个分区。以后该进程可能被换出，当它再次被换入时，可能被指定到与上一次不同的分区中。动态分区也存在同样的情况，压缩后内存中的进程也可能发生移动。因此，进程访问（指令和数据单元）的位置不是固定的。进程被换入或在内存中移动时，指令和数据单元的位置也发生变化。为了解决这个问题，需要区分几种地址类型： 
 
-- 逻辑地址（logical address）是指与当前数据再内存中的物理分配地址无关的访问地址，在执行对内存的访问之前必须把它转换为物理地址。
+- 逻辑地址（logical address）是指与当前数据在内存中的物理分配地址无关的访问地址，在执行对内存的访问之前必须把它转换为物理地址。
 - 相对地址（relative address）是逻辑地址的一个特例，他是相对于某些已知点（通常是程序的开始处）的存储单元。
 - 物理地址（physical address）或绝对地址是数据在内存中的实际位置。
 
@@ -125,7 +126,7 @@ l     第三、每个进程的用户空间都是完全独立、互不相干的
 
 ### 分段
 
-细分用户程序的另一种可选方案是分段。采用分段技术，可以把程序和与其相关的数据划分到几个段（fragment）中。尽管短有最大长度限制，但并不要求所有程序的所有段的长度都相等。和分页一样，采用分段技术时的逻辑地址也是由两部分组成：段号和偏移量。 
+细分用户程序的另一种可选方案是分段。采用分段技术，可以把程序和与其相关的数据划分到几个段（fragment）中。尽管段有最大长度限制，但并不要求所有程序的所有段的长度都相等。和分页一样，采用分段技术时的逻辑地址也是由两部分组成：段号和偏移量。 
 
 由于使用大小不等的段，分段类似于动态分区。在未采用覆盖方案或使用虚存的情况下，为执行一个程序，需要把它的所有段都装入内存。与动态分区不同的是，在分段方案中，一个程序可以占据多个分区，并且这些分区不要求是连续的。分段消除了内部碎片，但是和动态分区一样，他会产生外部碎片。不过由于进程被分成多个小块，因此外部碎片也会很小。
 
@@ -163,7 +164,7 @@ l     第三、每个进程的用户空间都是完全独立、互不相干的
 
 虚拟内存机制使得期望运行大于物理内存的程序称为可能。其方法是将程序放在磁盘上，而将主存作为一种缓存，用来保存最频繁使用的部分程序。这种机制需要快速的映像内存地址，以便把程序生成的地址转换为有关字节在RAM中的物理地址。这种映像由CPU中的一个称为存储器管理单元（Memory Management Unit，MMU）的部件来完成。
 
-**虚拟内存**的**基本思想**是:每个程序都拥有自己的地址空间,这个空间被分割成多个 块,每个块被成为一页或页面.
+**虚拟内存**的**基本思想**是:每个程序都拥有自己的地址空间,这个空间被分割成多个块,每个块被成为一页或页面.
 
 **程序运行时,并不是所有页都在物理内存中**:
 
@@ -204,7 +205,7 @@ l     第三、每个进程的用户空间都是完全独立、互不相干的
 
 #### 2. 放置策略
 
-防止策略决定一个进程块驻留在实存中的什么位置。在纯分页系统或段页式系统中，如何放置通常无关紧要，因为地址转换硬件和内存访问硬件能以相同的效率为任何页框组合执行相应的功能。
+放置策略决定一个进程块驻留在实存中的什么位置。在纯分页系统或段页式系统中，如何放置通常无关紧要，因为地址转换硬件和内存访问硬件能以相同的效率为任何页框组合执行相应的功能。
 
 #### 3. 置换策略
 
@@ -218,15 +219,15 @@ l     第三、每个进程的用户空间都是完全独立、互不相干的
 
 
 
-#### 5.清楚策略
+#### 5.清除策略
 
-与读取策略相反，清楚策略用于确定何时将已修改的一页写回辅存。通常有两种选择： 
+与读取策略相反，清除策略用于确定何时将已修改的一页写回辅存。通常有两种选择： 
 
-- 请求式清楚
+- 请求式清除
 
     只有当一页被选择用于置换时才能被写回辅存。
 
-- 预约式清楚
+- 预约式清除
 
     将这些已修改的多页在需要使用他们所占据的页框之前成批写回辅存。
 
@@ -244,8 +245,7 @@ Android包含了标准Linux内核中内存管理设施的许多扩展，具体
 
 - ASHMem：这个功能提供匿名共享内存，它将内存抽象为文件描述符。文件描述符可以传递给另一个进程以共享内存。
 - Pmen：这个功能分配虚拟内存，使的它在物理上是连续的，因此对于那些不支持虚拟内存的设备非常实用。
-- Low Memory Killer：大部分移动设备不具备置换能力（因为闪存的使用寿命因素）。主存耗尽时，使用大量内存的应用不是让步对内存的使用就是被终结。这个功能可让系统通知应用释放内存，如果应用不配合，则终结应用。
-
+- Low Memory Killer：ndorid基于oomKiller原理所扩展的一个多层次oomKiller，OOMkiller(Out Of Memory Killer)是在Linux系统无法分配新内存的时候，选择性杀掉进程，到oom的时候，系统可能已经不太稳定，而LowMemoryKiller是一种根据内存阈值级别触发的内存回收的机制，在系统可用内存较低时，就会选择性杀死进程的策略，相对OOMKiller，更加灵活。主存耗尽时，使用大量内存的应用不是让步对内存的使用就是被终结。这个功能可让系统通知应用释放内存，如果应用不配合，则终结应用。
 
 
 
@@ -263,6 +263,8 @@ Android包含了标准Linux内核中内存管理设施的许多扩展，具体
 
 
 
+- [上一篇:2.进程和线程](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/2.%E8%BF%9B%E7%A8%8B%E4%B8%8E%E7%BA%BF%E7%A8%8B.md)
+- [下一篇:4.调度](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/4.%E8%B0%83%E5%BA%A6.md)
 
 
 
diff --git "a/OperatingSystem/4.\350\260\203\345\272\246.md" "b/OperatingSystem/4.\350\260\203\345\272\246.md"
index bb435432..568d6cf7 100644
--- "a/OperatingSystem/4.\350\260\203\345\272\246.md"
+++ "b/OperatingSystem/4.\350\260\203\345\272\246.md"
@@ -51,7 +51,7 @@
 
 - 把进程分配到处理器
 
-    假设多处理器的结构是统一的，即没有哪个处理器在访问内核和I/O设备时具有物理上的特别优势，那么最简单的调度方法是把处理器视为一个资源池，并按照要求把进程分配到相应的处理器。但是这样就牵扯到静态还是动态的问题。如果一个进程从被激活到完成，一直被分配给同一个处理器，那么就需要为每个处理器维护一个专门的短程队列。这种方法的优点是调度的开销较小，因为相对于所有进程，关于处理器的分配只进行一次。静态分配的缺点就是一个处理器可能处于空闲状态，这时其队列为空，而另一个处理器却积压了许多工作。为了防止这种情况，需要使用一个公共队列。所有进程都进入一个全局队列，然后调度到任何一个可用的处理器中。这样，在一个进程的声明周期中，它可以在不同的时间于不同的处理器上执行。另一种分配策略是动态负载平衡，在该策略中，线程能在不同处理器所对应的队列之间转移。Linux采用的就是这种动态分配策略。
+    假设多处理器的结构是统一的，即没有哪个处理器在访问内核和I/O设备时具有物理上的特别优势，那么最简单的调度方法是把处理器视为一个资源池，并按照要求把进程分配到相应的处理器。但是这样就牵扯到静态还是动态的问题。如果一个进程从被激活到完成，一直被分配给同一个处理器，那么就需要为每个处理器维护一个专门的短程队列。这种方法的优点是调度的开销较小，因为相对于所有进程，关于处理器的分配只进行一次。静态分配的缺点就是一个处理器可能处于空闲状态，这时其队列为空，而另一个处理器却积压了许多工作。为了防止这种情况，需要使用一个公共队列。所有进程都进入一个全局队列，然后调度到任何一个可用的处理器中。这样，在一个进程的生命周期中，它可以在不同的时间于不同的处理器上执行。另一种分配策略是动态负载平衡，在该策略中，线程能在不同处理器所对应的队列之间转移。Linux采用的就是这种动态分配策略。
 
     
 
@@ -80,6 +80,9 @@
 
 
 
+- [上一篇:3.内存管理](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/3.%E5%86%85%E5%AD%98%E7%AE%A1%E7%90%86.md)
+- [下一篇：5.I/O](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/5.I:O.md)
+
 
 ---
 
diff --git a/OperatingSystem/5.I:O.md b/OperatingSystem/5.I:O.md
index bf043437..2a4e19c2 100644
--- a/OperatingSystem/5.I:O.md
+++ b/OperatingSystem/5.I:O.md
@@ -33,6 +33,9 @@
 
 
 
+- [上一篇:4.调度](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/4.%E8%B0%83%E5%BA%A6.md)
+- [下一篇:6.文件管理](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/6.%E6%96%87%E4%BB%B6%E7%AE%A1%E7%90%86.md)
+
 
 
 
diff --git "a/OperatingSystem/6.\346\226\207\344\273\266\347\256\241\347\220\206.md" "b/OperatingSystem/6.\346\226\207\344\273\266\347\256\241\347\220\206.md"
index 50a05239..3621dd4d 100644
--- "a/OperatingSystem/6.\346\226\207\344\273\266\347\256\241\347\220\206.md"
+++ "b/OperatingSystem/6.\346\226\207\344\273\266\347\256\241\347\220\206.md"
@@ -1,5 +1,7 @@
 # 6.文件管理
 
+
+
 文件管理系统是一组系统软件，它为使用文件的用户和应用程序提供服务，包括文件访问、目录维护和访问控制。文件管理系统通常被视为一个由操作系统提供服务的系统服务，而不是操作系统的一部分，但是在任何系统中，至少有一部分文件管理功能是由操作系统执行的。
 
 
@@ -54,6 +56,9 @@ Android文件系统目录的顶层部分：
 
 
 
+- [上一篇:5.I/O](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/5.I:O.md)
+- [下一篇:7.嵌入式系统](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/7.%E5%B5%8C%E5%85%A5%E5%BC%8F%E7%B3%BB%E7%BB%9F.md)
+
 
 
 
diff --git "a/OperatingSystem/7.\345\265\214\345\205\245\345\274\217\347\263\273\347\273\237.md" "b/OperatingSystem/7.\345\265\214\345\205\245\345\274\217\347\263\273\347\273\237.md"
index 5cddf7fc..e37630e3 100644
--- "a/OperatingSystem/7.\345\265\214\345\205\245\345\274\217\347\263\273\347\273\237.md"
+++ "b/OperatingSystem/7.\345\265\214\345\205\245\345\274\217\347\263\273\347\273\237.md"
@@ -20,6 +20,9 @@ Android是基于Linux内核的一个嵌入式系统，因此我们可以认为An
 
 
 
+- [上一篇:6.文件管理](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/6.%E6%96%87%E4%BB%B6%E7%AE%A1%E7%90%86.md)
+- [下一篇:8.虚拟机](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/8.%E8%99%9A%E6%8B%9F%E6%9C%BA.md)
+
 
 ---
 
diff --git "a/OperatingSystem/8.\350\231\232\346\213\237\346\234\272.md" "b/OperatingSystem/8.\350\231\232\346\213\237\346\234\272.md"
index 73d02145..0945dd88 100644
--- "a/OperatingSystem/8.\350\231\232\346\213\237\346\234\272.md"
+++ "b/OperatingSystem/8.\350\231\232\346\213\237\346\234\272.md"
@@ -52,80 +52,7 @@ DVM运行Java语言的应用和代码。标准的Java编译器将源代码（写
 
 
 
-## Android进程结构
-
-如同传统的Linux系统一样，Android的第一个用户空间进程是init，它是所有其他进程的根。然而，Android的init启动的守护进程是不同的，这些守护进程更多的聚焦于底层细节（管理文件系统和硬件访问），而不是高层用户设施，例如调度定时任务。Android还有一层额外的进程，它们运行Dalvik的Java语言环境，负责执行系统中所有以Java实现的部分。
-
-
-
-![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_process.png?raw=true)
-
-
-
-如上图，首先是init进程，它产生了一些底层守护进程。其中一个守护进程是zygote，它是高级Java语言进程的根。Android的init不以传统的方法运行shell，因为典型的Android设备没有本地控制台用于shell访问。作为替代，系统进程adbd监听请求shell访问的远程连接（例如通过USB），按要求为它们创建shell进程。因为Android大部分是用Java语言编写的，所以zygote守护进程以及由它启动的进程是系统的中心。由zygote启动的第一个进程称为system_server，它包含全部核心操作服务，其关键部分是电源管理、包管理、窗口管理和活动管理。
-
-其他进程在需要的时候由zygote创建。这些进程中有一些是“持久的”进程，它们是基本操作系统的组成部分，例如phone进程中的电话栈，它必须保持始终运行。另外的应用程序进程将在系统运行的过程中按需创建和终止。
-
-应用程序通过调用操作系统提供的库与操作系统进行交互，这些库合起来构成Android框架（Android framework）。这些库中有一些可以在进程内部执行其工作，但是许多库需要与其他进程执行进程间通信，作者通常是在system_server进程中提供服务的。
-
-
-
-### Zygote
-
-Zygote是在启动时就运行在DVM上的一个进程。每当出现创建进程的请求时，Zygote就会产生一个新的DVM虚拟机。Zygote通过在内存中尽可能多的共享内容来最小化产生一个新DVM所消耗的时间。通常而言，许多应用程序都会使用核心库的类和相应的堆结构，而这些内容都是只读的。也就是说，被大部分应用程序使用的这些共享数据和类都是只读而不能改变的。因此，当Zygote加载时，就预加载和初始化了应用程序运行时可能用到的Java核心库和资源。当Zygote创建一个新的DVM时，这部分类不会被分配到新内存。Zygote只是简单地把子进程的这些内存页映射到父进程的相应位置。
-
-实际上，几乎不需要更多的映射页。如果一个类被一个子进程自己的DVM改写，那么Zygote会将受影响的内存复制到子进程中。这种即写即复制的行为在使得最大化共享内存的同时，还能保证应用程序间不会相互影响，并在跨应用程序和进程的边界时保证安全性。
-
-
-
-## Android进程模型
-
-
-
-Linux的传统进程模型是用fork指令来创建新进程，然后用exec指令使用待运行的源码初始化该进程并开始执行。shell负责实现进程执行、创建新进程、执行所需的进程来运行shell指令。当指令结束时，进程被从Linux中移除。
-
-Android使用的进程有些不同。活动管理器是Android负责正在运行的应用程序的管理的一部分。活动管理器协调新应用程序进程的启动，决定哪些应用程序能在其中运行，哪些已不再需要。
-
-
-
-### 启动进程
-
-为了启动新进程，活动管理器需要与zygote通信。活动管理器首先开始，它创建一个与zygote相连的专用接口，通过接口发送一条指令，表示它需要启动一个进程。这条指令主要描述需要创建的沙箱、新进程运行所需要的UID以及需要遵守的安全性制约。zygote需要作为根来运行：创建新进程时，它合理配置运行所需的UID，最终下放权限，将进程改为该UID。
-
-![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_start_process.png?raw=true)
-
-上图展示了一个新进程中启动活动的流程： 
-
-1. 某个现有进程（如应用程序启动器）调用活动管理器，发出意图，描述它想要启动的新活动。
-2. 活动管理器要求封装管理器将这个意图解析为一个明确的组件。
-3. 活动管理器判断这个应用程序的进程并未正在运行，然后向zygote请求一个具有合适UID的新锦成。
-4. zygote进行一次fork指令，克隆自己来创造一个新进程，下方权限并配置新进程的UID和沙箱，初始化该进程的Dalvik，使得Java runtime开始完全执行。例如，它需要在fork后启动垃圾收集等线程。
-5. 新进程如今是一个zygote的克隆，并运行着完全配置好的Java环境。它回调活动管理器，询问后者“我该做什么”。
-6. 活动管理器返回即将启动的应用程序的完整信息，如源码位置等。
-7. 新进程读取应用程序的源码，开始运行。
-8. 活动管理器将所有即将进行的操作发送给新进程，在此处为“启动活动X”。
-9. 新进程收到指令，启动活动，实体化合适的Java类并执行。
-
-注意，当活动启动时，应用程序的进程可能正在运行了。在这种情况下，活动管理器会直接跳转到末尾，向该进程发送一条新指令，让它实体化并执行合适的组件。如果合适，这会导致一个额外的活动实例在应用程序中运行。
-
-
-
-### 进程声明周期
-
-活动管理器也负责判断何时进程不再被需要。活动管理器记录一个进程中运行的所有活动、接收器、服务以及内容提供其，据此可判断该进程的重要程度。
-
-Android内核中的内存溢出强制结束指令是使用一个进程的oom_adj进行严格排序，决定哪个进程需要优先强制结束。活动管理器负责基于每个进程的状态，通过将其归类于几个主要用途，从而合理设定器oom_adj。/proc/<pid>/oom_adj:   
-
-- 取值是-17到+15，取值越高，越容易被干掉。如果是-17，则表示不能被kill
-- 该设置参数的存在是为了和旧版本的内核兼容
-
-![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_process_adj.png?raw=true)
-
-让RAM内存不足时，系统已经完成了进程的配置，使得内存溢出强制结束命令优先中止缓存(cache)类型的进程，尝试重新取得足够的所需内存，随后中止界面(home)类别、服务(service)类别，以此类推。在同一个oom_adj水平中，它将优先中止内存占用较大的进程。
-
-
-
-
+- [上一篇:7.嵌入式系统](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/7.%E5%B5%8C%E5%85%A5%E5%BC%8F%E7%B3%BB%E7%BB%9F.md)
 
 
 ---

From 9dd95c870f9057079e458ed9f1165ce9720d4e75 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Tue, 1 Dec 2020 21:23:03 +0800
Subject: [PATCH 036/213] add android kernal

---
 .../ANR\345\210\206\346\236\220.md"           |  66 ++
 ...04\351\234\262\345\210\206\346\236\220.md" | 105 --
 .../crash\345\210\206\346\236\220.md"         | 126 +++
 ...03\345\261\200\344\274\230\345\214\226.md" |  47 +-
 ...66\346\236\204\347\256\200\344\273\213.md" |   4 +-
 ...73\347\273\237\347\256\200\344\273\213.md" | 141 ++-
 ...13\344\270\216\347\272\277\347\250\213.md" | 187 +++-
 ...05\345\255\230\347\256\241\347\220\206.md" |   4 +-
 OperatingSystem/5.I:O.md                      |  13 +
 ...8.\350\231\232\346\213\237\346\234\272.md" |  37 +-
 ...13\351\227\264\351\200\232\344\277\241.md" | 199 ++++
 ...10\346\201\257\346\234\272\345\210\266.md" | 918 ++++++++++++++++++
 ...roid Framework\346\241\206\346\236\266.md" | 105 ++
 ...ManagerService\347\256\200\344\273\213.md" | 148 +++
 ...10\346\201\257\350\216\267\345\217\226.md" |  60 ++
 ...30\345\210\266\345\237\272\347\241\200.md" |  51 +
 ...30\345\210\266\345\216\237\347\220\206.md" |  16 +
 ...ManagerService\347\256\200\344\273\213.md" | 131 +++
 ...ManagerService\347\256\200\344\273\213.md" |  65 ++
 ...57\345\212\250\350\277\207\347\250\213.md" |   4 +
 ...06\345\217\221\350\257\246\350\247\243.md" |  45 +-
 ...07\347\250\213\350\257\246\350\247\243.md" |  51 +-
 22 files changed, 2369 insertions(+), 154 deletions(-)
 create mode 100644 "AdavancedPart/ANR\345\210\206\346\236\220.md"
 delete mode 100644 "AdavancedPart/Handler\345\257\274\350\207\264\345\206\205\345\255\230\346\263\204\351\234\262\345\210\206\346\236\220.md"
 create mode 100644 "AdavancedPart/crash\345\210\206\346\236\220.md"
 create mode 100644 "OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md"
 create mode 100644 "OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md"
 create mode 100644 "OperatingSystem/AndroidKernal/3.Android Framework\346\241\206\346\236\266.md"
 create mode 100644 "OperatingSystem/AndroidKernal/4.ActivityManagerService\347\256\200\344\273\213.md"
 create mode 100644 "OperatingSystem/AndroidKernal/5.Android\346\266\210\346\201\257\350\216\267\345\217\226.md"
 create mode 100644 "OperatingSystem/AndroidKernal/6.\345\261\217\345\271\225\347\273\230\345\210\266\345\237\272\347\241\200.md"
 create mode 100644 "OperatingSystem/AndroidKernal/7.View\347\273\230\345\210\266\345\216\237\347\220\206.md"
 create mode 100644 "OperatingSystem/AndroidKernal/8.WindowManagerService\347\256\200\344\273\213.md"
 create mode 100644 "OperatingSystem/AndroidKernal/9.PackageManagerService\347\256\200\344\273\213.md"

diff --git "a/AdavancedPart/ANR\345\210\206\346\236\220.md" "b/AdavancedPart/ANR\345\210\206\346\236\220.md"
new file mode 100644
index 00000000..fc8ed472
--- /dev/null
+++ "b/AdavancedPart/ANR\345\210\206\346\236\220.md"
@@ -0,0 +1,66 @@
+# ANR分析
+
+Application Not Responding，字面意思就是应用无响应，稍加解释就是用户的一些操作无法从应用中获取反馈
+
+
+Android系统中的应用被Activity Manager及Window Manager两个系统服务监控着，Android系统会在如下情况展示出ANR的对话框: 
+- Service Timeout:比如前台服务在20s内未执行完成；后台服务超过200没有执行
+- BroadcastQueue Timeout：比如前台广播在10s内未执行完成，后台60s
+- ContentProvider Timeout：内容提供者,在publish过超时10s
+- InputDispatching Timeout: 输入事件分发超时5s，包括按键和触摸事件。
+
+
+
+ANR信息输出到traces.txt文件中
+
+traces.txt文件是一个ANR记录文件，用于开发人员调试，目录位于/data/anr中，无需root权限即可通过pull命令获取，下面的命令可以将traces.txt文件拷贝到当前目录下
+adb pull /data/anr .
+
+
+1) Thread基础信息
+
+输出种包含所有的线程，取其中的一条
+"Thread-1" prio=5 tid=0x00007fde73872800 nid=0x4a03 waiting for monitor entry [0x000000011cb30000]
+   java.lang.Thread.State: BLOCKED (on object monitor)
+    at Test.rightLeft(Test.java:48)
+    - waiting to lock <0x00000007d56540a0> (a Test$LeftObject)
+    - locked <0x00000007d5656180> (a Test$RightObject)
+    at Test$2.run(Test.java:68)
+    at java.lang.Thread.run(Thread.java:745)
+a) "Thread-1" prio=5 tid=0x00007fde73872800 nid=0x4a03 waiting for monitor entry [0x000000011cb30000]
+
+首先描述了线程名是『Thread-1』，然后prio=5表示优先级，tid表示的是线程id，nid表示native层的线程id，他们的值实际都是一个地址，后续给出了对于线程状态的描述，waiting for monitor entry [0x000000011cb30000]这里表示该线程目前处于一个等待进入临界区状态，该临界区的地址是[0x000000011cb30000]
+这里对线程的描述多种多样，简单解释下上面出现的几种状态
+
+    waiting on condition（等待某个事件出现）
+    waiting for monitor entry（等待进入临界区）
+    runnable（正在运行）
+    in Object.wait(处于等待状态)
+
+作者：silentleaf
+链接：https://www.jianshu.com/p/30c1a5ad63a3
+来源：简书
+著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
diff --git "a/AdavancedPart/Handler\345\257\274\350\207\264\345\206\205\345\255\230\346\263\204\351\234\262\345\210\206\346\236\220.md" "b/AdavancedPart/Handler\345\257\274\350\207\264\345\206\205\345\255\230\346\263\204\351\234\262\345\210\206\346\236\220.md"
deleted file mode 100644
index d3ea4562..00000000
--- "a/AdavancedPart/Handler\345\257\274\350\207\264\345\206\205\345\255\230\346\263\204\351\234\262\345\210\206\346\236\220.md"
+++ /dev/null
@@ -1,105 +0,0 @@
-Handler导致内存泄露分析
-===
-
-有关内存泄露请猛戳[内存泄露][1]
-
-```java
-Handler mHandler = new Handler() {
-    @Override
-    public void handleMessage(Message msg) {
-	    // do something.
-    }
-}
-```
-当我们这样创建`Handler`的时候`Android Lint`会提示我们这样一个`warning： In Android, Handler classes should be static or leaks might occur.`。       
-     
-一直以来没有仔细的去分析泄露的原因，先把主要原因列一下：    
-- `Android`程序第一次创建的时候，默认会创建一个`Looper`对象，`Looper`去处理`Message Queue`中的每个`Message`,主线程的`Looper`存在整个应用程序的生命周期.
-- `Hanlder`在主线程创建时会关联到`Looper`的`Message Queue`,`Message`添加到消息队列中的时候`Message(排队的Message)`会持有当前`Handler`引用，
-当`Looper`处理到当前消息的时候，会调用`Handler#handleMessage(Message)`.就是说在`Looper`处理这个`Message`之前，
-会有一条链`MessageQueue -> Message -> Handler -> Activity`，由于它的引用导致你的`Activity`被持有引用而无法被回收
-- **在java中，no-static的内部类会隐式的持有当前类的一个引用。static的内部类则没有。**
-
-## 具体分析
-```java
-public class SampleActivity extends Activity {
-
-  private final Handler mHandler = new Handler() {
-		@Override
-		public void handleMessage(Message msg) {
-		  // do something
-		}
-  }
-
-  @Override
-  protected void onCreate(Bundle savedInstanceState) {
-    super.onCreate(savedInstanceState);
-	// 发送一个10分钟后执行的一个消息
-	mHandler.postDelayed(new Runnable() {
-	  @Override
-	  public void run() { }
-	}, 600000);
-
-	// 结束当前的Activity
-	finish();
-}
-```
-在`finish()`的时候，该`Message`还没有被处理，`Message`持有`Handler`,`Handler`持有`Activity`,这样会导致该`Activity`不会被回收，就发生了内存泄露.
-
-## 解决方法 
-- 通过程序逻辑来进行保护。
-    - 如果`Handler`中执行的是耗时的操作，在关闭`Activity`的时候停掉你的后台线程。线程停掉了，就相当于切断了`Handler`和外部连接的线，
-	`Activity`自然会在合适的时候被回收。 
-    - 如果`Handler`是被`delay`的`Message`持有了引用，那么在`Activity`的`onDestroy()`方法要调用`Handler`的`remove*`方法，把消息对象从消息队列移除就行了。 
-	    - 关于`Handler.remove*`方法
-			- `removeCallbacks(Runnable r)` ——清除r匹配上的Message。    
-			- `removeC4allbacks(Runnable r, Object token)` ——清除r匹配且匹配token（Message.obj）的Message，token为空时，只匹配r。
-			- `removeCallbacksAndMessages(Object token)` ——清除token匹配上的Message。
-			- `removeMessages(int what)` ——按what来匹配     
-			- `removeMessages(int what, Object object)` ——按what来匹配      
-			我们更多需要的是清除以该`Handler`为`target`的所有`Message(Callback)`就调用如下方法即可`handler.removeCallbacksAndMessages(null)`;
-- 将`Handler`声明为静态类。
-    静态类不持有外部类的对象，所以你的`Activity`可以随意被回收。但是不持有`Activity`的引用，如何去操作`Activity`中的一些对象？ 这里要用到弱引用
-	
-```java
-public class MyActivity extends Activity {
-	private MyHandler mHandler;
-
-	@Override
-	protected void onCreate(Bundle savedInstanceState) {
-		super.onCreate(savedInstanceState);
-		mHandler = new MyHandler(this);
-	}
-
-	@Override
-	protected void onDestroy() {
-		// Remove all Runnable and Message.
-		mHandler.removeCallbacksAndMessages(null);
-		super.onDestroy();
-	}
-
-	static class MyHandler extends Handler {
-		// WeakReference to the outer class's instance.
-		private WeakReference<MyActivity> mOuter;
-
-		public MyHandler(MyActivity activity) {
-			mOuter = new WeakReference<MyActivity>(activity);
-		}
-
-		@Override
-		public void handleMessage(Message msg) {
-			MyActivity outer = mOuter.get();
-			if (outer != null) {
-				// Do something with outer as your wish.
-			}
-		}
-	}
-}
-```
-
-[1]:(https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E5%86%85%E5%AD%98%E6%B3%84%E6%BC%8F.md)
-
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
diff --git "a/AdavancedPart/crash\345\210\206\346\236\220.md" "b/AdavancedPart/crash\345\210\206\346\236\220.md"
new file mode 100644
index 00000000..e3dd4ca7
--- /dev/null
+++ "b/AdavancedPart/crash\345\210\206\346\236\220.md"
@@ -0,0 +1,126 @@
+# crash分析
+
+
+## Java Crash流程
+
+1、首先发生crash所在进程，在创建之初便准备好了defaultUncaughtHandler，用来处理Uncaught Exception，并输出当前crash的基本信息；
+2、调用当前进程中的AMP.handleApplicationCrash；经过binder ipc机制，传递到system_server进程；
+3、接下来，进入system_server进程，调用binder服务端执行AMS.handleApplicationCrash；
+4、从mProcessNames查找到目标进程的ProcessRecord对象；并将进程crash信息输出到目录/data/system/dropbox；
+5、执行makeAppCrashingLocked：
+
+创建当前用户下的crash应用的error receiver，并忽略当前应用的广播；
+停止当前进程中所有activity中的WMS的冻结屏幕消息，并执行相关一些屏幕相关操作；
+
+6、再执行handleAppCrashLocked方法：
+
+当1分钟内同一进程连续crash两次时，且非persistent进程，则直接结束该应用所有activity，并杀死该进程以及同一个进程组下的所有进程。然后再恢复栈顶第一个非finishing状态的activity;
+当1分钟内同一进程连续crash两次时，且persistent进程，，则只执行恢复栈顶第一个非finishing状态的activity;
+当1分钟内同一进程未发生连续crash两次时，则执行结束栈顶正在运行activity的流程。
+
+7、通过mUiHandler发送消息SHOW_ERROR_MSG，弹出crash对话框；
+8、到此，system_server进程执行完成。回到crash进程开始执行杀掉当前进程的操作；
+9、当crash进程被杀，通过binder死亡通知，告知system_server进程来执行appDiedLocked()；
+10、最后，执行清理应用相关的四大组件信息。
+
+
+
+- 剩余内存: /proc/meminfo，当系统可用内存小于MemTotal的10%时，非常容易发生OOM和大量GC。
+- PSS和RSS通过/proc/self/smap
+- 虚拟内存: 获取大小/proc/self/status，获取具体的分布/proc/self/maps。
+
+如果应用堆内存和设备内存比较充足，但还出现内存分配失败，则可能跟资源泄露有关。
+- 获取fd的限制数量:/proc/self/limits。一般单个进程允许打开的最大句柄个数为1024，如果超过800需将所有fd和文件名输出日志进行排查。
+- 获取线程数大小：/proc/self/status一个线程一般占2MB的虚拟内存，线程数超过400个比较危险，需要将所有tid和线程名输出到日志进行排查。
+
+
+
+
+
+
+
+Native Crash
+
+    崩溃过程：native crash 时操作系统会向进程发送信号，崩溃信息会写入到 data/tombstones 下，并在 logcat 输出崩溃日志
+    定位：so 库剥离调试信息的话，只有相对位置没有具体行号，可以使用 NDK 提供的 addr2line 或 ndk-stack 来定位
+    addr2line：根据有调试信息的 so 和相对位置定位实际的代码处
+    ndk-stack：可以分析 tombstone 文件，得到实际的代码调用栈
+
+
+
+## ANR
+
+
+
+
+ANR排查流程
+1、Log获取
+1、抓取bugreport
+adb shell bugreport > bugreport.txt
+复制代码
+2、直接导出/data/anr/traces.txt文件
+adb pull /data/anr/traces.txt trace.txt
+复制代码
+2、搜索“ANR in”处log关键点解读
+
+
+发生时间（可能会延时10-20s）
+
+
+pid：当pid=0，说明在ANR之前，进程就被LMK杀死或出现了Crash，所以无法接受到系统的广播或者按键消息，因此会出现ANR
+
+
+cpu负载Load: 7.58 / 6.21 / 4.83
+代表此时一分钟有平均有7.58个进程在等待
+1、5、15分钟内系统的平均负荷
+当系统负荷持续大于1.0，必须将值降下来
+当系统负荷达到5.0，表面系统有很严重的问题
+
+
+cpu使用率
+CPU usage from 18101ms to 0ms ago
+28% 2085/system_server: 18% user + 10% kernel / faults: 8689 minor 24 major
+11% 752/android.hardware.sensors@1.0-service: 4% user + 6.9% kernel / faults: 2 minor
+9.8% 780/surfaceflinger: 6.2% user + 3.5% kernel / faults: 143 minor 4 major
+
+
+上述表示Top进程的cpu占用情况。
+注意
+如果CPU使用量很少，说明主线程可能阻塞。
+3、在bugreport.txt中根据pid和发生时间搜索到阻塞的log处
+----- pid 10494 at 2019-11-18 15:28:29 -----
+复制代码
+4、往下翻找到“main”线程则可看到对应的阻塞log
+"main" prio=5 tid=1 Sleeping
+| group="main" sCount=1 dsCount=0 flags=1 obj=0x746bf7f0 self=0xe7c8f000
+| sysTid=10494 nice=-4 cgrp=default sched=0/0 handle=0xeb6784a4
+| state=S schedstat=( 5119636327 325064933 4204 ) utm=460 stm=51 core=4 HZ=100
+| stack=0xff575000-0xff577000 stackSize=8MB
+| held mutexes=
+复制代码
+上述关键字段的含义如下所示：
+
+tid：线程号
+sysTid：主进程线程号和进程号相同
+Waiting/Sleeping：各种线程状态
+nice：nice值越小，则优先级越高，-17~16
+schedstat：Running、Runable时间(ns)与Switch次数
+utm：该线程在用户态的执行时间(jiffies)
+stm：该线程在内核态的执行时间(jiffies)
+sCount：该线程被挂起的次数
+dsCount：该线程被调试器挂起的次数
+self：线程本身的地址
+
+作者：jsonchao
+链接：https://juejin.cn/post/6844903972587716621
+来源：掘金
+著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
+
+
+
+
+
+
+
+
+
diff --git "a/AdavancedPart/\345\270\203\345\261\200\344\274\230\345\214\226.md" "b/AdavancedPart/\345\270\203\345\261\200\344\274\230\345\214\226.md"
index b5c34641..68dd2232 100644
--- "a/AdavancedPart/\345\270\203\345\261\200\344\274\230\345\214\226.md"
+++ "b/AdavancedPart/\345\270\203\345\261\200\344\274\230\345\214\226.md"
@@ -1,8 +1,34 @@
 布局优化
 ===
 
+布局优化的核心问题就是要解决因布局渲染性能不佳而导致应用卡顿的问题。
+
+
+
+## 绘制原理
+
+Android的绘制主要是借助CPU和GPU结合刷新机制来共同完成。
+
+- CPU负责计算显示内容，包括Measure、Layout等操作，在UI绘制上的缺陷在于容易显示重复的视图组件，这样不仅带来重复的计算操作，而且会占用额外的GPU资源。
+- GPU负责光栅化，将UI元素绘制到屏幕上。
+
+例如，文字首先要经过CPU换算成纹理，然后再传递给GPU进行渲染。而图片是先经过CPU计算，然后加载到内存中，最后再传给GPU进行渲染。
+
+
+## 耗时原因
+分析完布局的加载流程之后，我们发现有如下四点可能会导致布局卡顿：
+
+1. 首先，系统会将我们的Xml文件通过IO的方式映射的方式加载到我们的内存当中，而IO的过程可能会导致卡顿。
+2. 其次，布局加载的过程是一个反射的过程，而反射的过程也会可能会导致卡顿。
+3. 同时，这个布局的层级如果比较深，那么进行布局遍历的过程就会比较耗时。
+4. 最后，不合理的嵌套RelativeLayout布局也会导致重绘的次数过多。
+
+
+## 优化方式
+
 - 去除不必要的嵌套和节点
     这是最基本的一条，但也是最不好做到的一条，往往不注意的时候难免会一些嵌套等。    
+	
 	- 首次不需要的节点设置为`GONE`或使用`ViewStud`.       
 	- 使用`Relativelayout`代替`LinearLayout`.        
 	平时写布局的时候要多注意，写完后可以通过`Hierarchy Viewer`或在手机上通过开发者选项中的显示布局边界来查看是否有不必要的嵌套。
@@ -146,7 +172,26 @@
 
 - 减少不必要的`Inflate`                
     如上一步中`stub.infalte()`后将该`View`进行记录或者是`ListView`中`item inflate`的时候。
-		
+	
+- 使用ConstraintLayout降低布局嵌套层级
+    
+	- 实现几乎完全扁平化的布局
+	- 构建复杂布局性能更高
+	- 具有RelativeLayout和LinearLayout的特性
+	
+- 使用AsyncLayoutInflater异步加载对应的布局
+
+    - 工作线程加载布局
+    - 回调主线程
+    - 节省主线程时间
+
+    AsyncLayoutInflater是通过侧面缓解的方式去缓解布局加载过程中的卡顿，但是它依然存在一些问题：
+
+    - 1、不能设置LayoutInflater.Factory，需要通过自定义AsyncLayoutInflater的方式解决，由于它是一个final，所以需要将代码直接拷处进行修改。
+    - 2、因为是异步加载，所以需要注意在布局加载过程中不能有依赖于主线程的操作。
+    
+
+    
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
diff --git "a/Architect/1.\346\236\266\346\236\204\347\256\200\344\273\213.md" "b/Architect/1.\346\236\266\346\236\204\347\256\200\344\273\213.md"
index f75f78d3..fe4d4cdc 100644
--- "a/Architect/1.\346\236\266\346\236\204\347\256\200\344\273\213.md"
+++ "b/Architect/1.\346\236\266\346\236\204\347\256\200\344\273\213.md"
@@ -21,7 +21,7 @@
 
 #### 规划
 
-规划是系统架构中最重要的组成部分，是个人或者组织制定的比较全民长远的发展计划，是对未来整体性、长期性、基本性问题的思考和考量。设计未来整套行动的方案。很早就有规划这个概念了，例如:国家的十一五规划等。当然软件开发也和生活紧密联系，一个大型的系统也需要良好的规划，规划可以说是基石，是系统架构的前提。 
+规划是系统架构中最重要的组成部分，是个人或者组织制定的比较全面长远的发展计划，是对未来整体性、长期性、基本性问题的思考和考量。设计未来整套行动的方案。很早就有规划这个概念了，例如:国家的十一五规划等。当然软件开发也和生活紧密联系，一个大型的系统也需要良好的规划，规划可以说是基石，是系统架构的前提。 
 
 
 系统架构虽然是软件系统的结构，行为，属性的高级抽象，但其根本就是在需求分析的基础行为下，制定技术框架，对需求的技术实现。 
@@ -29,7 +29,7 @@
 
 
 
-		
+​		
 ---
 - 邮箱 ：charon.chui@gmail.com  
 - Good Luck! 
diff --git "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md" "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
index 1129070f..09bff58c 100644
--- "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
+++ "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
@@ -104,13 +104,45 @@
 
 然后，操作系统询问BIOS，以获得配置信息。对于每种设备，系统检查对应的设备驱动程序是否存在。如果没有，系统要求用户插入含有该驱动程序的CD-ROM（由设备供应商提供）或者从网络上下载驱动程序。一旦有了全部的设备驱动程序，操作系统就将它们调入内核。然后初始化有关表格，创建需要的任何背景进程，并在每个终端上启动登陆程序或GUI。
 
-如果是从普通硬盘启动，可简单列举为如下步骤:  
 
-1. X86 PC开机时CPU处于实模式，开机时会将cs=0xffff，ip=0x0000
-2. 寻址0xFFFF0(ROM BIOS映射区)
-3. 检查RAM、键盘、显示器、磁盘、主板等硬件
-4. 将磁盘0磁道0扇区(操作系统引导扇区)读入0x7c00处
-5. 设置 cs=0x07c0，ip=0x0000开始执行
+
+不同的处理器和硬解系统可能会采用不同的策略，但是通用系统的启动分为三个步骤: 
+
+- 开机并执行bootloader程序
+
+    开机就是给系统开始供电，此时硬件电路会产生一个确定的复位时序，保证CPU是最后一个被复位的器件。为什么CPU要最后被复位呢？ 因为，如果CPU是第一个被复位，则当CPU复位后开始运行时，其他硬件内部的寄存器状态可能还没有准备好，比如磁盘或者内存，那这样就可能出现外围硬件初始化的错误。当正确完成复位后，CPU开始执行第一条指令，该指令所在的内存地址是固定的，这由CPU的制造者指定。不同的CPU可能会从不同的地址获取指令，但这个地址必须是固定的，这个固定的地址所保存的程序往往被称为“引导程序“（Bootloader），因为其作用是装载真正的用户程序。
+
+    至于如何装载，则是一个策略问题，不同的CPU会提供不同的装载方式，比如有的是通过普通的并口存储器，有的则是通过SD卡，但是无论硬件上使用何种接口装载，装载过程必须提供以下信息，具体包括： 
+
+    - 从哪里读取用户程序？
+    - 用户程序的长度是多少？
+    - 装载完用户程序后，应该跳转到哪里，即用户程序的执行入口在哪里？
+
+- 操作系统内核初始化
+
+    执行内核程序，这一步所说的内核程序在上一步中指的就是”用户程序“。因为从CPU的角度来看，除了Bootloader之外的所有程序都是用户程序，只是从软件的角度来看，用户程序被分为”内核程序“和”应用程序“，而本步执行的是内核程序。
+
+    内核程序初始化时执行的操作包括，初始化各种硬件，包括内存、网络接口、显示器、输入设备、然后建立各种内部数据结构，这些数据结构将用于多线程调度及内存的管理等。当内核初始化完毕后就开始运行具体的应用程序了。在一般情况下，习惯于将第一个应用程序称为”Home程序“。
+
+- 执行第一个应用程序
+
+    运行Home程序，比如Windows系统的桌面。之所以称为Home程序，是因为通过该程序可以方便的启动其他应用程序。而传统的Linux系统启动后第一个运行的程序一般是一个Terminal。
+
+
+
+### Android系统启动过程
+
+目前的Android系统大多运行在ARM处理器之上。ARM本身是一个公司的名称，从技术的角度来看，它又是一种微处理器内核的架构。
+
+对于ARM处理器，当复位完毕后，处理器首先还行其片上ROM中的一小块程序。这块ROM的大小一般只有几KB，改段程序就是Bootloader程序，这段程序执行时会根据处理器上一些特定引脚的高低电平状态，选择从何种物理接口上装载用户程序，比如USB口、SD卡、并口Flash等。
+
+多数基于ARM的实际硬件系统，会从并口NAND Flash芯片上的0x00000000地址处装载程序。对于一些小型嵌入式系统而言，该地址中的程序就是最终要执行的用户程序；而对于Android而言，该地址中的程序还不是Android程序，而是一个叫做uboot或者fastboot的程序，其作用是初始化硬件设备，比如网口、SDRAM、RS232等，并提供一些调试功能，比如向NAND Flash中写入新的数据，这可用于开发过程中的内核烧写、升级等。
+
+当uboot（fastboot）被装载后便开始运行，它一般会先检测用户是否按下了某些特别的按键，这些特别按键是uboot在编译时预先预定好的，用于进入调试模式。如果用户没有按这些特殊的按键，则uboot会从NAND Flash中装载Linux内核，装载的地址是在编译uboot时预先约定好的。
+
+Linux内核被装载后，就开始进行内核初始化的过程。
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_power_on_start.png)
 
 
 
@@ -124,11 +156,11 @@ CPU(中央处理器)是计算机的大脑，它主要和内存进行交互，从
 
 使用高级语言编写的程序会在编译后转化成机器语言，然后通过CPU内部的寄存器来处理。不同类型的CPU，其内部寄存器的数量，种类以及寄存器存储的数值范围都是不同的。根据功能的不同，我们可以将寄存器大致划分为八类。
 
-***累加寄存器***：存储执行运算的数据和运算后的数据。
+***累加寄存器简称累加器(Accumulator， AC)***：是一个通用寄存器。存储临时的执行运算的数据和运算后的数据。
 
 ***标志寄存器***：存储运算处理后的CPU的状态。
 
-***程序计数器***：存储下一条指令所在内存的地址。
+***程序计数器(Program Counter, PC)***：存储下一条指令所在内存的地址。
 
 ***基址寄存器***：存储数据内存的起始地址。
 
@@ -136,7 +168,7 @@ CPU(中央处理器)是计算机的大脑，它主要和内存进行交互，从
 
 ***通用寄存器***：存储任意数据。
 
-***指令寄存器***：存储指令。CPU内部使用，程序员无法通过程序对该寄存器进行读写操作。
+***指令寄存器(Instruction Register, IR)***：存储指令，CPU取到的指令存放在处理器的一个寄存器中，这个寄存器就是指令寄存器。CPU内部使用，程序员无法通过程序对该寄存器进行读写操作。
 
 ***栈寄存器***：存储栈区域的起始地址。
 
@@ -171,6 +203,69 @@ CPU(中央处理器)是计算机的大脑，它主要和内存进行交互，从
 
 
 
+假设目前一台机器的处理器包含一个累加器(AC)的数据寄存器，所有指令和数据长度均为16位，使用16位的单元或字来组织存储器。指令格式中有4位是操作码。操作码定义了处理器执行的操作。通过指令格式剩下的12位，来直接访问存储器。
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/cpu_zhiling_1.png)
+
+如上图中的三个指令中的操作码描述了要执行的操作。
+
+下图描述了程序的执行过程。给出的程序片段把地址为940的存储单元中的内容与地址为941的存储单元的内容相加，并将结果保存在后一个单元中。这需要三条指令。 
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/cpu_process_demo.png)
+
+该图中，为把地址为940的存储单元中的内容与地址为941的存储单元中的内容相加，一共需要三个指令周期，每个指令周期都包含一个取指阶段和一个执行阶段。具体步骤为 ： 
+
+1. PC中包含第一条指令的地址为300，该指令内容（值为十六进制数1940）被送入指令寄存器IR中，PC增加1。注意，该处理过程中使用了存储器地址寄存器(MAR)和存储器缓冲寄存器（MBR）。为简单起见，这里未显示这些中间寄存器。
+2. IR中取出操作码，也就是最初的4位（对应到这里的十六进制，就是第一位数也就是1），而在上面1对应的二进制操作码是0001 = 从内存中载入AC。剩下的12位（后三个十六进制数）表示的是地址为940。所以这里的意思就是将存储器940地址的单元加载到AC中。
+3. 然后继续去下一条指令，PC现在是301了，所以要从地址为301的存储单元中取下一条指令，也就是(5941)，同时PC增加1。这条指令是5941，最初的4位操作码是5，对应的二进制是0101，上面的操作码图标中0101 = 从内存中添加到AC。剩下的12位（后三个十六进制数）表示的是地址为941。
+4. 内存地址为941的存储单元中的内容与AC中以前的内容相加，结果保存在AC中。
+5. 接着读下一个指令，现在PC是302了，从302的存储单元中读取下一个指令为2941，PC同时加1.前四位操作码对应的是2，转换成二进制也就是0010 = 将AC存储到内存。后十二位对应的地址是941。所以这条指令的意思就是将AC中的内容存储到地址为941的存储单元中。
+6. 执行指令，将AC中的内容存储到地址为941的存储单元中。现在941存储单元的内容变成了5.
+
+
+
+### 中断
+
+
+
+
+
+所有计算机都提供了允许其他模块（I/O、存储器)中断处理器正常处理过程的机制。中断最初是用于提高处理器效率的一种手段。例如，多数I/O设备都要远慢于处理器，处理器必须暂停并保持空闲，直到打印机完成工作。暂停的时间长度可能相当于成百上千哥不涉及存储器的指令周期，显然，这对于处理器的使用来说是非常浪费的。这种只有一个单独程序的情况，称为单道程序设计。在单道程序设计中处理器话费一定的运行时间进行计算，直到遇到一个I/O指令，这时它必须等到该I/O指令结束后才能继续执行。这种问题是可以避免的，就是存储器可以保存多个程序，在一个程序等待时通过切换去执行其他的程序，这种处理称为多道程序设计或多任务处理。它是现代操作系统的主要方案。多道程序设计的目的是为了让处理器和I/O设备（包括存储设备）同时报出忙状态，以实现最大的效率。
+
+
+
+利用中断功能，处理器可以在I/O操作的执行过程中去执行其他命令。在这期间，如果I/O操作已经完成，此时外部设备在做好服务的准备后，即它准备好从处理器接收更多的数据时，外部设备的I/O模块给处理器发送一个中断请求信号。这时处理器会做出相应，暂停当前程序的处理，转去处理服务于特定I/O设备的程序，这种程序被称为中断处理程序(interupt handler)。在对该设备的服务响应完成后，处理器恢复原来的执行。
+
+从用户程序的角度来看，中断打断了正常执行的序列。中断处理完成后，再回复执行。因此，用户程序并不需要为中断添加任何特殊的代码，处理器和操作系统负责挂起用户程序，然后在同一个地方恢复执行。
+
+为使用中断产生的情况，在指令周期中要增加一个中断阶段。在中断阶段，处理器检查是否有中断发生，即检查是否出现中断信号。若没有中断，处理器继续运行，并在取指周期取当前程序的下一条指令。若有中断，处理器挂起当前程序的执行，并执行一个中断处理程序。这个中断处理程序通常是操作系统的一部分，它确定中断的性质，并执行所需要的操作。
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/cpu_zhiling_intercept.png)
+
+
+
+### 中断处理
+
+
+
+
+
+当I/O设备完成一次I/O操作时，发生以下硬件事件:  
+
+1. 设备给处理器发送一个中断信号。
+2. 处理器在响应中断前结束当前指令的执行。
+3. 处理器对中断进行测试，确定存在未响应的中断，并给提交中断的设备发送确认信号，确认信号允许该设备取消它的中断信号。
+4. 处理器需要准备把控制权转交给中断程序。首先，需要保存从中断点恢复当前程序所需要的信息，要求的最少信息包括程序状态字（PSW）和保存在程序计数器（PC）中的下一条要执行的指令地址，它们被压入系统控制栈。
+5. 处理器把相应此中断的中断处理程序入口地址装入程序计数器。每类中断可由一个中断处理程序，具体取决于计算机系统架构和操作系统的设计。如果有多个中断程序，这一信息可能已包含在最初的中断信号中，否则处理器必须给发中断的设备发送请求，以获取含有所需信息的响应。一旦装入程序计数器，处理器就继续执行下一个指令周期，该指令周期也从取指开始。由于取指是由程序计数器的内容决定的，因此控制权被转交给中断处理程序，该程序会引起以下操作： 
+6. 在这一点，与被中断程序相关的程序计数器和PSW被保存到系统栈中，此外，还有一些其他信息被当做正在执行程序的状态的一部分。特别需要保存处理器寄存器的内容，因为中断处理程序可能会用到这些寄存器，因此所有这些值和任何其他状态信息都需要保存。
+7. 中断处理程序现在可以开始处理中断，其中包括检查与I/O操作相关的状态信息或其他引起中断的事件，还可能包括给I/O设备发送附加命令或应答。
+8. 中断处理结束后，被保存的寄存器值从栈中释放并恢复到寄存器中。
+9. 最后的操作是从栈中恢复PSW和程序计数器的值，因此下一条要执行的指令来自前面被中断的程序。
+
+
+
+
+
 ## 存储器
 
 在任何一种计算机中，第二种主要部件都是存储器。在理想情况下，存储器应该极为迅速（快于执行一条指令，这样CPU就不会受到存储器的限制），充分大并且非常便宜。但是目前的技术无法同时满足这三个目标。
@@ -264,13 +359,41 @@ CPU(中央处理器)是计算机的大脑，它主要和内存进行交互，从
 
 
 
+## Linux系统
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/linux_archi.png)
+
+
+
+## Android系统
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_system_2.png)
+
+
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/![](https://raw.githubusercontent.com/CharonChui/Pictures/master/rtsp_rtp_rtcp.jpeg))
+
+
 
+- 应用和框架：应用开发者最关心这一层及访问低层服务的API。
+- Binder IPC：Binder进程间通信机制允许应用框架打破进程的界限来访问Android系统服务代码，从而允许系统的高层框架API与Android的系统服务进行交互。
+- Android系统服务：框架中大部分能够调用系统服务的接口都向开发者开放，以便开发者能够使用底层的硬件和内核功能。Android系统服务分为两部分：媒体服务处理播放和录制媒体文件，系统服务处理应用所需要的系统功能。
+- 硬件抽象层（HAL）：HAL提供调用核心层设备驱动的标准接口，以便上层代码不需要关心具体驱动和硬件的实现袭击，Android的HAL与标准的HAL基本一致。
+- Linux内核：Linux内核已被裁剪到满足移动环境的需求。
 
 
 
+Android在Linux内核中增加了两个提升电源管理能力的新功能： 报警和唤醒锁。
 
+- 报警功能是在Linux内核中实现的，开发者可通过调用运行库中的报警管理器来进行操作。通过报警管理器，应用可以请求定时叫醒服务。报警管理器是内核服务，目的是让应用即使在系统休眠的情况下也能触发警告提醒。这就使得系统随时可以进入休眠状态以节省电能，即使有一个进程有需要被唤醒的服务。
 
+- 唤醒锁也可以阻止Android系统进入休眠模式。一个应用程序占有一下唤醒锁中的一个：  
+    - full_wake_lock：处理器工作，屏幕亮，键盘亮。
+    - partial_wake_lock:处理器工作，屏幕关，键盘关。
+    - screen_dim_wake_lock:处理工作，屏幕暗，键盘关。
+    - screen_bright_wake_lock：处理器工作，屏幕亮，键盘关。
 
+当应用要求被管理的外设保持供电时，会通过API请求对应的锁。若无唤醒锁存在，系统就会锁定并关闭设备以节省电能。
 
 
 
diff --git "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md" "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
index 316d0c47..83bfc7f2 100644
--- "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
+++ "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
@@ -22,7 +22,11 @@
 
 最后一部分是根本。执行上下文(execution context)又称为进程状态(process state)，是操作系统用来管理和控制进程所需的内部数据。这种内部信息和进程是分开的，因为操作系统信息不允许被进程直接访问。上下文包括操作系统管理进程及处理器正确执行进程所需的所有信息，包括各种处理器寄存器的内容，如程序计数器和数据寄存器。它还包括操作系统使用的信息，如进程优先级及进程是否在等待I/O事件的完成。
 
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/cpu_process.png)
 
+上图是一种进程管理方法。两个进程A和B存在与内存中的某些部分，给每个进程（包含程序、数据和上下文信息）分配了一块存储器区域，并且在由操作系统建立和维护的进程表中进行了记录。进程表包含记录每个进程的表项，表项内容包括指向包含进程的存储块地址的指针，还包括该进程的部分和全部上下文。执行上下文的其余部分存放在别处，可能和进程本身存在一起，通常还可能保存在内存中的一块独立区域。进程索引寄存器（process index register）包含当前正在控制处理器的进程在进程表中的索引。程序计数器（program counter）指向该进程中下一条待执行的指令。基址寄存器中保存该存储器区域的开始地址。
+
+图中表示，进程索引寄存器表明进程B正在执行。以前执行的进程被临时中断，在A中断的同事，所有寄存器的内容被记录在其执行上下文环境中，以后操作系统就可以执行进程切换。恢复进程A的执行。进程切换过程中包括保存B的上下文和恢复A的上下文。在程序计数器中载入指向A的程序区域的值时，进程A自动恢复执行。
 
 在任何多道程序设计系统中，CPU由一个进程快速切换至另一个进程，使每个进程各运行几十或几百毫秒。严格来说，在某一个瞬间，CPU只能运行一个进程。但在1秒钟内，它可能运行多个进程，这样就产生并行的错觉。CPU在各进程之间来回切换，这种快速的切换称为多道程序设计。
 
@@ -68,6 +72,14 @@
 - 新建态：刚刚创建的进程，操作系统还未把他加入可执行进程组，它通常是进程控制块已经创建但还未加载到内存中的新进程
 - 退出态：操作系统从可执行进程组中释放出的进程，要么它自身已停止，要么它因某种原因被取消
 
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/process_state.png)
+
+### 挂起态
+
+当内存中的所有进程都处于堵塞态时，操作系统可把其中的一个进程置为挂起态，并将它移到磁盘。此时内存所释放的空间就可被调入的另一个进程使用。操作系统执行换出操作后，将进程取到内存中的方式有两种：接纳一个新近创建的进程，或调入一个此前挂起的进程。显然，操作系统更倾向于调入一个此前挂起的进程，并为它服务，而非增加系统的总负载数。
+
+挂起进程等价于不在内存中的进程。不在内存中的进程，不论他是否在等待一个时间，都不能立即执行。
+
 ### 进程由哪几部分组成？
 
 进程是程序的一次运行过程，它是由程序段、数据段和进程控制块 PCB 组成的一个实体，其中：
@@ -161,23 +173,23 @@
 
 进程间的信息交换，具体内容分为：控制信息交换和数据交换，控制信息的交换为低级通信，数据的交换为高级通信。
 
+- 信号
 
-
-高级通信方式
+    基本原来是：两个或多个进程可以通过简单的信号进行合作，可以强迫一个进程在某个位置停止，直到它接收到一个特定的信号。
 
 - 共享存储系统
 
-多台服务器访问同一个存储设备的同一分区
+    多台服务器访问同一个存储设备的同一分区
 
 - 消息传递系统
 
-进程与其它的进程进行通信而不必借助共享数据，通过互相发送和接收消息，建立一条通信链路。
+    进程与其它的进程进行通信而不必借助共享数据，通过互相发送和接收消息，建立一条通信链路。
 
 - 管道通信
 
-发送进程以字符流形式将大量数据送入管道，接收进程可从管道接收数据，二者利用管道进行通信，管道是单向的、先进先出的，它把一个进程的输出和另一个进程的输入连接在一起。一个进程（写进程）在管道的尾部写入数据，另一个进程（读进程）从管道的头部读出数据。每次只有一个进程能够真正地进入管道，其他的只能等待。
+    发送进程以字符流形式将大量数据送入管道，接收进程可从管道接收数据，二者利用管道进行通信，管道是单向的、先进先出的，它把一个进程的输出和另一个进程的输入连接在一起。一个进程（写进程）在管道的尾部写入数据，另一个进程（读进程）从管道的头部读出数据。每次只有一个进程能够真正地进入管道，其他的只能等待。
 
-管道分为无名管道和命名管道，前者用于父子进程通信，后者用于任意进程通信。
+    管道分为无名管道和命名管道，前者用于父子进程通信，后者用于任意进程通信。
 
 
 
@@ -230,10 +242,17 @@
 
 ### 产生条件
 
-- 互斥条件 
-- 请求保持
-- 不可剥夺
-- 环路条件
+死锁有三个必要条件： 
+
+- 互斥。一次只有一个进程可以使用一个资源。其他进程不能访问已分配给其他进程的资源。
+- 占有且等待。当一个进程等待其他进程时，继续占有已分配的资源。
+- 不可抢占。不能强行抢占进程已占有的资源。
+
+前三个条件都只是死锁存在的必要条件而非充分条件。要产生死锁，还需要第四个条件： 
+
+- 循环等到。存在一个闭合的进程链，每个进程至少占有此链中下一个进程所需的一个资源。
+
+
 
 ### 解决方法
 
@@ -244,6 +263,51 @@
 
 
 
+## Linux并发机制
+
+Linux为进程间通信和同步提供了各种机制。这里只是几种。
+
+- 管道
+
+    管道是一个环形缓冲区，它允许两个进程以生产者/消费者的模型进行通信。因此，这是一个先进先出的队列，由一个进程写，由另一个进程度。
+
+- 消息
+
+    每个进程都有一个与之相关联的消息队列。当程序视图给一个满队列发送信息时，它会被堵塞。当进程视图从一个空队列读取消息时也回被堵塞。
+
+- 共享内存
+
+    这是虚存中由多个进程共享的一个公共内存块。进程读写共享内存所用的机器指令，与读写虚存空间的其他部分所用的指令相同。每个进程有一个只读或读写的权限。互斥约束不属于共享内存机制的一部分，但必须由使用共享内存的进程提供。
+
+- 信号量
+
+    信号量实际上是以集合的形式创建的，一个信号量集合中有一个或多个信号量。内核自动完成所有需要的操作，在所有操作完成前，任何其他进程都不能访问信号量。
+
+    信号量由如下元素组成: 
+
+    - 信号量的当前值
+    - 在信号量上操作的最后一个进程的进程ID
+    - 等待该信号量的值大于当前值的进程数
+    - 等待该信号量的值为零的进程数
+
+- 信号
+
+    信号是用于向一个进程通知发生异步事件的机制。信号类似于硬件中断，但没有优先级，即内核公平地对待所有的信号。
+
+- 自旋锁
+
+    在Linux中保护临界区的常用技术是自旋锁。在同一个时刻，只有一个线程能够获得自旋锁。其他任何试图获得自旋锁的线程将一直进行尝试（即自旋），知道获得了该锁。
+
+
+
+### Android进程间通信
+
+虽然Linux内核包含很多用于进程间通信（IPC）的机制，但是Adnroid系统在IPC中仍然新增了一个连接器。连接器提供了一个轻量级的远程程序调用功能，它在内存和事务处理方面非常高效，非常适合嵌入式系统。
+
+连接器被用来传递两个进程之间的交互。进程（客户端）组件发起一个调用，调用直接传递给位于内核的连接器，连接器将其传递给目标进程（服务器端）的目标组件，目标进程返回的结果通过连接器传递给发起调用的进程组件。
+
+
+
 ## Android进程结构
 
 如同传统的Linux系统一样，Android的第一个用户空间进程是init，它是所有其他进程的根。然而，Android的init启动的守护进程是不同的，这些守护进程更多的聚焦于底层细节（管理文件系统和硬件访问），而不是高层用户设施，例如调度定时任务。Android还有一层额外的进程，它们运行Dalvik的Java语言环境，负责执行系统中所有以Java实现的部分。
@@ -254,7 +318,7 @@
 
 
 
-如上图，首先是init进程，它产生了一些底层守护进程。其中一个守护进程是zygote，它是高级Java语言进程的根。Android的init不以传统的方法运行shell，因为典型的Android设备没有本地控制台用于shell访问。作为替代，系统进程adbd监听请求shell访问的远程连接（例如通过USB），按要求为它们创建shell进程。因为Android大部分是用Java语言编写的，所以zygote守护进程以及由它启动的进程是系统的中心。由zygote启动的第一个进程称为system_server，它包含全部核心操作服务，其关键部分是电源管理、包管理、窗口管理和活动管理。
+如上图，首先是init进程，它产生了一些底层守护进程，init进程是所有用户进程的鼻祖。其中一个守护进程是zygote，它是高级Java语言进程的根。Android的init不以传统的方法运行shell，因为典型的Android设备没有本地控制台用于shell访问。作为替代，系统进程adbd监听请求shell访问的远程连接（例如通过USB），按要求为它们创建shell进程。因为Android大部分是用Java语言编写的，所以zygote守护进程以及由它启动的进程是系统的中心。由zygote启动的第一个进程称为system_server，它包含全部核心操作服务，其关键部分是电源管理、包管理、窗口管理和活动管理。
 
 其他进程在需要的时候由zygote创建。这些进程中有一些是“持久的”进程，它们是基本操作系统的组成部分，例如phone进程中的电话栈，它必须保持始终运行。另外的应用程序进程将在系统运行的过程中按需创建和终止。
 
@@ -264,10 +328,65 @@
 
 ### Zygote
 
-Zygote是在启动时就运行在DVM上的一个进程。每当出现创建进程的请求时，Zygote就会产生一个新的DVM虚拟机。Zygote通过在内存中尽可能多的共享内容来最小化产生一个新DVM所消耗的时间。通常而言，许多应用程序都会使用核心库的类和相应的堆结构，而这些内容都是只读的。也就是说，被大部分应用程序使用的这些共享数据和类都是只读而不能改变的。因此，当Zygote加载时，就预加载和初始化了应用程序运行时可能用到的Java核心库和资源。当Zygote创建一个新的DVM时，这部分类不会被分配到新内存。Zygote只是简单地把子进程的这些内存页映射到父进程的相应位置。
+系统中运行的第一个Dalvik虚拟机程序叫做zygote，该名称的意义是“一个卵”，因为接下来的所有Dalvik虚拟机进程都是通过这个卵孵化出来的。Zygote是在启动时就运行在DVM上的一个进程。
+
+zygote进程汇总包含两个主要模块，分别如下:   
+
+- Socket服务端：该Socket服务端用于接收启动新的Dalvik进程的命令。
+- Framework共享类及共享资源。当zygote进程启动后，会装载一些共享的类及资源，其中共享类是在preload-classes文件中被定义，共享资源是在preload-resources中被定义。因为zygote进程用于孵化出其他Dalvik进程，因此，这些类和资源装载后，新的Dalvik进程就不需要再装载这些类和资源了，这也就是所谓的共享。
+
+
+
+每当出现创建进程的请求时，Zygote就会产生一个新的DVM虚拟机。Zygote通过在内存中尽可能多的共享内容来最小化产生一个新DVM所消耗的时间。通常而言，许多应用程序都会使用核心库的类和相应的堆结构，而这些内容都是只读的。也就是说，被大部分应用程序使用的这些共享数据和类都是只读而不能改变的。因此，当Zygote加载时，就预加载和初始化了应用程序运行时可能用到的Java核心库和资源。当Zygote创建一个新的DVM时，这部分类不会被分配到新内存。Zygote只是简单地把子进程的这些内存页映射到父进程的相应位置。
 
 实际上，几乎不需要更多的映射页。如果一个类被一个子进程自己的DVM改写，那么Zygote会将受影响的内存复制到子进程中。这种即写即复制的行为在使得最大化共享内存的同时，还能保证应用程序间不会相互影响，并在跨应用程序和进程的边界时保证安全性。
 
+zygote进程对应的具体程序是app_process，该程序存在于system/bin目录下，启动该程序的指令是在init.rc中进行配置的。
+
+
+
+
+
+#### System Server进程
+
+System Server进程是由zygote进程fork而来，System Server是zygote孵化的第一个Dalvik进程，SystemServer仅仅是该进程的别名，而该进程具体对应的程序依然是app_process，因为System是从app_process中孵化出来的。System Server负责启动和管理整个Java framework，SystemServer进程在Android的运行环境中扮演了“神经中枢”的作用，APK应用中能够直接交互的大部分系统服务都在该进程中运行，常见的有WindowManagerServer（WmS）、ActivityManagerSystemService（AmS）、PackageManagerServer（PmS）等，这些系统服务都是以一个线程的方式存在于SystemServer进程中。SystemServer的main()函数会首先创建一个ServerThread对象，该对象是一个线程，然后直接运行该线程。而在ServerThread的run()方法内部真正启动各种服务线程，都有:  
+
+- EntropyService：提供伪随机数
+- PowerManagerService：电源管理服务
+- ActivityManagerService：最核心的服务之一，管理Activity
+- TelephonyRegistry：通过该服务注册电话模块的事件响应，比如重启、关闭、启动等
+- PackageManagerService：程序包管理服务
+- AccountManagerService：账户管理服务，是指联系人账户，而不是Linux系统账户
+- ContentService：ContentProvider服务，提供跨进程数据交互
+- BatteryService：电池管理服务
+- LightsService：自然光强度感应传感器服务
+- VibratorService：振动器服务
+- AlarmManagerService：定时器管理服务，提供定时提醒服务
+- WindowManagerService：Framework最核心的服务之一，负责窗口管理
+- BluetoothService：蓝牙服务
+- DevicePolicyManagerService：提供一些系统级别的设置及属性
+- StatusBarManagerService：状态栏管理服务
+- ClipboardService：系统剪切板服务
+- InputMethodManagerService：输入法管理服务
+- NetStatService：网络状态服务
+- NetworkManagementService：网络管理服务
+- ConnectivityService：网络连接管理服务
+- NotificationManagerService：通知栏管理服务
+- LocationManagerService：地理位置服务
+- AudioService：音频管理服务
+- ....
+
+SystemServer中创建了一个Socket客户端，并有AmS负责管理该客户端，之后所有的Dalvik进程都将通过该Socket客户端间接被启动。当需要启动新的APK进程时，AmS中会通过该Socket客户端向zygote进程的Socket服务端发送一个启动命令，然后zygote会孵化出新的进程。
+
+
+
+
+
+从系统架构的角度来看，先创建一个zygote并加载共享类的资源，然后通过该zygote去孵化新的Dalvik进程，该架构的特点有两个:    
+
+- 每一个进程都是一个Dalvik虚拟机，而Dalvik虚拟机是一个类似于Java虚拟机的程序，并且从开发的过程来看，与标准的Java程序开发基本一致。因此对于程序员来讲，必须要学习新的语言，并可以使用Java程序在过去几十年中已经成熟的各种类库资源。
+- zygote进程预先会装载共享类和共享资源，这些类及资源实际上就是SDK中定义的大部分类和资源，因此，当通过zygote孵化出新的进程后，新的APK进程只需要去装载APK自身包含的类和资源即可，这就有效的解决了多个APK共享Framework资源的问题。
+
 
 
 ## Android进程模型
@@ -302,6 +421,8 @@ Android使用的进程有些不同。活动管理器是Android负责正在运行
 
 
 
+
+
 ### 进程生命周期
 
 活动管理器也负责判断何时进程不再被需要。活动管理器记录一个进程中运行的所有活动、接收器、服务以及内容提供其，据此可判断该进程的重要程度。
@@ -317,7 +438,47 @@ Android内核中的内存溢出强制结束指令是使用一个进程的oom_adj
 
 
 
-## 进程和线程的区别
+### Android系统启动的核心流程如下：
+
+
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/Andriod-Boot-Process.jpg)
+
+
+
+1. 启动电源以及系统启动：当电源按下时引导芯片从预定义的地方（固化在ROM）开始执行（Boot ROM），Boot ROM会去加载引导程序BootLoader到RAM，然后执行。
+
+2. 引导程序BootLoader：BootLoader是在Android系统开始运行前的一个小程序，主要用于把系统OS拉起来并运行。
+3. Linux内核启动：当内核启动时，设置缓存、被保护存储器、计划列表、加载驱动。当其完成系统设置时，会先在系统文件中寻找init.rc文件，并启动init进程。
+4. init进程启动：初始化和启动属性服务，init进程会孵化出eadbd、logd、等用户守护进程，还会启动ServiceManager(binder服务管家)、botanic(开机动画)等服务，并且启动Zygote进程。
+5. Zygote进程启动：zygote进程是Android系统的第一个Java进程（即虚拟机进程），它是所有Java进程的父进程。它会创建JVM并为其注册JNI方法，创建服务器端Socket，启动SystemServer进程。并且，zygote进程在启动的时候会创建DVM或者ART。因此通过从zygote进程fork创建的应用程序进程和systemserver进程都可以在内部获取一个DVM或者ART的实例副本。它还会提前加载类preloadClasses和提前加载资源preloadResouces。
+6. SystemServer进程启动：System Server是zygote孵化的第一个进程，它会启动Binder线程池和SystemServiceManager，并且启动各种系统服务，包括ActivityManager、WindowManager、PackageManager、PowerManager等服务。
+7. Media Server进程，是由init进程fork而来，负责启动和管理整个C++ framework，包括AudioFlinger，Camera Service等服务。
+8. Launcher启动：是zygote孵化的第一个App进程，被SystemServer进程启动的AMS会启动Launcher，Launcher启动后会将已安装应用的快捷图标显示到系统桌面上。zygote还会创建Broweer、Phone、Email等App进程，每个App至少运行在一个进程上。
+
+
+
+对于IPC(Inter-Process Communication,  进程间通信)，Linux现有管道、消息队列、共享内存、套接字、信号量、信号这些IPC机制，Android额外还有Binder  IPC机制，Android OS中的Zygote进程的IPC采用的是Socket机制，在上层system server、media  server以及上层App之间更多的是采用Binder  IPC方式来完成跨进程间的通信。对于Android上层架构中，很多时候是在同一个进程的线程之间需要相互通信，例如同一个进程的主线程与工作线程之间的通信，往往采用的Handler消息机制。
+
+
+
+## 线程
+
+多线程技术是指把执行一个应用程序的进程划分为可以同时运行的多个线程。
+
+
+
+### 进程和线程的区别
+
+进程有如下两个特点: 
+
+-  资源所有权：进程包括存放进程映像的虚拟地址空间，进程映像是程序、数据、栈和进程控制块中定义的属性集。进程总具有对资源的控制权和所有权，这些资源包括内存、I/O通道、I/O设备和文件。操作系统能提供预防进程间发生不必要资源冲突的保护功能。
+- 调度/执行：进程执行时采用一个或多程序的执行路径，不同进程的执行过程会交替执行。因此进程具有执行态和分配给其的优先级，是可被操作系统调度和分派的实体。
+
+上面这两个特点是独立的，因此操作系统能分别处理它们。为了区分这两个特点，通常将分派的单位成为线程或轻量级进程，而将拥有资源所有权的单位成为进程或任务。
+
+- 线程（thread）：可分派的工作单元。它包括处理器上下文环境（包含程序计数器和栈指针）和栈中自身的数据区域。线程顺序执行且可以中断，因此处理器可以转到另一个线程。
+- 进程（process)：一个或多个线程和相关系统资源（如包含程序和代码的存储空间、打开的文件和设备）的集合。它严格对应于一个正在执行的程序的概念。通过把一个应用程序分解成多个线程，程序员可以很大程度上控制应用程序的模块性及相关事件的时间安排。
 
 线程比进程更轻量级，所以它们比进程更容易（更快）创建，也更容易撤销。在许多系统中，创建一个线程比创建一个进程要快10~100倍。
 
diff --git "a/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md" "b/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
index 3a54aa0e..2490734b 100644
--- "a/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
+++ "b/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
@@ -245,11 +245,11 @@ Android包含了标准Linux内核中内存管理设施的许多扩展，具体
 
 - ASHMem：这个功能提供匿名共享内存，它将内存抽象为文件描述符。文件描述符可以传递给另一个进程以共享内存。
 - Pmen：这个功能分配虚拟内存，使的它在物理上是连续的，因此对于那些不支持虚拟内存的设备非常实用。
-- Low Memory Killer：ndorid基于oomKiller原理所扩展的一个多层次oomKiller，OOMkiller(Out Of Memory Killer)是在Linux系统无法分配新内存的时候，选择性杀掉进程，到oom的时候，系统可能已经不太稳定，而LowMemoryKiller是一种根据内存阈值级别触发的内存回收的机制，在系统可用内存较低时，就会选择性杀死进程的策略，相对OOMKiller，更加灵活。主存耗尽时，使用大量内存的应用不是让步对内存的使用就是被终结。这个功能可让系统通知应用释放内存，如果应用不配合，则终结应用。
-
+- Low Memory Killer：andorid基于oomKiller原理所扩展的一个多层次oomKiller。在Android中运行了一个OOM进程，该进程启动时会首先向Linux内核中把自己注册为一个OOM Killer，即当Linux内核的内存管理模块检测到系统内存低的时候会通知已经注册的OOM进程，然后这些OOMkille会选择性杀掉进程，到oom的时候，系统可能已经不太稳定，而LowMemoryKiller是一种根据内存阈值级别触发的内存回收的机制，在系统可用内存较低时，就会选择性杀死进程的策略，相对OOMKiller，更加灵活。主存耗尽时，使用大量内存的应用不是让步对内存的使用就是被终结。这个功能可让系统通知应用释放内存，如果应用不配合，则终结应用。
 
 
 
+Android的底层Linux未采用磁盘虚拟内存机制，程序只能使用屋里内存作为最大内存，所以AmS中采用了自动杀死优先级较低进程的方法以达到释放内存的目的。
 
 
 
diff --git a/OperatingSystem/5.I:O.md b/OperatingSystem/5.I:O.md
index 2a4e19c2..29367863 100644
--- a/OperatingSystem/5.I:O.md
+++ b/OperatingSystem/5.I:O.md
@@ -11,9 +11,22 @@
 执行I/O的三种技术： 
 
 - 程序控制I/O：处理器代表一个进程给I/O模块发送一个I/O命令，该进程进入忙等待，直到操作完成才能继续执行。
+
 - 中断驱动I/O：处理器代表进程向I/O模块发出一个I/O命令。有两种可能性：若来自进程的I/O指令是非堵塞的，则处理器继续执行发出I/O命令的进程的后续指令。若I/O指令是堵塞的，则处理器执行的下一条指令来自操作系统，它将当前的进程设置为堵塞态并调度其他进程。
+
 - 直接存储器访问（DMA）：一个DMA模块控制内存和I/O模块之间的数据交换。为传送一块数据，处理器给DMA模块发请求，且只有在整个数据块传送结束后，它才被中断。
 
+    DMA技术工作流程如下： 
+
+    如果处理器想读或写一块数据时，它通过想DMA模块发送以下信息来给DMA模块发出一条命令: 
+
+    - 请求读操作或写操作的信号，通过在处理器和DMA模块之间使用读写控制线发送。
+    - 相关I/O设备地址，通过数据线发送。
+    - 从存储器中读或向存储器中写的起始地址，在数据线上传送，并由DMA模块保存在其地址寄存器中。
+    - 读或写的字数，也通过数据线传送，并由DMA模块保存在其数据计数寄存器中
+
+    然后处理器继续执行其他工作，此时它已把这个I/O操作委托给DMA模块。DMA模块直接从存储器中或向存储器中逐字传送整块数据，并且数据不再需要通过处理器。传送结束后，DMA模块给处理器发送一个中断信号。因此，只有在传送开始和结束时才会用到处理器。
+
 
 
 ### 磁盘高速缓存
diff --git "a/OperatingSystem/8.\350\231\232\346\213\237\346\234\272.md" "b/OperatingSystem/8.\350\231\232\346\213\237\346\234\272.md"
index 0945dd88..47f61216 100644
--- "a/OperatingSystem/8.\350\231\232\346\213\237\346\234\272.md"
+++ "b/OperatingSystem/8.\350\231\232\346\213\237\346\234\272.md"
@@ -30,11 +30,9 @@ Android平台的虚拟机称为Dalvik，Dalvik VM(DVM)执行格式为Dalvik Exec
 
 虚拟机运行在Linux内核的顶部，它依赖于底层的功能（如线程和底层的内存管理）。Dalvik核心类库的目的是，为那些使用标准Java编程的人员提供熟悉的开发环境，但它是专门为满足小型移动设备的需要而设计的。
 
-
-
 每个Android应用程序都运行在自己的进程中，有自己的Dalvik运行实例。Dalvik是可以在一台设备上高效执行多个副本的虚拟机。 
 
-
+当Java程序运行时，都是由一个虚拟机来解释Java的字节码，它将这些字节码翻译成本地CPU的指令码，然后执行。对Java程序而言，负责解释并执行的就是一个虚拟机，而对于Linux而言，这个进程只是一个普通的进程，它与一个只有一行代码的Hello World可执行程序无本质区别。所以启动一个虚拟机的方法就跟启动任何一个可执行程序的方法是相同的，那就是在命令行下输入可执行程序的名称，并在参数中指定要执行的Java类。而dalvikvm的作用就是创建一个虚拟机并执行参数中指定的Java类。
 
 
 
@@ -50,6 +48,39 @@ DVM运行Java语言的应用和代码。标准的Java编译器将源代码（写
 
 
 
+### DVM示例
+
+下面以一个例子来说明dalvikvm的使用方法: 
+
+1. 首先新建一个Foo.java文件，如下:  
+
+    ```java
+    class Foo {
+        public static void main(String[] args) {
+            System.out.println("Hello dalvik");
+        }
+    }
+    ```
+
+2. 然后编译该文件，并生成jar文件，如下: 
+
+    ```java
+    $ javac Foo.java
+    $ dx --dex --output=foo.jar Foo.class
+    ```
+
+    dx工具的作用是将.class转换为dex文件，因为Dalvik虚拟机所执行的程序不是标准的Jar文件，而是将jar经过特别的转换以提高执行效率，而在转换后就是dex文件。dx工具是Android源码的一部分，其路径是在out目录下。dx执行时,--output参数用于指定jar文件的输出路径，注意该jar文件内部包含已经不是纯粹的.class文件，而是dex格式文件，jar仅仅是zip包。
+
+3. 生成了该jar包后，就可以把该jar包push到设备中，并执行以下命令: 
+
+    ```java
+    $ adb push foo.jar /data/app
+    $ adb shell dalvikvm -cp /data/app/foo.jar Foo
+    Hello dalvik    
+    ```
+
+    以上命令首先将jar包push到/data/app目录下，因为该目录一般用于存放应用程序，接着使用adb shell执行dalvikvm程序。dalvikvm的执行语法是: dalvikvm -cp 类路径 类名，从这里可以感觉到，dalvikvm的作用就像在pc上执行java程序一样。
+
 
 
 - [上一篇:7.嵌入式系统](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/7.%E5%B5%8C%E5%85%A5%E5%BC%8F%E7%B3%BB%E7%BB%9F.md)
diff --git "a/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md" "b/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md"
new file mode 100644
index 00000000..0a6b51a4
--- /dev/null
+++ "b/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md"
@@ -0,0 +1,199 @@
+# 1.Android进程间通信
+
+## Binder简介
+
+Binder，英文的意思是别针、回形针。我们经常用别针把两张纸”别“在一起，而在Android中，Binder用于完成进程间通信（IPC），即把多个进程”别“在一起。比如，普通应用程序可以调用音乐播放服务提供的播放、暂停、停止等功能。Binder工作在Linux层面，属于一个驱动，只是这个驱动不需要硬件，或者说其操作的硬件是基于一小段内存。从线程的角度来讲，Binder驱动代码运行在内核态，客户端程序调用Binder是通过系统调用完成的。
+
+
+
+## Linux进程间通信
+
+无论是Android系统，还是各种Linux衍生系统，各个组件、模块往往运行在各种不同的进程和线程内，这里就必然涉及进程/线程之间的通信。对于IPC(Inter-Process Communication,  进程间通信)，Linux目前有一下这些IPC机制: 
+
+-  管道：在创建时分配一个page大小的内存，缓存区大小比较有限；
+- 消息队列：信息复制两次，额外的CPU消耗；不合适频繁或信息量大的通信；
+- 共享内存：无须复制，共享缓冲区直接付附加到进程虚拟地址空间，速度快；但进程间的同步问题操作系统无法实现，必须各进程利用同步工具解决；
+- 套接字：作为更通用的接口，传输效率低，主要用于不通机器或跨网络的通信；
+- 信号量：常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。
+- 信号: 不适用于信息交换，更适用于进程中断控制，比如非法内存访问，杀死某个进程等；
+
+Android额外还有Binder  IPC机制，Android OS中的Zygote进程的IPC采用的是Socket机制，在上层system server、media  server以及上层App之间更多的是采用Binder。 IPC方式来完成跨进程间的通信。对于Android上层架构中，很多时候是在同一个进程的线程之间需要相互通信，例如同一个进程的主线程与工作线程之间的通信，往往采用的Handler消息机制。所以对于Android最上层架构而言，最常用的通信方式是: 
+
+- Binder
+
+- Socket
+
+    Socket通信方式也是C/S架构，比Binder简单很多。在Android系统中采用Socket通信方式的主要有：
+
+    - zygote：用于孵化进程，system_server创建进程是通过socket向zygote进程发起请求；
+    - installd：用于安装App的守护进程，上层PackageManagerService很多实现最终都是交给它来完成；
+    - lmkd：lowmemorykiller的守护进程，Java层的LowMemoryKiller最终都是由lmkd来完成；
+    - adbd：这个也不用说，用于服务adb；
+    - logcatd:这个不用说，用于服务logcat；
+    - vold：即volume Daemon，是存储类的守护进程，用于负责如USB、Sdcard等存储设备的事件处理。
+
+    等等还有很多，这里不一一列举，Socket方式更多的用于Android framework层与native层之间的通信。Socket通信方式相对于binder比较简单，这里省略。
+
+- Handler
+
+    
+
+## Android为什么要使用Binder
+
+Binder作为Android系统提供的一种IPC机制。首先一个问题就是为什么Linux已经有那么多IPC通信的机制，Android还要用Binder。
+
+**接下来正面回答这个问题，从5个角度来展开对Binder的分析：**
+
+**（1）从性能的角度** **数据拷贝次数：**Binder数据拷贝只需要一次，而管道、消息队列、Socket都需要2次，但共享内存方式一次内存拷贝都不需要；从性能角度看，Binder性能仅次于共享内存。
+
+**（2）从稳定性的角度**
+Binder是基于C/S架构的，简单解释下C/S架构，是指客户端(Client)和服务端(Server)组成的架构，Client端有什么需求，直接发送给Server端去完成，架构清晰明朗，Server端与Client端相对独立，稳定性较好；而共享内存实现方式复杂，没有客户与服务端之别， 需要充分考虑到访问临界资源的并发同步问题，否则可能会出现死锁等问题；从这稳定性角度看，Binder架构优越于共享内存。
+
+仅仅从以上两点，各有优劣，还不足以支撑google去采用binder的IPC机制，那么更重要的原因是：
+
+**（3）从安全的角度**
+传统Linux IPC的接收方无法获得对方进程可靠的UID/PID，从而无法鉴别对方身份；而Android作为一个开放的开源体系，拥有非常多的开发平台，App来源甚广，因此手机的安全显得额外重要；对于普通用户，绝不希望从App商店下载偷窥隐射数据、后台造成手机耗电等等问题，传统Linux IPC无任何保护措施，完全由上层协议来确保。 
+
+Android为每个安装好的应用程序分配了自己的UID，故进程的UID是鉴别进程身份的重要标志，前面提到C/S架构，**Android系统中对外只暴露Client端，Client端将任务发送给Server端，Server端会根据权限控制策略，判断UID/PID是否满足访问权限，目前权限控制很多时候是通过弹出权限询问对话框，让用户选择是否运行**。Android 6.0，也称为Android M，在6.0之前的系统是在App第一次安装时，会将整个App所涉及的所有权限一次询问，只要留意看会发现很多App根本用不上通信录和短信，但在这一次性权限权限时会包含进去，让用户拒绝不得，因为拒绝后App无法正常使用，而一旦授权后，应用便可以胡作非为。
+
+针对这个问题，google在Android M做了调整，不再是安装时一并询问所有权限，而是在App运行过程中，需要哪个权限再弹框询问用户是否给相应的权限，对权限做了更细地控制，让用户有了更多的可控性，但**同时也带来了另一个用户诟病的地方，那也就是权限询问的弹框的次数大幅度增多。**对于Android M平台上，有些App开发者可能会写出让手机异常频繁弹框的App，企图直到用户授权为止，这对用户来说是不能忍的，用户最后吐槽的可不光是App，还有Android系统以及手机厂商，有些用户可能就跳果粉了，这还需要广大Android开发者以及手机厂商共同努力，共同打造安全与体验俱佳的Android手机。
+
+Android中权限控制策略有SELinux等多方面手段。传统IPC只能由用户在数据包里填入UID/PID；另外，可靠的身份标记只有由IPC机制本身在内核中添加。其次传统IPC访问接入点是开放的，无法建立私有通道。从安全角度，Binder的安全性更高。
+
+**说到这，可能有人要反驳**，Android就算用了Binder架构，而现如今Android手机的各种流氓软件，不就是干着这种偷窥隐射，后台偷偷跑流量的事吗？没错，确实存在，但这不能说Binder的安全性不好，因为Android系统仍然是掌握主控权，可以控制这类App的流氓行为，只是对于该采用何种策略来控制，在这方面android的确存在很多有待进步的空间，这也是google以及各大手机厂商一直努力改善的地方之一。在Android 6.0，google对于app的权限问题作为较多的努力，大大收紧的应用权限；另外，在**Google举办的Android Bootcamp 2016**大会中，google也表示在Android 7.0 （也叫Android N）的权限隐私方面会进一步加强加固，比如SELinux，Memory safe language(还在research中)等等，在今年的5月18日至5月20日，google将推出Android N。 
+
+话题扯远了，继续说Binder。
+
+**（4）从语言层面的角度**
+大家多知道Linux是基于C语言(面向过程的语言)，而Android是基于Java语言(面向对象的语句)，而对于Binder恰恰也符合面向对象的思想，将进程间通信转化为通过对某个Binder对象的引用调用该对象的方法，而其独特之处在于Binder对象是一个可以跨进程引用的对象，它的实体位于一个进程中，而它的引用却遍布于系统的各个进程之中。可以从一个进程传给其它进程，让大家都能访问同一Server，就像将一个对象或引用赋值给另一个引用一样。Binder模糊了进程边界，淡化了进程间通信过程，整个系统仿佛运行于同一个面向对象的程序之中。从语言层面，Binder更适合基于面向对象语言的Android系统，对于Linux系统可能会有点“水土不服”。
+
+**另外，Binder是为Android这类系统而生，而并非Linux社区没有想到Binder IPC机制的存在，对于Linux社区的广大开发人员，我还是表示深深佩服，让世界有了如此精湛而美妙的开源系统。**也并非Linux现有的IPC机制不够好，相反地，经过这么多优秀工程师的不断打磨，依然非常优秀，每种Linux的IPC机制都有存在的价值，同时在Android系统中也依然采用了大量Linux现有的IPC机制，根据每类IPC的原理特性，因时制宜，不同场景特性往往会采用其下最适宜的。比如在**Android OS中的Zygote进程的IPC采用的是Socket（套接字）机制**，Android中的**Kill Process采用的signal（信号）机制**等等。而**Binder更多则用在system_server进程与上层App层的IPC交互**。
+
+**(5) 从公司战略的角度**
+
+总所周知，Linux内核是开源的系统，所开放源代码许可协议GPL保护，该协议具有“病毒式感染”的能力，怎么理解这句话呢？受GPL保护的Linux Kernel是运行在内核空间，对于上层的任何类库、服务、应用等运行在用户空间，一旦进行SysCall（系统调用），调用到底层Kernel，那么也必须遵循GPL协议。 
+
+而Android 之父 Andy Rubin对于GPL显然是不能接受的，为此，Google巧妙地将GPL协议控制在内核空间，将用户空间的协议采用Apache-2.0协议（允许基于Android的开发商不向社区反馈源码），同时在GPL协议与Apache-2.0之间的Lib库中采用BSD证授权方法，有效隔断了GPL的传染性，仍有较大争议，但至少目前缓解Android，让GPL止步于内核空间，这是Google在GPL Linux下 开源与商业化共存的一个成功典范。
+
+**有了这些铺垫，我们再说说Binder的今世前缘**
+
+Binder是基于开源的 [OpenBinder](https://link.zhihu.com/?target=http%3A//www.angryredplanet.com/~hackbod/openbinder/docs/html/BinderIPCMechanism.html)实现的，OpenBinder是一个开源的系统IPC机制,最初是由 [Be Inc.](https://link.zhihu.com/?target=https%3A//en.wikipedia.org/wiki/Be_Inc.) 开发，接着由[Palm, Inc.](https://link.zhihu.com/?target=https%3A//en.wikipedia.org/wiki/Palm%2C_Inc.)公司负责开发，现在OpenBinder的作者在Google工作，既然作者在Google公司，在用户空间采用Binder 作为核心的IPC机制，再用Apache-2.0协议保护，自然而然是没什么问题，减少法律风险，以及对开发成本也大有裨益的，那么从公司战略角度，Binder也是不错的选择。
+
+另外，再说一点关于OpenBinder，在2015年OpenBinder以及合入到Linux Kernel主线 3.19版本，这也算是Google对Linux的一点回馈吧。
+
+**综合上述5点，可知Binder是Android系统上层进程间通信的不二选择。**
+
+
+
+**最后，简单讲讲Android Binder架构**
+
+Binder在Android系统中江湖地位非常之高。在Zygote孵化出system_server进程后，在system_server进程中出初始化支持整个Android framework的各种各样的Service，而这些Service从大的方向来划分，分为Java层Framework和Native Framework层(C++)的Service，几乎都是基于BInder IPC机制。
+
+1. **Java framework：作为Server端继承(或间接继承)于Binder类，Client端继承(或间接继承)于BinderProxy类。**例如 ActivityManagerService(用于控制Activity、Service、进程等) 这个服务作为Server端，间接继承Binder类，而相应的ActivityManager作为Client端，间接继承于BinderProxy类。 当然还有PackageManagerService、WindowManagerService等等很多系统服务都是采用C/S架构；
+2. **Native Framework层：这是C++层，作为Server端继承(或间接继承)于BBinder类，Client端继承(或间接继承)于BpBinder。**例如MediaPlayService(用于多媒体相关)作为Server端，继承于BBinder类，而相应的MediaPlay作为Client端，间接继承于BpBinder类。
+
+
+
+**总之，一句话"无Binder不Android"。**
+
+
+
+前面人都说了Binder的优点，我来讲故事
+
+1. 当年Andy Rubin有个公司 Palm 做掌上设备的 就是当年那种PDA 有个系统叫PalmOS 后来palm被收购了以后 Andy Rubin 创立了Android
+
+2. Palm收购过一个公司叫 Be 里面有个移动系统 叫 BeOS 进程通信自己学了个实现 叫Binder 由一个叫 Dianne Hackbod的人开发并维护 后来Binder 也被用到了 PalmOS里
+
+3. Android创立了以后 Andy从Palm带走了一大批人，其中就有Dianne。Dianne成为安卓系统总架构师。
+
+- 如果你是她，你会选择用a.Linux已有的进程通信手段吗？ 不会，要不当年也不会搞个新东西出来 
+
+- 重写一个新东西 也不会 binder反正是自己写的开源库
+
+- 用binder 已经被两个公司用过 而且是自己写的 可靠放心
+
+我是她我就选C
+
+你可以看到 如果当年Dianne没有加入Be 或者Be没有被收购 ，又或者Dianne没有和Andy加入Android 那Android也不一定会用binder。
+
+
+
+## Binder框架
+
+Binder是一种架构，这种架构提供了服务端接口、Binder驱动、客户端接口三个模块。
+
+- 服务端
+
+    一个Binder服务端实际上就是一个Binder类的对象，该对象一旦创建，内部就启动一个隐藏线程。该线程接下来会接收Binder驱动发送的消息，收到消息后，会执行到Binder对象中的onTransact()函数，并按照该函数的参数执行不同的服务代码。因此，要实现一个Binder服务就必须重载onTransact()方法。
+
+    可以想象，重载onTransact()函数的主要内容是把onTransact()函数的参数转换为服务函数的参数，而onTransact()函数的参数来源是客户端调用transact()函数时传入的，因此，如果transact()有固定格式的输入，那么onTransact()就会有固定格式的输出。
+
+- Binder驱动
+
+    任何一个服务端Binder对象被创建时，同时会在Binder驱动中创建一个mRemote对象，该对象的类型也是Binder类。客户端要访问远程服务时，都是通过mRemote对象。
+
+    ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/binder_archi.png)
+
+- 应用程序客户端
+
+    客户端想要访问远程服务，必须获取远程服务在Binder对象中对应的mRemote引用，获得该mRemote对象后，就可以调用其transact()方法，调用该方法后，客户端线程进入Binder驱动，Binder驱动就会挂起当前线程，并向远程服务发送一个消息，消息中包含了客户端传进来的包裹。服务端拿到包裹后，会对包裹进行拆解，然后执行指定的服务函数，执行完毕后，再把执行结果放入客户端提供的reply包裹中。然后服务端向Binder驱动发送一个notify的消息，从而使得客户端线程从Binder驱动的代码区返回到客户端代码区。transact()的最后一个参数的含义是执行IPC调用的模式，分为两种：一种是双向，用常量0表示，其含义是服务端执行完指定的服务后返回一定的数据。另一种是单向，用常量1表示，其含义是不返回任何数据。最后，客户端就可以从reply中解析返回的数据了，同样，返回包裹中包含的数据也必须是有序的，而且这个顺序也必须是服务端和客户端事先约定好的。
+
+    从这里可以看出，对应用程序开发员来说，客户端似乎是直接调用远程服务对应的Binder，而事实上则是通过Binder驱动进行了中转。即存在两个Binder对象，一个是服务端的Binder对象，另一个则是Binder驱动中的Binder对象，所不同的是Binder驱动中的对象不会再额外产生一个线程。
+
+
+
+## Binder IPC原理
+
+
+
+每个Android的进程，只能运行在自己进程所拥有的虚拟地址空间。对应一个4GB的虚拟地址空间，其中3GB是用户空间，1GB是内核空间，当然内核空间的大小是可以通过参数配置调整的。对于用户空间，不同进程之间彼此是不能共享的，而内核空间却是可共享的。Client进程向Server进程通信，恰恰是利用进程间可共享的内核内存空间来完成底层通信工作的，Client端与Server端进程往往采用ioctl等方法跟内核空间的驱动进行交互。
+
+
+
+Binder通信采用C/S架构，从组件视角来说，包含Client、Server、ServiceManager以及binder驱动，其中ServiceManager用于管理系统中的各种服务。架构图如下所示：
+
+![ServiceManager](http://gityuan.com/images/binder/prepare/IPC-Binder.jpg)
+
+可以看出无论是注册服务和获取服务的过程都需要ServiceManager，需要注意的是此处的Service  Manager是指Native层的ServiceManager（C++），并非指framework层的ServiceManager(Java)。ServiceManager是整个Binder通信机制的大管家，是Android进程间通信机制Binder的守护进程，要掌握Binder机制，首先需要了解系统是如何首次[启动Service Manager](http://gityuan.com/2015/11/07/binder-start-sm/)。当Service Manager启动之后，Client端和Server端通信时都需要先[获取Service Manager](http://gityuan.com/2015/11/08/binder-get-sm/)接口，才能开始通信服务。
+
+图中Client/Server/ServiceManage之间的相互通信都是基于Binder机制。既然基于Binder机制通信，那么同样也是C/S架构，则图中的3大步骤都有相应的Client端与Server端。
+
+1. **[注册服务(addService)](http://gityuan.com/2015/11/14/binder-add-service/)**：Server进程要先注册Service到ServiceManager。该过程：Server是客户端，ServiceManager是服务端。
+2. **[获取服务(getService)](http://gityuan.com/2015/11/15/binder-get-service/)**：Client进程使用某个Service前，须先向ServiceManager中获取相应的Service。该过程：Client是客户端，ServiceManager是服务端。
+3. **使用服务**：Client根据得到的Service信息建立与Service所在的Server进程通信的通路，然后就可以直接与Service交互。该过程：client是客户端，server是服务端。
+
+图中的Client,Server,Service Manager之间交互都是虚线表示，是由于它们彼此之间不是直接交互的，而是都通过与[Binder驱动](http://gityuan.com/2015/11/01/binder-driver/)进行交互的，从而实现IPC通信方式。其中Binder驱动位于内核空间，Client,Server,Service Manager位于用户空间。Binder驱动和Service  Manager可以看做是Android平台的基础架构，而Client和Server是Android的应用层，开发人员只需自定义实现client、Server端，借助Android的基本平台架构便可以直接进行IPC通信。
+
+
+
+
+
+
+
+### 2.3 C/S模式
+
+BpBinder(客户端)和BBinder(服务端)都是Android中Binder通信相关的代表，它们都从IBinder类中派生而来，关系图如下：
+
+![Binder关系图](http://gityuan.com/images/binder/prepare/Ibinder_classes.jpg)
+
+- client端：BpBinder.transact()来发送事务请求；
+- server端：BBinder.onTransact()会接收到相应事务。
+
+
+
+
+
+参考: https://www.zhihu.com/question/39440766/answer/93550572
+
+
+
+
+
+
+- [上一篇:7.嵌入式系统](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/7.%E5%B5%8C%E5%85%A5%E5%BC%8F%E7%B3%BB%E7%BB%9F.md)
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md" "b/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md"
new file mode 100644
index 00000000..df78f0cf
--- /dev/null
+++ "b/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md"
@@ -0,0 +1,918 @@
+# 2.Android线程间通信之Handler消息机制
+
+
+Binder/Socket用于进程间通信，而Handler消息机制用于同进程的线程间通信，Handler消息机制是由一组MessageQueue、Message、Looper、Handler共同组成的，为了方便且称之为Handler消息机制。
+
+有人可能会疑惑，为何Binder/Socket用于进程间通信，能否用于线程间通信呢？答案是肯定，对于两个具有独立地址空间的进程通信都可以，当然也能用于共享内存空间的两个线程间通信，这就好比杀鸡用牛刀。接着可能还有人会疑惑，那handler消息机制能否用于进程间通信？答案是不能，Handler只能用于共享内存地址空间的两个线程间通信，即同进程的两个线程间通信。很多时候，Handler是工作线程向UI主线程发送消息，即App应用中只有主线程能更新UI，其他工作线程往往是完成相应工作后，通过Handler告知主线程需要做出相应地UI更新操作，Handler分发相应的消息给UI主线程去完成，如下图：
+
+![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/handler_thread_commun.jpg)
+
+由于工作线程与主线程共享地址空间，即Handler实例对象mHandler位于线程间共享的内存堆上，工作线程与主线程都能直接使用该对象，只需要注意多线程的同步问题。工作线程通过mHandler向其成员变量MessageQueue中添加新Message，主线程一直处于loop()方法内，当收到新的Message时按照一定规则分发给相应的handleMessage()方法来处理。所以说，Handler消息机制用于同进程的线程间通信，其核心是线程间共享内存空间，而不同进程拥有不同的地址空间，也就不能用handler来实现进程间通信。
+
+
+
+消息机制主要包含: 
+
+- Message：消息分为硬件产生的消息(如按钮、触摸)和软件生成的消息；Message中有一个用于处理消息的Handler；
+- MessageQueue：消息队列的主要功能向消息池投递消息(MessageQueue.enqueueMessage)和取走消息池的消息(MessageQueue.next)；MessageQueue有一组待处理的Message；
+- Handler：消息辅助类，主要功能向消息池发送各种消息事件(Handler.sendMessage)和处理相应消息事件(Handler.handleMessage)；Handler中有Looper和MessageQueue。
+- Looper：不断循环执行(Looper.loop)，按分发机制将消息分发给目标处理者。Looper有一个MessageQueue消息队列；
+
+
+首先想一想平时我们是怎么使用的: 
+```java
+private Handler mHandler = new Handler(new Handler.Callback() {
+    @Override
+    public boolean handleMessage(@NonNull Message msg) {
+        // xxxx.
+        return false;
+    }
+});
+
+mHandler.sendMessage(msg);
+```
+
+所以这里分析还是要从Handler开始，主要看它的构造函数和sendMessage()方法:   
+
+## 1. Handler构造函数
+```java
+final Looper mLooper;
+final MessageQueue mQueue;
+@UnsupportedAppUsage
+final Callback mCallback;
+final boolean mAsynchronous;
+@UnsupportedAppUsage
+IMessenger mMessenger;
+
+public Handler() {
+    this(null, false);
+}
+
+public Handler(@Nullable Callback callback) {
+    this(callback, false);
+}
+// 可以设置Looper进来
+public Handler(@NonNull Looper looper) {
+    this(looper, null, false);
+}
+
+public Handler(@Nullable Callback callback, boolean async) {
+	// 匿名类、内部类和本地类都必须申请为static，否则会警告可能出现内存泄露
+    if (FIND_POTENTIAL_LEAKS) {
+        final Class<? extends Handler> klass = getClass();
+        if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
+                (klass.getModifiers() & Modifier.STATIC) == 0) {
+            Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
+                klass.getCanonicalName());
+        }
+    }
+    // 1. 如果不设置Looper对象进来，Looper会通过Looper.myLooper()获取Looper对象
+    mLooper = Looper.myLooper();
+    if (mLooper == null) {
+        throw new RuntimeException(
+            "Can't create handler inside thread " + Thread.currentThread()
+                    + " that has not called Looper.prepare()");
+    }
+    // 获取Looper中的MessageQueue
+    mQueue = mLooper.mQueue;
+    // 回调接口
+    mCallback = callback;
+    // 设置消息是否为异步处理方式，默认都是同步的
+    // If true, the handler calls {@link Message#setAsynchronous(boolean)} for
+    // each {@link Message} that is sent to it or {@link Runnable} that is posted to it.
+    // 如果是异步的会调用Message的setAsynchronous方法，然后在MessageQueue中会判断是不是异步的消息
+    mAsynchronous = async;
+}
+
+```
+
+### 上面看到会通过Looper类的myLooper()获取Looper对象
+
+```java
+// sThreadLocal.get() will return null unless you've called prepare().
+@UnsupportedAppUsage
+static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
+
+public static @Nullable Looper myLooper() {
+    return sThreadLocal.get();
+}
+
+/**
+ * Return the {@link MessageQueue} object associated with the current
+ * thread.  This must be called from a thread running a Looper, or a
+ * NullPointerException will be thrown.
+ */
+public static @NonNull MessageQueue myQueue() {
+    return myLooper().mQueue;
+}
+```
+上面注释写的很明白：除非你调用了prepare()方法，不然sThreadLocal.get()会返回null。那sThreadLocal是啥？ prepare()方法又是干啥的？这里还是分两步: 
+
+#### sThreadLocal
+
+ThreadLocal:线程本地存储区（Thread Local Storage，简称为TLS），每个线程都有自己的私有的本地存储区域，不同线程之间彼此不能访问对方的TLS区域。TLS常用的操作方法:    
+- ThreadLocal.set(T value)：将value存储到当前线程的TLS区域: 
+
+    ```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);
+    }
+    ```
+
+- ThreadLocal.get():获取当前线程TLS区域的数据:  
+  
+  ```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();
+  }
+  ```
+  
+
+而sThreadLocal就是线程本地存储变量，它的意义就是在本线程内的任何对象内保持一致。
+
+
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/var_1.png)
+
+
+
+#### prepare()方法
+
+```java
+public static void prepare() {
+    prepare(true);
+}
+
+private static void prepare(boolean quitAllowed) {
+    if (sThreadLocal.get() != null) {
+        throw new RuntimeException("Only one Looper may be created per thread");
+    }
+    // 这个参数是是否允许退出
+    sThreadLocal.set(new Looper(quitAllowed));
+}
+
+final MessageQueue mQueue;
+final Thread mThread;
+private Looper(boolean quitAllowed) {
+    // 创建MessageQueue，并将quitAllowed传入MessageQueue的构造函数
+    mQueue = new MessageQueue(quitAllowed);
+    // 保存当前的线程
+    mThread = Thread.currentThread();
+}
+```
+从代码上可以看到prepare()方法的作用是创建一个Looper对象，然后将该Looper对象保存到sThreadLocal中。
+
+这里有点麻烦了，我们上面使用的代码中并没有调用Looper.prepare()方法啊，理论上这里应该是null，Handler是无法使用的，为什么我们还能正常使用Handler？Looper.prepare()究竟是什么时候调用的？那我们需要看一下prepare()和prepare(boolean quitAllowed)方法都有哪些地方调用了: 
+
+```java
+/**
+     * Initialize the current thread as a looper, marking it as an
+     * application's main looper. The main looper for your application
+     * is created by the Android environment, so you should never need
+     * to call this function yourself.  See also: {@link #prepare()}
+     */
+public static void prepareMainLooper() {
+    prepare(false);
+    synchronized (Looper.class) {
+        if (sMainLooper != null) {
+            throw new IllegalStateException("The main Looper has already been prepared.");
+        }
+        sMainLooper = myLooper();
+    }
+}
+```
+
+发现在Looper类中有个prepareMainLooper()的方法，注释上面写的也比较清楚，说这是Android运行环境创建的应用程序的主looper，你不能自己调用这个方法，那我们看一下这个方法是从哪里调用的，ActivityThread类中的main函数，看到这个main函数，就知道这个类不简单， 
+
+```java
+/**
+ * This manages the execution of the main thread in an
+ * application process, scheduling and executing activities,
+ * broadcasts, and other operations on it as the activity
+ * manager requests.
+ *
+ * {@hide}
+ */
+public final class ActivityThread extends ClientTransactionHandler {
+    // ....
+        public static void main(String[] args) {
+        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
+
+        // Install selective syscall interception
+        AndroidOs.install();
+
+        // CloseGuard defaults to true and can be quite spammy.  We
+        // disable it here, but selectively enable it later (via
+        // StrictMode) on debug builds, but using DropBox, not logs.
+        CloseGuard.setEnabled(false);
+
+        Environment.initForCurrentUser();
+
+        // Make sure TrustedCertificateStore looks in the right place for CA certificates
+        final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
+        TrustedCertificateStore.setDefaultUserDirectory(configDir);
+
+        Process.setArgV0("<pre-initialized>");
+		// 调用Looper.prepareMainLooper()方法
+        Looper.prepareMainLooper();
+
+        // Find the value for {@link #PROC_START_SEQ_IDENT} if provided on the command line.
+        // It will be in the format "seq=114"
+        long startSeq = 0;
+        if (args != null) {
+            for (int i = args.length - 1; i >= 0; --i) {
+                if (args[i] != null && args[i].startsWith(PROC_START_SEQ_IDENT)) {
+                    startSeq = Long.parseLong(
+                            args[i].substring(PROC_START_SEQ_IDENT.length()));
+                }
+            }
+        }
+        ActivityThread thread = new ActivityThread();
+        thread.attach(false, startSeq);
+
+        if (sMainThreadHandler == null) {
+            sMainThreadHandler = thread.getHandler();
+        }
+
+        if (false) {
+            Looper.myLooper().setMessageLogging(new
+                    LogPrinter(Log.DEBUG, "ActivityThread"));
+        }
+
+        // End of event ActivityThreadMain.
+        Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
+        // Looper.loop()启动
+        Looper.loop();
+
+        throw new RuntimeException("Main thread loop unexpectedly exited");
+    } 
+}    
+```
+
+##### ActivityThread类
+
+从上面ActivityThread类的注释中可以看到说ActivityThread是应用程序的主线程。ActivityThread类是Android APP进程的初始类，它的main函数是这个APP进程的入口。
+
+[ActivityThread类的详细介绍可以参考这篇文章]()，这里就不细说ActivityThread类了，我们只需要知道Android运行环境会启动ActivityThread类，他是主线程，而ActivityThread类中的main函数会调用Looper.prepareMainLooper()和Looper.loop()方法。
+
+
+
+到这里梳理一下上面的TODO： 
+
+1. Looper类构造函数创建MessageQueue
+2. ActivityThread调用了Looper.prepareMainLooper()后又调用了Looper.loop()方法，要分析Looper.loop()方法的实现。 
+
+
+
+#### MessageQueue的实现
+
+```java
+private Looper(boolean quitAllowed) {
+    mQueue = new MessageQueue(quitAllowed);
+    mThread = Thread.currentThread();
+}
+
+public final class MessageQueue {
+    private final boolean mQuitAllowed;
+    private long mPtr; // used by native code
+    // Message中的next指向了下一个Message
+    Message mMessages;
+    private boolean mBlocked;
+    
+    MessageQueue(boolean quitAllowed) {
+        mQuitAllowed = quitAllowed;
+        mPtr = nativeInit();
+    }
+    
+    private native static long nativeInit();
+    private native static void nativeDestroy(long ptr);
+    @UnsupportedAppUsage
+    private native void nativePollOnce(long ptr, int timeoutMillis); /*non-static for callbacks*/
+    private native static void nativeWake(long ptr);
+    private native static boolean nativeIsPolling(long ptr);
+    private native static void nativeSetFileDescriptorEvents(long ptr, int fd, int events);
+}    
+```
+
+MessageQueue中有一个native的方法; 
+
+- nativeInit()
+    - 创建了NativeMessageQueue对象，增加其引用计数，并将NativeMessageQueue指针mPtr保存在Java层的MessageQueue
+    - 创建了Native Looper对象
+    - 调用epoll的epoll_create()/epoll_ctl()来完成对mWakeEventFd和mRequests的可读事件监听
+- nativeDestroy()方法    
+    - 调用RefBase::decStrong()来减少对象的引用计数
+    - 当引用计数为0时，则删除NativeMessageQueue对象
+- nativePollOnce
+    - 调用Looper::pollOnce()来完成，空闲时停留在epoll_wait()方法，用于等待事件发生或者超时
+- nativeWake
+    - 调用Looper::wake()来完成，向管道mWakeEventfd写入字符；
+
+
+
+
+
+#### Looper.loop()方法:
+
+```java
+/**
+* Run the message queue in this thread. Be sure to call
+* {@link #quit()} to end the loop.
+*/
+public static void loop() {
+    // 从sThreadLocal获取当前的Looper
+    final Looper me = myLooper();
+    if (me == null) {
+        throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
+    }
+    // 获取当前Looper的MessageQueue
+    final MessageQueue queue = me.mQueue;
+
+    // 确保在权限检查时是基于本地进程，而不是调用进程
+    // Make sure the identity of this thread is that of the local process,
+    // and keep track of what that identity token actually is.
+    Binder.clearCallingIdentity();
+    final long ident = Binder.clearCallingIdentity();
+
+    // Allow overriding a threshold with a system prop. e.g.
+    // adb shell 'setprop log.looper.1000.main.slow 1 && stop && start'
+    final int thresholdOverride =
+        SystemProperties.getInt("log.looper."
+                                + Process.myUid() + "."
+                                + Thread.currentThread().getName()
+                                + ".slow", 0);
+
+    boolean slowDeliveryDetected = false;
+	// 不断去循环执行
+    for (;;) {
+        // 去MessageQueue中的下一个Message，可能会堵塞
+        Message msg = queue.next(); // might block
+        // 没有消息就退出该循环
+        if (msg == null) {
+            // No message indicates that the message queue is quitting.
+            return;
+        }
+
+        // This must be in a local variable, in case a UI event sets the logger
+        final Printer logging = me.mLogging;
+        if (logging != null) {
+            logging.println(">>>>> Dispatching to " + msg.target + " " +
+                            msg.callback + ": " + msg.what);
+        }
+
+        try {
+            // 分发Message，Message.target是Message中保存的当前handler对象，这里相对于调用Handler的dispatchMessage(msg)方法
+            msg.target.dispatchMessage(msg);
+            if (observer != null) {
+                observer.messageDispatched(token, msg);
+            }
+            dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
+        } catch (Exception exception) {
+            if (observer != null) {
+                observer.dispatchingThrewException(token, msg, exception);
+            }
+            throw exception;
+        } finally {
+            ThreadLocalWorkSource.restore(origWorkSource);
+            if (traceTag != 0) {
+                Trace.traceEnd(traceTag);
+            }
+        }
+ 		// 恢复调用者信息
+        // Make sure that during the course of dispatching the
+        // identity of the thread wasn't corrupted.
+        final long newIdent = Binder.clearCallingIdentity();
+		// 将Message放入消息池
+        msg.recycleUnchecked();
+    }
+}
+
+// Looper的quit方法是调用MessageQueue.quit()方法
+public void quit() {
+    mQueue.quit(false);
+}
+
+
+public void quitSafely() {
+    mQueue.quit(true);
+}
+```
+
+loop()进入循环模式，不断重复下面的操作，直到没有消息时退出循环
+
+- 读取MessageQueue的下一条Message；
+- 把Message分发给相应的target；
+- 再把分发后的Message回收到消息池，以便重复利用。
+
+#### Message类
+
+这里我们需要看一下Message类中的target及recycleUncheked()方法: 
+
+```java
+public final class Message implements Parcelable {
+    // 消息类别
+    public int what;
+    // 参数1
+    public int arg1;
+    // 参数2
+    public int arg2;
+    // 消息内容
+    public Object obj;
+    // 消息响应方Handler
+    /*package*/ Handler target;
+    // 维护下一个消息
+    /*package*/ Message next;
+    // 消息的回调方法
+    /*package*/ Runnable callback;
+    public static final Object sPoolSync = new Object();
+    // sPool也是Message对象，
+    private static Message sPool;
+    private static int sPoolSize = 0;
+
+    private static final int MAX_POOL_SIZE = 50;
+    
+    public static Message obtain(Handler h) {
+        Message m = obtain();
+        // 将handler赋值给target保存
+        m.target = h;
+
+        return m;
+    }
+    
+    public void recycle() {
+        if (isInUse()) {
+            if (gCheckRecycle) {
+                throw new IllegalStateException("This message cannot be recycled because it "
+                        + "is still in use.");
+            }
+            return;
+        }
+        recycleUnchecked();
+    }
+    
+    void recycleUnchecked() {
+        // Mark the message as in use while it remains in the recycled object pool.
+        // Clear out all other details.
+        flags = FLAG_IN_USE;
+        what = 0;
+        arg1 = 0;
+        arg2 = 0;
+        obj = null;
+        replyTo = null;
+        sendingUid = UID_NONE;
+        workSourceUid = UID_NONE;
+        when = 0;
+        target = null;
+        callback = null;
+        data = null;
+
+        synchronized (sPoolSync) {
+            // 如果当前消息池小于最大的数量限制，就把消息放到消息池中
+            if (sPoolSize < MAX_POOL_SIZE) {
+                next = sPool;
+                // 把新放入的Message加到链表的表头
+                sPool = this;
+                sPoolSize++;
+            }
+        }
+    }   
+}    
+```
+
+
+
+## 2. Handler.sendMessage(Message)和dispatchMessage(Message)方法
+
+```java
+public void handleMessage(@NonNull Message msg) {
+}
+
+/**
+     * Handle system messages here.
+     */
+public void dispatchMessage(@NonNull Message msg) {
+    if (msg.callback != null) {
+        // 如果Message存在回调方法，就回调Message.callback.run()方法
+        handleCallback(msg);
+    } else {
+        if (mCallback != null) {
+            // 如果Message没有回调方法，而Handler对象中设置了Callback接口，这里就回调Callback.handleMessage(msg)方法
+            if (mCallback.handleMessage(msg)) {
+                return;
+            }
+        }
+        // handler自己的handleMessage方法，默认空实现，子类可重写该方法
+        handleMessage(msg);
+    }
+}
+
+public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
+    Message msg = Message.obtain();
+    msg.what = what;
+    return sendMessageDelayed(msg, delayMillis);
+}
+
+private static Message getPostMessage(Runnable r) {
+    Message m = Message.obtain();
+    m.callback = r;
+    return m;
+}
+
+public final void removeCallbacksAndMessages(@Nullable Object token) {
+    mQueue.removeCallbacksAndMessages(this, token);
+}
+```
+
+
+
+## MessageQueue类的常用方法
+
+MessageQueue非常重要，因为quit、next等都最终调用的是MessageQueue类。
+
+
+
+```java
+public final class MessageQueue {
+    private final boolean mQuitAllowed;
+    private long mPtr; // used by native code
+    // 消息在MessageQueue中使用Message表示，而Message包含一个next变量，该变量指向下一个消息
+    // 所以队列中的消息以链表的结构进行保存
+    Message mMessages;
+
+    // 获取MessageQueue的下一个Message
+    Message next() {
+        // 如果MessageQueue已退出就直接返回
+        // Return here if the message loop has already quit and been disposed.
+        // This can happen if the application tries to restart a looper after quit
+        // which is not supported.
+        final long ptr = mPtr;
+        if (ptr == 0) {
+            return null;
+        }
+
+        int pendingIdleHandlerCount = -1; // -1 only during first iteration
+        int nextPollTimeoutMillis = 0;
+        for (;;) {
+            if (nextPollTimeoutMillis != 0) {
+                Binder.flushPendingCommands();
+            }
+			// 该方法的作用是从消息队列中取出一个消息。MessageQueue中没有保存消息队列，真正的消息队列在JNI的C代码中
+            // 也就是在C环境中创建了一个NativeMessageQueue数据对象。该方法的第一个参数是int型变量，在C环境中该变量
+            // 会被强制转换为一个NativeMessageQueue对象。如果消息队列中没消息，当前线程会被挂起。
+            // 堵塞操作，当等待nextPollTimeoutMillis时长或消息队列别唤醒，都会返回
+            // nextPollTimeoutMillis代表下一个消息到来前，还需要等待的时长；当nextPollTimeoutMillis = -1时，表示消息队列中无消息，会一直等待下去。
+            nativePollOnce(ptr, nextPollTimeoutMillis);
+
+            synchronized (this) {
+                // Try to retrieve the next message.  Return if found.
+                final long now = SystemClock.uptimeMillis();
+                Message prevMsg = null;
+                Message msg = mMessages;
+               
+                if (msg != null && msg.target == null) {
+                    // 当当前的消息的Handler为空时，就查询异步消息
+                    // Stalled by a barrier.  Find the next asynchronous message in the queue.
+                    do {
+                        prevMsg = msg;
+                        msg = msg.next;
+                    } while (msg != null && !msg.isAsynchronous());
+                }
+                if (msg != null) {
+                    // 仅仅是为了判断消息所指定的执行时间是否到了，如果到了就返回该消息
+                    if (now < msg.when) {
+                        // Next message is not ready.  Set a timeout to wake up when it is ready.
+                        nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
+                    } else {
+                        // Got a message.
+                        mBlocked = false;
+                        if (prevMsg != null) {
+                            prevMsg.next = msg.next;
+                        } else {
+                            mMessages = msg.next;
+                        }
+                        msg.next = null;
+                        if (DEBUG) Log.v(TAG, "Returning message: " + msg);
+                        // 设置消息的使用状态，即FLOAG_IN_USE的flag
+                        msg.markInUse();
+                        return msg;
+                    }
+                } else {
+                    // No more messages.
+                    nextPollTimeoutMillis = -1;
+                }
+
+                // Process the quit message now that all pending messages have been handled.
+                if (mQuitting) {
+                    dispose();
+                    return null;
+                }
+
+                // If first time idle, then get the number of idlers to run.
+                // Idle handles only run if the queue is empty or if the first message
+                // in the queue (possibly a barrier) is due to be handled in the future.
+                if (pendingIdleHandlerCount < 0
+                        && (mMessages == null || now < mMessages.when)) {
+                    pendingIdleHandlerCount = mIdleHandlers.size();
+                }
+                if (pendingIdleHandlerCount <= 0) {
+                    // No idle handlers to run.  Loop and wait some more.
+                    mBlocked = true;
+                    continue;
+                }
+
+                if (mPendingIdleHandlers == null) {
+                    mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
+                }
+                mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
+            }
+			// 空闲回调函数
+            // Run the idle handlers.
+            // We only ever reach this code block during the first iteration.
+            for (int i = 0; i < pendingIdleHandlerCount; i++) {
+                final IdleHandler idler = mPendingIdleHandlers[i];
+                mPendingIdleHandlers[i] = null; // release the reference to the handler
+
+                boolean keep = false;
+                try {
+                    keep = idler.queueIdle();
+                } catch (Throwable t) {
+                    Log.wtf(TAG, "IdleHandler threw exception", t);
+                }
+
+                if (!keep) {
+                    synchronized (this) {
+                        mIdleHandlers.remove(idler);
+                    }
+                }
+            }
+
+            // Reset the idle handler count to 0 so we do not run them again.
+            pendingIdleHandlerCount = 0;
+
+            // While calling an idle handler, a new message could have been delivered
+            // so go back and look again for a pending message without waiting.
+            nextPollTimeoutMillis = 0;
+        }
+    }
+    
+    // 添加一条消息到消息队列
+    boolean enqueueMessage(Message msg, long when) {
+        // 每条消息必须有一个target
+        if (msg.target == null) {
+            throw new IllegalArgumentException("Message must have a target.");
+        }
+        if (msg.isInUse()) {
+            throw new IllegalStateException(msg + " This message is already in use.");
+        }
+
+        synchronized (this) {
+            if (mQuitting) {
+                IllegalStateException e = new IllegalStateException(
+                        msg.target + " sending message to a Handler on a dead thread");
+                Log.w(TAG, e.getMessage(), e);
+                msg.recycle();
+                return false;
+            }
+
+            msg.markInUse();
+            msg.when = when;
+            Message p = mMessages;
+            boolean needWake;
+            if (p == null || when == 0 || when < p.when) {
+                // New head, wake up the event queue if blocked.
+                msg.next = p;
+                mMessages = msg;
+                // 如果是堵塞的，这里就需要唤醒
+                needWake = mBlocked;
+            } else {
+                // Inserted within the middle of the queue.  Usually we don't have to wake
+                // up the event queue unless there is a barrier at the head of the queue
+                // and the message is the earliest asynchronous message in the queue.
+                needWake = mBlocked && p.target == null && msg.isAsynchronous();
+                Message prev;
+                for (;;) {
+                    prev = p;
+                    p = p.next;
+                    if (p == null || when < p.when) {
+                        break;
+                    }
+                    if (needWake && p.isAsynchronous()) {
+                        needWake = false;
+                    }
+                }
+                msg.next = p; // invariant: p == prev.next
+                prev.next = msg;
+            }
+
+            // We can assume mPtr != 0 because mQuitting is false.
+            if (needWake) {
+                // 内部会将mMessages消息添加到C环境中的消息队列中，并且如果消息线程正处于挂起状态，则唤醒该线程
+                nativeWake(mPtr);
+            }
+        }
+        return true;
+    }
+
+    
+
+    void quit(boolean safe) {
+        if (!mQuitAllowed) {
+            throw new IllegalStateException("Main thread not allowed to quit.");
+        }
+
+        synchronized (this) {
+            if (mQuitting) {
+                return;
+            }
+            mQuitting = true;
+
+            if (safe) {
+                removeAllFutureMessagesLocked();
+            } else {
+                removeAllMessagesLocked();
+            }
+
+            // We can assume mPtr != 0 because mQuitting was previously false.
+            nativeWake(mPtr);
+        }
+    }
+
+    // 清除所有的message
+    private void removeAllMessagesLocked() {
+        Message p = mMessages;
+        while (p != null) {
+            Message n = p.next;
+            p.recycleUnchecked();
+            p = n;
+        }
+        mMessages = null;
+    }
+
+    void removeCallbacksAndMessages(Handler h, Object object) {
+        if (h == null) {
+            return;
+        }
+
+        synchronized (this) {
+            Message p = mMessages;
+			// 从消息队列的头开始，移除所有符合条件的消息
+            // Remove all messages at front.
+            while (p != null && p.target == h
+                   && (object == null || p.obj == object)) {
+                Message n = p.next;
+                mMessages = n;
+                p.recycleUnchecked();
+                p = n;
+            }
+			// 移除剩余符合条件的消息
+            // Remove all messages after front.
+            while (p != null) {
+                Message n = p.next;
+                if (n != null) {
+                    if (n.target == h && (object == null || n.obj == object)) {
+                        Message nn = n.next;
+                        n.recycleUnchecked();
+                        p.next = nn;
+                        continue;
+                    }
+                }
+                p = n;
+            }
+        }
+    }
+```
+
+
+
+
+
+
+
+# Handler内存泄露
+
+
+
+有关内存泄露请猛戳[内存泄露][1]
+
+在上面分析Handler类源码时，其构造函数中第一部分的代码就是 匿名类、内部类和本地类都必须申请为static，否则会警告可能出现内存泄露。那为什么会导致内存泄露呢？
+
+```java
+Handler mHandler = new Handler() {
+    @Override
+    public void handleMessage(Message msg) {
+	    // do something.
+    }
+}
+```
+当我们这样创建`Handler`的时候`Android Lint`会提示我们这样一个`warning： In Android, Handler classes should be static or leaks might occur.`。       
+     
+一直以来没有仔细的去分析泄露的原因，先把主要原因列一下：    
+- `Android`程序第一次创建的时候，默认会创建一个`Looper`对象，`Looper`去处理`Message Queue`中的每个`Message`,主线程的`Looper`存在整个应用程序的生命周期.
+- `Hanlder`在主线程创建时会关联到`Looper`的`Message Queue`,`Message`添加到消息队列中的时候`Message(排队的Message)`会持有当前`Handler`引用，
+当`Looper`处理到当前消息的时候，会调用`Handler#handleMessage(Message)`.就是说在`Looper`处理这个`Message`之前，
+会有一条链`MessageQueue -> Message -> Handler -> Activity`，由于它的引用导致你的`Activity`被持有引用而无法被回收
+- **在java中，no-static的内部类会隐式的持有当前类的一个引用。static的内部类则没有。**
+
+## 具体分析
+```java
+public class SampleActivity extends Activity {
+
+  private final Handler mHandler = new Handler() {
+		@Override
+		public void handleMessage(Message msg) {
+		  // do something
+		}
+  }
+
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+	// 发送一个10分钟后执行的一个消息
+	mHandler.postDelayed(new Runnable() {
+	  @Override
+	  public void run() { }
+	}, 600000);
+
+	// 结束当前的Activity
+	finish();
+}
+```
+在`finish()`的时候，该`Message`还没有被处理，`Message`持有`Handler`,`Handler`持有`Activity`,这样会导致该`Activity`不会被回收，就发生了内存泄露.
+
+## 解决方法 
+- 通过程序逻辑来进行保护。
+    - 如果`Handler`中执行的是耗时的操作，在关闭`Activity`的时候停掉你的后台线程。线程停掉了，就相当于切断了`Handler`和外部连接的线，
+	`Activity`自然会在合适的时候被回收。 
+    - 如果`Handler`是被`delay`的`Message`持有了引用，那么在`Activity`的`onDestroy()`方法要调用`Handler`的`remove*`方法，把消息对象从消息队列移除就行了。 
+	    - 关于`Handler.remove*`方法
+			- `removeCallbacks(Runnable r)` ——清除r匹配上的Message。    
+			- `removeC4allbacks(Runnable r, Object token)` ——清除r匹配且匹配token（Message.obj）的Message，token为空时，只匹配r。
+			- `removeCallbacksAndMessages(Object token)` ——清除token匹配上的Message。
+			- `removeMessages(int what)` ——按what来匹配     
+			- `removeMessages(int what, Object object)` ——按what来匹配      
+			我们更多需要的是清除以该`Handler`为`target`的所有`Message(Callback)`就调用如下方法即可`handler.removeCallbacksAndMessages(null)`;
+- 将`Handler`声明为静态类。
+    静态类不持有外部类的对象，所以你的`Activity`可以随意被回收。但是不持有`Activity`的引用，如何去操作`Activity`中的一些对象？ 这里要用到弱引用
+	
+```java
+public class MyActivity extends Activity {
+	private MyHandler mHandler;
+
+	@Override
+	protected void onCreate(Bundle savedInstanceState) {
+		super.onCreate(savedInstanceState);
+		mHandler = new MyHandler(this);
+	}
+
+	@Override
+	protected void onDestroy() {
+		// Remove all Runnable and Message.
+		mHandler.removeCallbacksAndMessages(null);
+		super.onDestroy();
+	}
+
+	static class MyHandler extends Handler {
+		// WeakReference to the outer class's instance.
+		private WeakReference<MyActivity> mOuter;
+
+		public MyHandler(MyActivity activity) {
+			mOuter = new WeakReference<MyActivity>(activity);
+		}
+
+		@Override
+		public void handleMessage(Message msg) {
+			MyActivity outer = mOuter.get();
+			if (outer != null) {
+				// Do something with outer as your wish.
+			}
+		}
+	}
+}
+```
+
+[1]:(https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E5%86%85%E5%AD%98%E6%B3%84%E6%BC%8F.md)
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/OperatingSystem/AndroidKernal/3.Android Framework\346\241\206\346\236\266.md" "b/OperatingSystem/AndroidKernal/3.Android Framework\346\241\206\346\236\266.md"
new file mode 100644
index 00000000..100b61d7
--- /dev/null
+++ "b/OperatingSystem/AndroidKernal/3.Android Framework\346\241\206\346\236\266.md"	
@@ -0,0 +1,105 @@
+# 3.Android Framework框架
+
+## Framework框架
+
+Framework定义了客户端组件和服务端组件功能及接口。后面的阐述中，”应用程序“一般是指”.apk“程序。
+
+框架中包含三个主要部分，分别是服务端、客户端和Linux驱动。
+
+
+
+### 服务端
+
+服务端主要包含两个重要类，分别是WindowManagerService(WmS)和ActivityManagerService(AmS)。
+
+WmS的作用是为所有应用程序分配窗口，并管理这些窗口。包括分配窗口的大小，调节各窗口的叠放次序，隐藏或显示窗口。
+
+AmS的作用是管理所有应用程序中的Activity。
+
+除此之外，在服务端还包括两个消息处理类: 
+
+- KeyQ类：该类为WmS的内部类，继承与KeyInputQueue类，KeyQ对象一旦创建，就立即启动一个线程，该线程会不断地读取用户的UI操作信息，比如按键、触摸屏、trackball、鼠标等，并把这些消息放到一个消息队列QueueEvent类中。
+- InputDispatcherThread类：该类的对象一旦创建，也会立即启动一个线程，该线程会不断地从QueueEvent中取出用户消息，并进行一定的过滤，过滤后，再将这些消息发送给当前活动的客户端程序中。
+
+
+
+### 客户端
+
+
+
+客户端主要包括以下重要类：   
+
+- ActivityThread类：该类为应用程序的主线程类，所有的APK程序都有且仅有一个ActivityThread类，程序的入口为该类中的static main()函数。
+- Activity类：该类为APK程序中的一个最小运行单元，一个APK程序中可以包含多个Activity对象，ActivityThread类会根据用户操作选择运行哪个Activity对象。
+- PhoneWindow类：该类继承于Window类，同时，PhoneWindow类内部包含了一个DecorView对象。简而言之，PhoneWindow是把一个FrameLayout进行了一定的包装，并提供了一组通用的窗口操作接口。
+- Window类：该类提供了一组通用的窗口（Window)操作API，这里的窗口仅仅是程序层面上的，WmS所管理的窗口并不是Window类，而是一个View或者ViewGroup类，一般就是指DecorView类，即一个DecorView就是WmS所管理的一个窗口。Window是一个abstract类型。
+- DecorView类：该类是一个FrameLayout的子类，并且是PhoneWindow中的一个内部类。Decor的英文是Decoration，即”装饰“的意思，DecorView就是对普通的FrameLayout进行了一定的装饰，比如添加一个通用的Titlebar，并相应特定的按键消息等。
+- ViewRoot类：WmS管理客户端窗口时，需要通知客户端进行某种操作，这些都是通过异步消息完成的，实现的方式就是使用Handler，ViewRoot类就是继承于Handler，其作用主要是接收WmS的通知。
+- W类：该类继承于Binder，并且是ViewRoot的一个内部类。
+- WindowManager类：客户端要申请创建一个窗口，而具体创建窗口的任务是由WmS完成的，WindowManager类就像是一个部门经理，谁有什么需求就告诉它，由它和WmS进行交互，客户端不能直接和WmS进行交互。
+
+
+
+### Linux驱动
+
+Linux驱动和Framework相关的主要包含两部分： 
+
+- SurfaceFlingger（SF）驱动：每一个窗口都对应一个Surface，SF驱动的作用是把各个Surface显示在同一个屏幕上。
+- Binder驱动：Binder驱动的作用是提供进程间的消息传递。
+
+
+
+## APK程序的运行过程
+
+1. 首先，ActivityThread从main()函数开始执行，调用prepareMainLooper()为UI线程创建一个消息队列(MessageQueue)。
+2. 创建一个ActivityThread对象，在ActivityThread的初始化代码中会创建一个H（Handler）对象和一个ApplicationThread（Binder）对象。其中Binder负责接收远程AmS的IPC调用，接收到调用后，则通过Handler把消息发送到消息队列，UI主线程会异步地从消息队列中取出消息并执行相应的操作，比如start、stop、pause等。
+3. UI主线程调用Looper.loop()方法进入消息循环体，进入后就会不断地从消息队列中读取并处理消息。
+4. 当ActivityThread接收到AmS发送发送start某个Activity后，就会创建指定的Activity对象。Activity又会创建PhoneWindow类 ==》 DecorView类 ==》 创建相应的View或ViewGroup。创建完成后，Activity需要把创建好的界面显示到屏幕上，于是调用WindowManager类，后者于是创建一个ViewRoot对象，该对象实际上创建了ViewRoot类和W类，创建ViewRoot对象后，WindowManager再调用WmS提供的远程接口完成添加一个窗口并显示到屏幕上。
+5. 接下来，用户开始在程序界面上操作。KeyQ线程不断把用户消息存储到QueueEvent队列中，InputDispatch而Thread线程逐个去除消息，然后调用WmS中的相应函数处理该消息。当WmS发现该消息属于客户端某个窗口时，就会调用相应窗口的W接口。W类是一个Binder，负责接收WmS的IPC调用，并把调用消息传递给ViewRoot，ViewRoot再把消息传递给UI主线程ActivityThread，ActivityThread解析该消息并作出相应的处理。在客户端程序中，首先处理消息的是DecorView，如果DecorView不想处理某个消息，则可以将该消息传递给其内部包含的子View或者ViewGroup，如果还没有处理，则传递给PhoneWindow，最后再传递给Activity。
+
+
+
+上面启动完后会有几个线程？ 每个Binder对象都对应一个线程，Activity启动后会创建一个ViewRoot.W对象，同时ActivityThread会创建一个ApplicationThread对象，这两个对象都继承于Binder，因此会启动两个线程，负责接收Binder驱动发送IPC调用。最后一个主要线程也就是程序本身所在的线程，也叫做用户交互（UI）线程，因为所有的处理用户消息，以及绘制界面的工作都在该线程中完成。
+
+
+
+## 窗口相关概念
+
+窗口、Window类、ViewRoot类以及W类的区别和联系： 
+
+- 窗口（Window）：这是一个纯语义的说法，即程序员所看到的屏幕上的某个独立的界面，比如一个带有TitleBar的Activity界面、一个对话框、一个Menu菜单等，这些都称之为窗口。从WmS的角度来讲，窗口是接收用户消息的最小单元，WmS内部用特定的类表示一个窗口，以实现对窗口的管理。WmS接收到用户消息后，首先要判断这个消息属于哪个窗口，然后通过IPC调用把这个消息传递给客户端的ViewRoot类。
+- Window类：该类在android.view包中，是一个abstract类，该类是对包含有可视界面的窗口的一种包装，所谓的可视界面就是指各种View或者ViewGroup，一般可以通过res/layout目录下的xml文件描述。
+- ViewRoot类：该类是android.view包中，客户端申请创建窗口时需要一个客户端代理，用以和WmS进行交互，这个就是ViewRoot的功能，每个客户端的窗口都会对应一个ViewRoot类。
+- W类：该类是ViewRoot类的一个内部类，继承于Binder，用于想WmS提供一个IPC接口，从而让WmS控制窗口客户端的行为。
+
+描述一个窗口之所以有这么多类的原因在于，窗口的概念存在于客户端和服务端（WmS）之中，客户端所理解的窗口和服务端理解的窗口是不同的，因此，在客户端和服务端会用不同的类来描述窗口。比如在客户端，用户能看到的窗口一般是View或者ViewGroup组成的窗口，而与Activity对应的窗口却是一个DecorView类，而具备常规Phone操作的接口却又是一个PhoneWindow类。所以无论是在客户端还是服务端，对窗口都有不同层面的抽象。
+
+
+
+## Context
+
+
+
+Context在应用程序开发中会经常被使用，在一般的计算机书记中，Context被翻译为“上下文”，但是在Android中感觉翻译为“场景”更容易理解一些。
+
+
+
+一个Context意味着一个场景，一个场景就是用户和操作系统交互的一种过程。比如当你打电话时，场景包括电话程序对应的界面以及隐藏在界面后的数据。当你看短信时，场景包括短信界面以及隐藏在后面的数据。这也就是为什么一个Activity就是一个Context，一个Service也是一个Context。因为Android程序员把“场景”抽象为Context类，他们认为用户和操作系统的每一次交互都是一个场景，比如打电话、发短信，这些都是有界面的场景，还有一些没有界面的场景，比如后台运行的服务（Service）。一个应用程序可以认为是一个工作环境，用户在这个工作环境汇总会切换到不同的场景，这就像一个前台秘书，她可能需要接待客人，可能要打印文件，还可能要接听客户电话，而这些就称之为不同的场景，前台秘书可称之为一个应用程序。 
+
+
+
+### Context的创建
+
+在创建Application、Activity、Service时，AmS通过远程调用到ActivityThread的bindApplication()方法或ActivityThread的scheduleLaunchActivity()或ActivityThread.scheduleCreateService()方法，这里面会去创建ContextImpl并初始化。
+
+
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/OperatingSystem/AndroidKernal/4.ActivityManagerService\347\256\200\344\273\213.md" "b/OperatingSystem/AndroidKernal/4.ActivityManagerService\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..0a5b9007
--- /dev/null
+++ "b/OperatingSystem/AndroidKernal/4.ActivityManagerService\347\256\200\344\273\213.md"
@@ -0,0 +1,148 @@
+# 4.ActivityManagerService简介
+
+ActivityManagerService.java文件，简称AmS，是Android内核的三大核心功能之一，另外两个是WindowManagerService.java和View.java。Activity的管理实际上由三个主要类完成，分别是AmS、ActivityRecord及ActivityTask。AmS内部用ActivityRecord来表示一个Activity对象。ActivityStack是一个描述Task的类，所有和Task相关的数据以及控制都由ActivityStack来实现。
+
+AmS所提供的主要功能包括以下几项:   
+
+- 统一调度各应用程序的Activity。应用程序要运行Activity，会首先报告给AmS，然后由AmS决定该Activity是否可以启动，如果可以，AmS再通知应用程序运行指定的Activity。换句话说，运行Activity是各应用程序的内政，AmS并不干预，但是AmS必须知道应用进程都运行了哪些Activity。
+- 内存管理。Android官方声称，Activity退出后，其所在的进程并不会被立即杀死,从而下次在启动该Activity时能够提高启动速度。这些Activity只有当系统内存紧张时，才会被自动杀死，应用程序不用关心这个问题。而这些正是AmS中完成的。
+- 进程管理。AmS向外提供了查询系统正在运行的进程信息的API。
+
+
+
+## Activity调度机制
+
+
+
+在Android中，Activity调度的基本思路是：各应用进程要启动新的Activity或者停止当前的Activity，都要首先报告给AmS，而不能“擅自处理”。AmS在内部为所有应用程序都做了记录，当AmS接到启动或停止的报告时，首先更新内部记录，然后再通知相应客户进程运行或者停止指定的Activity。由于AmS内部有所有Activity的记录，也就理所当然地能够调度这些Activity，并根据Activity和系统内存的状态自动杀死后台的Activity。
+
+具体的讲，启动一个Activity有以下集中方式:  
+
+- 在应用程序中调用startActivity()启动指定的Activity。
+- 在Home程序中单击一个应用图标，启动新的Activity。
+- 按Back键，结束当前Activity，自动启动上一个Activity。
+- 长按Home键，显示出当前任务列表，从中选择一个启动。
+
+这四种启动方式的主体处理流程都会按照第一种启动方式运行，后三种方式只是在前端消息处理上各有不同。
+
+AmS中定义了几个重要的数据类，分别用来保存进程（Process）、活动（Activity）和任务（Task）。
+
+### 进程数据类ProcessRecord
+
+ProcessRecord记录一个进程中的相关信息，该类中内部变量可以分为三个部分：
+
+- 进程文件信息：也就是与该进程对应的APK文件的内部信息，例如ApplicationInfo、processName等。
+- 该进程的内存状态信息：这些信息将用于Linux系统的Out Of Memory情况的处理，当发生系统内部不够用时，Linux系统会根据进程的内存状态信息，杀掉优先级比较低的进程。
+- 进程中包含的Activity、Provider、Service等：如ArrayList activities；
+
+### HistoryRecord数据类
+
+AmS中使用HistoryRecord数据类来保存每个Activity的信息，这里非常奇怪，Activity本身也是一个类，为什么还要用HistoryRecord来保存Activity的信息，而不是直接用Activity呢？这是因为Activity是具体的功能类，这就好比每一个读者都是一个Activity，而学校要为每一个读者建立一个档案，这些档案中并不包含每个读者具体的学习能力，而只是学生的籍贯信息、姓名、出生日期等，HistoryRecord就是AmS为每一个Activity建立的档案，该数据类中的变量主要包含两部分:  
+
+- 环境信息：该Activity的工作环境，比如隶属于哪个Package，所在的进程名称、文件路径、数据路径、图标主题等。
+- 运行状态信息：比如idle、stop、finishing等，这些变量一般问boolean类型，这些状态值与应用程序中的onCreate、onPause、onStart等状态有所不同。
+
+HistoryRecord类也是一个Binder，它基于IApplication.Stub类，因此它可以被IPC调用，一般是在WmS中进行该对象的IPC调用。
+
+
+
+### TaskRecord类
+
+AmS中使用任务的概念确保Activity启动和退出的顺序。比如如下启动流程，A、B、C分别代表三个应用程序，数字1、2、3分别代表该应用中的Activity。
+
+A1 -> A2 -> A3 -> B1 -> B2 -> C1 -C2，此时应该处于C2，如果AmS中没有任务的概念，此时又要从C2启动B1，那么会存在以下两个问题： 
+
+- 虽然程序上是要启动B1，但是用户可能期望启动B2，因为B1和B2是两个关联的Activity，并且B2已经运行于B1之后。如何提供给程序员一种选择，虽然指定启动B1，但如果B2已经运行，那么就启动B2.
+- 假设已经成功从C2跳转到B2，此时如果用户按Back键，是应该回到B1呢，还是应该回到C2？
+
+任务概念的引入正是为了解决以上两个问题，HistoryRecord中包含一个init task变量，保存该Activity所属哪个任务，程序员可以使用Intent.FLAG_NEW_TASK标识告诉AmS为启动的Activity重新创建一个Task。
+
+有了Task的概念后，以上情况就会是这样： 
+
+虽然程序明确指定从C2启动到B1，程序员可以在intent的FLAG中添加NEW_TASK标识，从而使得AmS会判断B1是否已经在mHistory中。如果在，则找到B1所在的Task，并从该Task中的最上面的Activity出运行，此处也就是B2.当然，如果程序的确要启动B1，那么就不要使用NEW_TASK标识，使用的话，mHistory中会有两个B1记录，隶属于不同的Task。
+
+TaskRecord类内部变量如下:  
+
+- taskId：每一个任务对应一个Int型的标识
+- intent：创建该任务对应的intent
+- numActivities：该任务中的Activity数目
+
+TaskRecord中并没有该任务中所包含的Activity的列表，比如ArrayList<HistoryRecord>或者HistoryRecord[]之类的变量，这意味着不能直接通过任务id找到其所包含的Activity。
+
+
+
+### AmS中调度相关常量
+
+- MAX_ACTIVITIES = 20;
+
+    系统只能有一个Activity处于执行状态，对于非执行状态的Activity，AmS会在内部暂时缓存起来，而不是立即杀死，但如果后台的Activity超过该常量，则会强制杀死一些优先级较低的Activity。
+
+- PAUSE_TIMEOUT = 500;
+
+    当AmS通知应用程序暂停指定的Activity时，AmS的忍耐是有限的，因为只有500毫秒，如果应用程序在该常量时间内还没有暂停，AmS会强制暂停并关闭该Activity。这就是为什么不能在onPause()中做过多事情的原因。
+
+- LAUNCH_TIMEOUT = 10 * 1000：当AmS通知应用程序启动某个Activity时，如果超过10s，AmS就会放弃
+
+- PROC_START_TIMEEOUT = 10 * 1000：当AmS启动某个客户进程后，客户进程必须在10秒之内报告AmS自己已经启动，否则AmS会认为指定的客户进程不存在。
+
+### 等待序列
+
+由于AmS采用Service机制运作，所有的客户进程要做什么事情，都要先请求AmS，因此，AmS内部必须有一些消息序列保存这些请求，并按顺序依次进行相应的操作： 
+
+- final ArrayList mHistory = new ArrayList();
+
+    这是最最重要的内部变量，该变量保存了所有正在运行的Activity，所谓正在运行是指该HistoryRecord的finishing状态为true。比如当前和用户交互的Activity属于正在运行，从A1启动到A2，尽管A1看不见了，但是仍然是正在运行。从A2按Home键回到桌面，A2也是正在运行，但如果从A2按Back键回到A1，这时A2就不是正在运行状态了，它会从mHistory中删除掉 。
+
+- private final ArrayList mLRUActivities = new ArrayList();
+
+    LRU代表Latest Recent Used，即最近所用的Activity的列表，它不像mHistory仅保存正在运行的Activity，mLRUActirity会保存所有过去启动过的Activity。
+
+- final ArrayList<PendingActivityLaunch> mPendingActivityLaunches = new ArrayList();
+
+    当AmS内部还没有准备好时，如果客户进程请求启动某个Activity，那么会被暂时保存到该变量中，这也就是pending的含义。这中情况一般发生在系统启动时，系统进程会查询系统中所有属性为Persisitant的客户进程，此时由于AmS也正在启动，因此，会暂时保存这些请求。
+
+- final ArrayList<HistoryRecord> mStoppingActivitiies;
+
+    在AmS的设计中，有这样一个理念：优先启动，其次再停止。即当用户请求启动A2时，如果A1正在运行，AmS首先会暂停A1，然后启动A2.当A2启动后再停止A1.在这个过程中，A1会被临时保存到mStoppingActivities中，直到A2启动后并处于空闲时，再回过头来停止mStoppingActivities中保存的HistoryRecord列表。
+
+- final ArrayList mFinishingActivities;
+
+    和mStoppingActivities类似，当AmS认为某个Activity已经处于finish状态时，不会立即杀死该Activity，而是会保存到该变量中，直到超过系统设定的警戒线后，才去回收该变量中的Activity。
+
+- HistoryRecord mPausingActivity
+
+    正在暂停的Activity，该变量只有在暂停某个Activity时才有值，代表正在暂停的Activity
+
+- HistoryRecord mResumedActivity
+
+    当前正在运行的Activity，这里的正在运行不一定是正在与用户交互。比如当用户请求执行A2时，当前正在运行的A1，此时AmS会首先暂停A1，而在暂停的过程中，AmS会通知WmS暂停获取用户消息，而此时mResumedActivity依然是A1.
+
+- HistoryRecord mFocusedActivity
+
+    这里的Focus并非是正在和用户交互，而是AmS通知WmS应该和用户交互的Activity，而在WmS真正处理这个消息之前，用户还是不能和该Activity交互。
+
+- HistoryRecord mLastPausedActivity
+
+    上一次暂停的Activity
+
+
+
+当系统内存低时，AmS会要求客户端释放内存，而可能会释放Surface对应的内存，而这是由WmS具体完成的。当WmS释放了Surface内存后，该Surface对应的窗口就无效了，则该窗口对应的Activity也就无效了，则Activity所在的进程也就无效了。
+
+
+
+## startActivi()启动流程
+
+
+
+- 调用startActivity()方法后，通知到AmS，AmS收到请求startActivity()后，会首先暂停当前的Activity，因此这时候AmS需要判断mResumeActivity是否为空，也就是当前有没有正在运行的activity。一般情况下，该值都不会为空。
+- 如果为空的话继续往下走，如果不为空的话，AmS会通知当前mResumeActivity对应的Activity所在的进程暂停，然后AmS就不管了，当那个进程暂停完后会报告AmS，这时AmS开始执行completePaused()。该方法中会去检查要启动的目标Activity是否存在mHistory列表中，如果存在说明目标进程还在运行，只是目标Activity处于stop状态，还没有finish，所以会通知B进程则通过handleResumeActivity()方法来resume目标Activity。
+- 如果不存在那需要去检查目标Activity所在的进程是否存在。如果不存在则必须首先启动对应的进程。这时AmS调用Process进程类启动一个新的进程，新的进程会从ActivityThread的main()函数处开始执行，当对应进程启动后，B进程会报告AmS自己已经启动，于是执行AmS的attachApplication()方法，该方法可理解为B进程请求AmS给自己安排(attach)一个具体要执行的Activity，此时AmS继续调用resumeTopActivity()，通知B进程执行指定的Activity。
+- 首先判断目标HistoryRecord在B进程中不存在，则B调用handleLaunchActivity()创建一个该Activity实例。如果已经存在，则调用handleResumeActivity()恢复已有的Activity运行。这个逻辑的意思就是说，在ActivityThread中可以存在同一个Activity的多个实例，对应了AmS中mHistory的多个HistoryRecord对象。在一般情况下，当调用startActivity的FLAG为NEW_TASK时，AmS会首先从mHIstory中找到指定Activity所在的Task，然后启动Task中的最后一个Activity。如果FLAG不为NEW_TASK，那么AmS会在当前Task中重新创建一个HistoryRecord。
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/OperatingSystem/AndroidKernal/5.Android\346\266\210\346\201\257\350\216\267\345\217\226.md" "b/OperatingSystem/AndroidKernal/5.Android\346\266\210\346\201\257\350\216\267\345\217\226.md"
new file mode 100644
index 00000000..f731b4e9
--- /dev/null
+++ "b/OperatingSystem/AndroidKernal/5.Android\346\266\210\346\201\257\350\216\267\345\217\226.md"
@@ -0,0 +1,60 @@
+# 5.Android消息获取
+
+在Android 2.0及以前的所有版本中，获取用户消息的方式基本上都是相同的，具体如下:  
+
+- 在WmS中有一个子类KeyQ，该类基于KeyInputQueue类，而该类内部则包含一个线程对象，即KeyQ对象是一个线程对象。该线程的任务是调用native方法从输入设备中读取用户消息，包括案件、触摸屏、鼠标、轨迹球等各种消息，并把读取到的消息保存到一个QueueEvent队列中。
+
+- 在WmS中有另外一个子类叫做InputDispatcherThread，该类也是一个线程类，即内部包含一个线程。该线程的任务就是从上面的QueueEvent队列中读取用户消息，并对这些消息进行一定的加工，然后判断应该把这个消息发送给哪个应用窗口。
+- 在每一个应用窗口对象ViewRoot中都包含一个W子类，该类是一个Binder类，InputDispatchThread通过IPC方式调用W所提供的函数。从而把消息发送给对应的客户端窗口。
+
+2.2版本中的这种处理过程有两点被Android社区所诟病。
+
+- 对所有原始消息的加工都在KeyQ类的Java代码中完成，这加大了消息处理的延迟。
+- InputDispatcherThread是通过Binder方式传递按键消息的，而Binder的延迟降低了用户操作的相应速度。
+
+以上两点给用户的体验就是界面操作的延迟，比如滑动触摸屏，界面的移动会延迟于指尖的移动。于是从2.3开始，Android团队对消息处理逻辑进行了重构: 
+
+- 获取消息的代码全部使用C++完成，包括对消息进行加工转换。
+- 抛弃了使用Binder方式传递用户消息到客户端，而是使用Linux的Pipe机制。
+
+
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/input_message_process.png)
+
+1. 首先，InputReader线程会持续调用输入设备的驱动，读取所有用户输入的消息，该线程和InputDispatcher线程都在系统进程(system_process)空间中运行。InputDispatcher线程从自己的消息队列中取出原始消息，取出的消息有可能经过两种方式进行派发。
+    - 经过管道（Pipe）直接派发到客户窗口中。
+    - 先派发到WmS中，由WmS经过一定的处理，如果WmS没有处理该消息，则再派发给客户窗口中，否则，不派发到客户窗口。
+2. 应用程序添加窗口时，会在本地创建一个ViewRoot对象，然后通过IPC调用WmS中的Session对象的addWindow（）方法，从而请求WmS创建一个窗口。WmS会把窗口的相关信息保存在内部的一个窗口列表类InputMonitore中，然后使用InputManager类把这些窗口信息传递给InputDispatcher线程。传递的过程中，InputManager类需要调用JNI代码，把这些窗口信息传递给NativeInputManager对象中。
+3. 当InputDispatcher得到用户消息后，会根据NativeInputManager中保存的所有窗口信息判断当前的活动窗口是哪个，并把消息传递给该活动窗口。另外，如果是按键消息，InputDispatcher会先回调InputManager中定义的回调函数，这既会回调InputMonitor中的回调函数，又会回调WmS中定义的相关函数，所以这些回调函数的返回值类型是boolean。对于系统按键消息，比如“Home键”、电话按键等，WmS内部会按默认的方式处理，并返回false，从而InputDispatcher不会继续把这些按键消息传递给客户窗口。对于触摸屏消息，InputDispatcher则直接传递给客户窗口。
+4. 在InputDispatcher和客户窗口之间使用了管道（Pipe）机制进行消息传递。Pipe是Linux的一种系统调用，Linux会在内核地址空间中开辟一段共享内存，并产生一个Pipe对象。每个Pipe对象内部都会自动创建两个文件描述符，一个用于读，另一个用于写。应用程序可以调用pipe()函数产生一个Pipe对象，并获得该对象中的读、写文件描述符。文件描述符是全局唯一的，从而使得两个进程之间可以借助这两个描述符，一个往管道中写数据，另一个从管道中读数据。管道只能是单向的，因此，如果两个进程要进行双向消息传递，必须创建两个管道。当客户窗口请求WmS创建窗口时，WmS内部会创建两个管道，其中一个管道用于InputDispatcher向客户窗口传递消息，另一个用户客户窗口向InputDispatcher报告消息的执行结果。因此，有多少个客户窗口，就有多少个管道与InputDispatcher相连。
+5. 由于创建管道属于Linux系统调用，Java不能直接调用，另外也由于程序结构的需要，Android中把调用管道的相关操作封装到了InputChannel.java类中，同时该类中保存了InputDispatcher和客户窗口的管道收、发描述符。因此，InputChannel也可以理解为一个“通道”，在InputDispatcher端存在一个服务端消息通道（serverChannel）。在客户窗口端存在一个客户端消息通道（clientChannel）。管道和通道的区别是，管道是Linux系统的概念，使用pipe()系统调用就可以创建一个管道，而通道是Android内部定义的一个概念，主要保存了通信双发所使用的管道描述符。
+
+
+
+### 事件分发
+
+
+
+#### 按键消息派发
+
+1. 首先，在ViewRoot中定义了一个InputHandler对象，当底层得到按键消息后，会回调到该InputHandler对象的handleKey()函数，该函数内部发送一个异步DISPATCH_KEY消息，消息的处理函数为deliverKeyEvent()，该函数内部分以下三步执行:  
+    - 调用mView.dispatchKeyEventPreime()，这里的PreIme的意思就是在Ime之前，即输入法之前。因为对于View系统来讲，如果有输入法窗口存在，会先将案件消息派发给输入法窗口，只有当输入法窗口没有处理该消息时，才会把消息继续派发给真正的视图。所以如果想在输入法之前处理某些按键消息，可以重写该dispatchKeyEventPreime()方法，如果该函数返回为true，则可以直接返回了，但是在返回之前如果WmS要求返回一个处理回执，则需要先调用finishInputEvent()报告给WmS已经处理的该消息，从而使得WmS可以继续派发下一个消息。
+    - 接下来就需要把该消息派发到输入法窗口。当然如果此时输入法窗口不存在，就直接派发到真正的视图。
+    - 调用deliverKeyEventToViewHierarchy()，将消息派发给真正的视图。该函数内部又分为四步:  
+        - 调用checkForLeavingTouchModeAndConsume()判断该消息是否会导致离开触摸模式，并且会消耗掉该消息，一般情况下该函数总是会返回false。
+        - 调用mView.dispatchKeyEvent()将消息派发给根视图。对于应用窗口而言，根视图就是PhoneWindow的DecorView对象。而DecorView的dispatchKeyEvent内部会判断去处理音量键、系统快捷键等
+        - 如果应用程序中没有处理该消息，则默认会判断该消息是否会引起视图焦点的变化，如果会就进行焦点切换。
+
+
+
+
+
+和按键派发类似，当消息获取模块通过pipe将消息传递给客户端，InputQueue中的next()函数内部调用nativePollOnce()函数中会读取该消息，如果有消息，则回调ViewRoot内部的mInputHandler对象的dispatchMothion()函数，该函数仅仅是发起一个DISPATCH_POINTER异步消息，消息的处理函数是deliverPointerEvent()。执行完该函数后，调用finishInputEvent()向消息获取模块发送一个回执，以便其进行下一次消息派发。
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/OperatingSystem/AndroidKernal/6.\345\261\217\345\271\225\347\273\230\345\210\266\345\237\272\347\241\200.md" "b/OperatingSystem/AndroidKernal/6.\345\261\217\345\271\225\347\273\230\345\210\266\345\237\272\347\241\200.md"
new file mode 100644
index 00000000..b4f24bb7
--- /dev/null
+++ "b/OperatingSystem/AndroidKernal/6.\345\261\217\345\271\225\347\273\230\345\210\266\345\237\272\347\241\200.md"
@@ -0,0 +1,51 @@
+# 6.屏幕绘制基础
+
+Android中的GUI系统是客户端和服务端配合的窗口系统，即后台运行了一个绘制服务，每个应用程序都是该服务端的一个客户端，当客户端需要绘制时，首先请求服务端创建一个窗口，然后在窗口中进行具体的视图内容绘制；对于每个客户端而言，他们都感觉自己独占了屏幕，而对于服务端而言，它会给每一个客户端窗口分配不同的层值，并根据用户的交互情况动态改变窗口的层值，这就给用户造成了所谓的前台窗口和后台窗口的概念；
+
+Android的屏幕绘制架构如下图：
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_draw_process_archi.jpg)
+
+- SurfaceFlinger服务进程：简称sf。该进程在整个系统中只有一个实例，在系统开机后自动运行，它的作用是给每个客户端分配窗口，程序中用Surface类表示这个窗口。正如Surface字面的意义，它是一个平面，即每个窗口是一个平面，每个平面在程序中都对应一段内存，也就是所谓的屏幕缓冲区，不同窗口的缓冲区大小不同，这取决于该窗口的大小，即宽度和高度，一般来讲缓冲区的大小为宽度x高度。sf的客户端必须使用SurfaceFlinger的客户端接口驱动来和sf打交道，系统中使用该接口驱动的最重要的进程就是SystemServer进程。
+- 当一个APK程序需要创建窗口时，会使用WindowManager类的addView()函数，该函数会创建一个ViewRoot对象，而ViewRoot类中会使用Surface的无参构造函数创建一个Surface对象，此时该Surface仅仅是一个空壳，然后调用WindowManager类向WmS服务发起一个请求，请求的参数中包含该Surface对象。虽然它表示的是一个窗口，但它必须经过初始化后才真正能够对应一个再屏幕上显示的窗口，而初始化的本质就是给该Surface对象分配一段屏幕缓冲区的内存。
+- WmS收到这个请求后，会通过Surface类的JNI调用到SurfaceFlinger_client驱动，通过该client接口驱动请求sf进程创建指定的窗口。于是sf创建一段屏幕缓冲区，并在sf内部记录该窗口，然后sf会把该窗口的缓冲区地址传递给WmS，WmS再用这个地址去初始化APK程序传入的Surface对象，并最终回到APK程序中。此时APK程序中的Surface对象是一个真正的Surface对象了，因为它包含的屏幕缓冲区已经由sf创建并备案了。 
+- APK程序有了这个Surface后，就可以给这个平面上绘制任意的内容了，比如绘制矩阵、绘制文本、绘制图片等。然后Surface类本质上仅仅表示了一个平面，而绘制不同图片显然是一种操作，而不是一段数据，因此Android中使用了一个叫做Skia的绘图驱动库，该库使用C/C++语言编写而成，其作用就是能够进行各种平面绘制。在程序中用Canvas类来表示这个功能对象，Canvas类有很多绘制函数，比如drawColor()、drawLine()等。Surface类包含了一个函数lockCanvas()，APK应用程序可以通过该函数返回一个Canvas功能对象，然后就可以调用该对象的各种绘制函数完成对平面的绘制。
+
+
+
+### 相关类
+
+- Surface类：该类用于描述一个绘制平面，其内部仅仅包含了该平面的大小，在屏幕上的位置，以及一段屏幕缓冲内存区。不过在Java端，不能直接访问这段内存，同时也不能通过该类直接设置平面的大小和位置，而只能通过SurfaceHolder类。
+
+    一般情况下，客户端程序对应的Surface都是由底层的ViewRoot类进行创建的，而ViewRoot中创建Surface的函数在SDK中没有开放，所以应用程序不能通过ViewRoot类直接创建Surface对象，而只能通过SurfaceView类间接创建。
+
+    对于SDK开发的APK程序而言，不能直接创建Surface对象，而只能使用WindowManager类的addView()方法创建一个窗口，因为Surface的构造函数都是@hide的，即不会出现在SDK中。Surface类有两个构造函数:  
+
+    - public Surface() {}
+
+        使用该构造函数创建的Surface对象仅仅是一个空壳，因为每个Surface内部都会对应一段屏幕缓冲区内存，对于空壳子Surface而言，这段内存不存在。
+
+    - public Surface(SurfaceSession s, int pid, int display, int w, int h, int format, int flags)
+
+        该构造函数包含窗口大小相关的参数，使用该构造函数会创建一个真正的Surface对象。
+
+    WindowManager类的addView()函数会创建一个ViewRoot对象，而ViewRoot类则使用Surface的无参数构造函数创建了一个Surface对象，此时该Surface是一个空壳，然后ViewRoot类调用WmS中的IWindowSession服务为该Surface对象分配真正的屏幕缓冲区内容。之后Surface的构造函数回去创建一个Canvas对象，然后调用init()函数来初始化该Surface对象，该函数内部会首先获得一个SurfaceComposerClient对象，该类正式native层面上的SurfaceFlinger服务的客户端对象，然后调用该对象的createSurface()函数创建一个真正的Surface对象。之后调用Surface的lock()函数获取一个SurfaceInfo对象。该SurfaceInfo对象中获取该Surface对应屏幕缓冲区内存地址。再用这个地址构造一个SkBitmap对象，之后用SkBitmap对象构造一个SkCanvas对象，这个SkCanvas对象是底层真正进行绘制的功能类对象，Java层面的Canvas类仅仅是该类的包装而已，之后将Canvas对象返回到Java端。
+
+- Canvas类：是一个功能类，该类包含各种绘制函数，例如drawColor()、drawLine()等。构造Canvas对象时，必须为该Canvas指定一段内存地址，因为绘制的结果实际上就是给这段内存地址中填充不同的像素值。这段内存有两种类型，一种是普通的内存，另一种是屏幕缓冲区内存，当Canvas对应的内存为屏幕缓冲区内存时，绘制函数执行后就可以在屏幕上看到，如果是一段普通内存，则不会在屏幕上看到，不过却可以将这段内存复制到拥有屏幕缓冲内存的Canvas中，这种方式就是游戏开发中常用的方式。
+
+- Drawable类：是一个抽象类，该类是一个功能类，但它与Canvas的相同之处是两者可以给内存缓冲区中绘制图案，两者的区别有两点:  
+
+    - Drawable类内部不存在一段内存缓冲区，当应用程序需要绘制某种图案时，可以将一个包含内存缓冲区的Canvas对象传递给Drawable，然后Drawable就可以给该Canvas上绘制相应的团。
+    - 每个具体的Drawable对象仅仅绘制某个特定的图案，SDK中包含的Drawable实现类有BitmapDrawable、NinePatchDrawable等。
+
+
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/OperatingSystem/AndroidKernal/7.View\347\273\230\345\210\266\345\216\237\347\220\206.md" "b/OperatingSystem/AndroidKernal/7.View\347\273\230\345\210\266\345\216\237\347\220\206.md"
new file mode 100644
index 00000000..a5def400
--- /dev/null
+++ "b/OperatingSystem/AndroidKernal/7.View\347\273\230\345\210\266\345\216\237\347\220\206.md"
@@ -0,0 +1,16 @@
+# 7.View绘制原理
+
+
+
+
+
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/OperatingSystem/AndroidKernal/8.WindowManagerService\347\256\200\344\273\213.md" "b/OperatingSystem/AndroidKernal/8.WindowManagerService\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..7fa274dc
--- /dev/null
+++ "b/OperatingSystem/AndroidKernal/8.WindowManagerService\347\256\200\344\273\213.md"
@@ -0,0 +1,131 @@
+# 8.WindowManagerService简介
+
+
+WmS是Android中图形用户接口的引擎，它管理者所有窗口，包括创建、删除窗口以及将某个窗口设置为焦点等。
+
+在WmS中，窗口是由两部分内容构成: 
+
+- 描述该窗口的类WindowState。
+- 该窗口在屏幕上对应的界面Surface。
+
+它的功能可以归纳为两个: 
+
+- 保持窗口的层次关系，以便SurfaceFlinger能够据此绘制屏幕
+- 把窗口信息传递给InputManager对象，以便InputDispatcher能够把输入消息派发给和屏幕上显示一致的窗口。
+
+Android采用层叠式布局，这种布局的特点在于允许多个窗口层叠显示。该布局一般都需要一个窗口管理服务端。从程序设计的角度看，有两种设计模式可以实现服务端: 
+
+- 独立进程方式
+
+    使用一个独立的进程专门用于屏幕的绘制和消息处理，所有的其他引用程序当需要创建窗口时，通过进程通信的方式请求管理服务创建窗口。比如Linux上的X-window就是一种独立进程的方式，它使用Socket通信的方式，通知窗口管理服务进行窗口的创建及交互消息传递。
+
+- 共享库方式
+
+    使用一段共享程序，该段共享程序中保存了所有客户端的窗口信息，共享库和每个客户端程序都运行于同一个进程之间。Windows操作系统使用的就是这种方式，很多嵌入式系统也使用这种方式。该方式的有点是窗口管理的开销比较小，尤其是窗口的交互，因为它不需要进程间通信，其缺点就是任何一个客户端的不适当操作都可能导致窗口系统崩溃。
+
+
+
+
+
+在WmS内部逻辑中，会进行三种常见的操作，具体的操作可能会对应不同的函数名称，这三种常见的操作为assign layer、perform layout以及place surface:    
+
+- Assign layer的意思是为窗口分配层值。在WmS中，每个窗口都是用WindowState类来描述，而窗口要在界面上显示时，需要制定窗口的层值。从用户的视角来看，层值越大，其窗口越靠近用户，窗口之间的层叠正式按照层值进行的。
+- perform layout的意思是计算窗口的大小。每个窗口对应都必须有一个大小，即窗口大小，perform layout将根据状态栏大小、输入法窗口的状态、窗口动画状态计算该窗口的大小。
+- place surface的意思是调整Surface对象的属性，并重新将其显示到屏幕上。由于assign layer和perform layout的执行结果影响的仅仅是WindowState中的参数，而能够显示到屏幕上的窗口都包含一个Surface对象，因此只有将以上执行结果的窗口层值、大小设置到Surface对象中，屏幕上才能看出该窗口的变化。place surface的过程就是将这些值赋值给Surface对象，并告诉Surface Flinger服务重新显示这些Surface对象。
+
+
+
+### WmS接口结构
+
+WmS接口结构是指WmS功能模块与其他模块之间的交互接口，其中主要包括与AmS模块及应用程序客户端的接口，
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/wms_api.png)
+
+该结构中的主要交互过程如下:  
+
+- 应用程序在Activity中添加、删除窗口。具体实现就是通过调用WindowManager类的addView()和removeView()函数完成，这会转而调用ViewRoot类的相关方法，然后通过IPC调用到WmS中的相关方法完成添加、删除过程。
+- 当AmS通知ActivityThread销毁某个Activity时，ActivityThread会直接调用WindowManager中的removeView()方法删除窗口。
+- AmS中直接调用WmS，这种调用一般都不是请求WmS创建或删除窗口，而是告诉WmS一些其他信息。
+
+在WmS内部，全权接管了输入消息的处理和屏幕的绘制。其中输入消息的处理是借助于InputManager类完成的。而绘制屏幕则是借助于SurfaceFlinger模块完成的，SurfaceFlinger是Linux的一个驱动，它内部会使用芯片的图形加速引擎完成对界面的绘制。
+
+
+
+### WindowState
+
+由于WmS是用来管理窗口的，因此需要定义一个专门的类来表示窗口，WmS中表示窗口的类就是WindowState。从设计原理的角度来说，似乎使用WindowState类来表示一个窗口就可以了，但是从程序实现的角度来讲，为了变成的便利性及程序逻辑的清晰性，WmS类内部还定义了两个额外的用来表示窗口的类，分别是WindowToken和AppWindowToken。为什么还需要这两个额外的类？ 
+
+- 每个窗口都会对应一个WindowState对象。因为窗口的本质就是由WindowState类描述的数据对象，WindowState类中记录作为一个窗口应该有的全部属性，比如窗口的大小，在屏幕上的层值，以及窗口动画过程的各种状态信息。
+- WindowToken描述的是窗口对应的token的相关属性，每个窗口都会对应一个WindowToken对象，但是一个窗口的所有子窗口将对应同一个WindowToken对象，即多对一的关系。
+- 如果窗口是由Activity创建的，即该窗口对应一个Activity，那么该窗口同时对应一个AppWindowToken对象。
+
+
+
+### Session
+
+和SurfaceFlinger直接打交道的类本来是SurfaceSession。当应用程序需要创建Surface时，会请求WmS去完成创建的工作，WmS回味每一个应用程序分配一个SurfaceSession对象。然而一个surfaceSession对象不足以表示一个客户端，因此，WmS定义了Session类，它可被认为是SurfaceSession的一个包装。Session对象是当应用程序调用WmS的openSession()函数时创建的，而应用程序又是在ViewRoot类中调用openSession的。
+
+
+
+
+
+## 创建窗口
+
+
+
+创建窗口的时机可分为两种： 
+
+- 程序员主动调用WindowManager类的addView()方法。
+- 当用户启动一个新的Activity或者显示一个对话框、菜单栏等的时候，在这种情况下，程序员并不是直接调用addView()函数，但是这些类的内部同样会间接调用addView()函数。
+
+
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/create_window_process.png)
+
+- 客户端调用WindowManager类的addView()方法后，该方法会创建一个新的ViewRoot对象，然后调用ViewRoot类的setView()方法，该方法中会通过IPC方式调用WmS类中内联类Session的add()方法。
+- Session类的add()方法又会间接调用WmS的addWindow()方法，该方法内部又分为三个小过程：
+    - 第一个过程是进行前置处理，即首先判断参数的合法性，以确保接下来的添加操作能够顺利进行。
+    - 第二个过程是具体添加和窗口相关的数据。
+    - 第三个过程是后置处理，即添加窗口会引起相关状态的变化，因此需要把这些变化反应到相关的数据中。
+
+
+
+
+
+## AmS与WmS的交互
+
+
+
+AmS和WmS都是窗口管理系统的核心，不过AmS侧重于对Activity的管理，而WmS侧重于对窗口的管理。系统启动后首先是由AmS接管主控制权力，然后AmS开始调度并运行Activity，WmS作为AmS的辅助服务，接受应用程序的请求创建窗口。当窗口显示后，用户和窗口的交互控制则交由WmS和应用程序本身来完成，而当应用程序需要启动新的Activity时，则又交给AmS去处理，系统就这样周而复始的运行。
+
+
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/ams_wms.png)
+
+以上过程是在两个进程、三个独立线程中异步完成的，从代码的角度解释以上执行过程:   
+
+- 当要启动B时，AmS会调用WmS的addAppToken()添加一个token，该token对应的是新的Activity。然后再调用WmS的setAppStartingWindow()告诉WmS启动窗口的标题和图标，以便WmS能根据这两个信息创建一个启动窗口。WmS接收到这个命令后就开始去创建启动窗口了，创建的具体过程就是标准的添加窗口的过程。
+- 与此同时，AmS还去启动B对应的进程，如果进程已经存在，则运行一个ActivityThread实例。每个Activity都是从ActivityThread开始执行的，ActivityThread类是客户端程序的主类，Activity仅仅是一个回调而已。
+- 在接下来的一段时间里，AmS处于空闲状态。WmS内部则开始创建启动窗口，并可能已经创建完毕了启动窗口，但暂时不能显示该启动窗口。而ActivityThread内部也忙碌的启动进程并使ActivityThread就绪。
+- 当ActivityThread就绪后，就会通过IPC调用AmS的attachApplication()，通知AmS自己已经就绪，可以运行任何指定的Activity了。当AmS收到这个通知后，一方面会调用WmS的setAppVisibility()使其开始显示启动窗口，并调用WmS中的setFocusedApp()将新的AppWindowToken设为焦点窗口，然而此时由于真正的窗口还没有就绪，所以焦点窗口被调整为Null。另一方面则调用ActivityThread中内联类ApplicationThread的scheduleLaunchActivity()，请求其开始运行指定的Activity，这最终会调用执行到Activity类的onCreate()函数中。
+- 在接下来的一段时间里，在WmS中，由于真正的Activity窗口还没有被创建，因此当前的焦点窗口被调整为null，并且开始了启动动画。另一方面，在ActivityRecord类中则开始运行Activity的onCreate()，该函数最终会调用到setContentView()，这会间接的创建一个真正的Activity窗口。
+- 当ActivityThread内部执行到创建真正的Activity窗口时，会调用到WmS中的addWindow()函数，在该函数中，当添加完新窗口后，就会把焦点调整到新窗口中。
+
+
+
+## 销毁Surface的过程
+
+Surface的销毁有两种情况:  
+
+- AmS调用WmS的setAppVisibility()设置指定应用窗口的可视状态。该方法会调用到relayoutWindow()方法，这里面会销毁窗口对应的Surface。
+- 当要删除窗口时，这个很容易理解，窗口都不在了，内部的Surface自然应该被销毁。
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/OperatingSystem/AndroidKernal/9.PackageManagerService\347\256\200\344\273\213.md" "b/OperatingSystem/AndroidKernal/9.PackageManagerService\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..803a99df
--- /dev/null
+++ "b/OperatingSystem/AndroidKernal/9.PackageManagerService\347\256\200\344\273\213.md"
@@ -0,0 +1,65 @@
+# 9.PackageManagerService简介
+
+程序包管理主要包含三部分内容： 
+
+- 提供一个能够根据intent匹配到具体的Activity、Provider、Service。即当应用程序调用startActivity(intent)时，能够把参数中指定的intent转换成一个具体的包含了程序包名称及具体Component名称的信息，以便Java类加载器加载具体的Component。
+- 进行权限检查。即当应用程序调用某个需要一定权限的函数调用时，系统能够判断调用者是否具备该权限，从而保证系统的安全。
+- 提供安装、删除应用程序接口。
+
+
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/package_manager_service_archi.png)
+
+该框架可以分为三层:  
+
+- 应用程序层
+
+    应用程序需要使用包管理服务时，调用ContextImpl类的getPackageManager()函数返回一个PackageManager对象，然后调用该对象所提供的各种API接口。
+
+- PmS服务层
+
+    和AmS、WmS等其他系统服务一样，包管理服务运行于SystemServer进程。PmS服务运行时，使用了两个目录下的XML文件保存相关的包管理信息。
+
+    - 第一个目录是system/etc/permissions：该目录下的所有xml文件用于permission的管理，具体包含两件时间。第一个是定义系统中都包含了哪些feature，应用程序可以在AndroidManifest.xml中使用use-feature标签声明程序都需要哪些feature。
+    - 第二个目录是/data/system/packages.xml，该文件保存了所有安装程序的基本包信息，有点像系统的注册表，比如程序的包名称是什么，安装包路径在哪里，程序都是用了哪些系统权限。
+
+    PmS在启动时，会从这两个目录中解析相关的XML文件，从而建立一个庞大的包信息树，应用程序可以间接从这个信息树中查询所有所需的程序包信息。
+
+    除了PmS服务外，还有两个辅助系统服务用于程序安装。 一个是DefaultContainerService，该服务主要用于把安装程序复制到程序目录中。另一个是Installer服务，该服务实际上并不是一个Binder，而是一个Socket客户端，PmS直接和该Socket客户端交互。Socket的服务端主要完成程序文件的解压工作及数据目录创建，比如从APK文件中提取dex文件，删除dalvik-cache(会把每个apk的dex文件放到该目录，方便提升执行速度)目录下的dex文件，创建程序专属的程序目录等。
+
+- 数据文件层
+
+    就像所有操作系统一样，Android中的程序也由相关的程序文件组成，这些程序文件可以分为三个部分:  
+
+    - 程序文件
+
+        所有的系统程序保存在/system/app目录下，所有的第三方应用程序保存在/data/app目录下，该目录中的APK与原始的APK文件的唯一区别是文件的名称不同，原始文件可以任意命名，而该目录下的文件名称是以包名进行命名，并自动增加一个"-x"后缀，比如com.android.haii.debugjar-1.apk。当同样一个程序第二次安装时，后面的数字1会变成数字2，而当第三次再安装时，又会变成数字1，有点像“乒乓”机制。。/data/dalvik-cache目录保存了程序中的执行代码。一个APK实际上是一个Jar压缩类型的文件，压缩包中包含了各种资源文件、资源索引文件、AndroidManifest文件及程序文件，当应用程序运行前，PmS会从APK文件中提取出代码文件，也就是所谓的dex文件，并将该文件存储在该目录下，以便以后能够快速运行该程序。比如: data@app@com.android.xxx-1.apk@classes.dex
+
+    - framework库文件
+
+        这些库文件存在于/system/framework目录下，库文件类型是APK或者Jar，系统开机后，dalvik虚拟机会加载这些库文件，而在PmS启动时，如果这些Jar或者APK文件还没有被转换为dex文件，则PmS会将这些库文件转换为dex文件，并保存到/data/dalvik-cache目录下。
+
+    - 应用程序所使用的数据文件
+
+        应用程序可以使用三种数据保存方式，分为为参数存储、数据库存储、文件存储。这三种存储方式对应的数据文件一般都保存到/data/data/xxx目录下，xxx代表程序的包名。
+
+
+
+安装及卸载程序的操作都是由PmS完成，安装程序的过程包括在程序目录下创建以包名称命名的程序文件、创建程序数据目录，以及把程序信息保存到相关的配置文件packages.xml中，卸载则是一个相反的操作。
+
+
+
+
+
+### aipalign优化APK内部存储
+
+所谓的内部存储优化是指，为了提高APK程序的加载速度，从而对APK中相关的数据进行边界对齐。因为从底层NAND Flash的角度来讲，读取NAND时，是以一个扇区进行读取的，因此，如果相关的数据能够在同一个扇区中，肯定会提高读取速度。zipalign的作用正是将APK包中的不同类型的数据文件进行边界对齐。
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
diff --git "a/SourceAnalysis/Activity\345\220\257\345\212\250\350\277\207\347\250\213.md" "b/SourceAnalysis/Activity\345\220\257\345\212\250\350\277\207\347\250\213.md"
index 43ba62de..cc1cdbb3 100644
--- "a/SourceAnalysis/Activity\345\220\257\345\212\250\350\277\207\347\250\213.md"
+++ "b/SourceAnalysis/Activity\345\220\257\345\212\250\350\277\207\347\250\213.md"
@@ -2,6 +2,10 @@ Activity启动过程
 ===
 
 前两天面试了天猫的开发，被问到了`Activity`启动过程，不懂啊....
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/app launch summary.jpg)
+
+
 今天就来分析一下，我们开启`Activity`主要有两种方式:    
 
 - 通过桌面图标启动，桌面就是`Launcher`其实他也是一个应用程序，他也是继承`Activity`。
diff --git "a/SourceAnalysis/Android Touch\344\272\213\344\273\266\345\210\206\345\217\221\350\257\246\350\247\243.md" "b/SourceAnalysis/Android Touch\344\272\213\344\273\266\345\210\206\345\217\221\350\257\246\350\247\243.md"
index 66fb66eb..1ef073c8 100644
--- "a/SourceAnalysis/Android Touch\344\272\213\344\273\266\345\210\206\345\217\221\350\257\246\350\247\243.md"	
+++ "b/SourceAnalysis/Android Touch\344\272\213\344\273\266\345\210\206\345\217\221\350\257\246\350\247\243.md"	
@@ -3,27 +3,35 @@ Android Touch事件分发详解
 
 先说一些基本的知识，方便后面分析源码时能更好理解。
 - 所有`Touch`事件都被封装成`MotionEvent`对象，包括`Touch`的位置、历史记录、第几个手指等.
-
 - 事件类型分为`ACTION_DOWN`,`ACTION_UP`,`ACTION_MOVE`,`ACTION_POINTER_DOWN`,`ACTION_POINTER_UP`,`ACTION_CANCEL`, 每个
 一个完整的事件以`ACTION_DOWN`开始`ACTION_UP`结束，并且`ACTION_CANCEL`只能由代码引起.一般对于`CANCEL`的处理和`UP`的相同。
 `CANCEL`的一个简单例子：手指在移动的过程中突然移动到了边界外，那么这时`ACTION_UP`事件了，所以这是的`CANCEL`和`UP`的处理是一致的。
-
-- 事件的处理分别为`dispatchTouchEveent()`分发事件(`TextView`等这种最小的`View`中不会有该方式)、`onInterceptTouchEvent()`拦截事件(`ViewGroup`中拦截事件)、`onTouchEvent()`消费事件.
-
+- 事件的处理分别为`dispatchTouchEveent()`分发事件(`TextView`等这种最小的`View`中不会有该方式)、`onInterceptTouchEvent()`拦截事件(`ViewGroup`中拦截事件)、`onTouchEvent()`消费事件.这些方法的返回值如果是true表示事件被当前视图消费掉。
 - 事件从`Activity.dispatchTouchEveent()`开始传递，只要没有停止拦截，就会从最上层(`ViewGroup`)开始一直往下传递，子`View`通过`onTouchEvent()`消费事件。(隧道式向下分发).
-
-- 如果时间从上往下一直传递到最底层的子`View`，但是该`View`没有消费该事件，那么该事件会反序网上传递(从该`View`传递给自己的`ViewGroup`，然后再传给更上层的`ViewGroup`直至传递给`Activity.onTouchEvent()`).
+- 如果时间从上往下一直传递到最底层的子`View`，但是该`View`没有消费该事件(不是clickable或longclickable)，那么该事件会反序网上传递(从该`View`传递给自己的`ViewGroup`，然后再传给更上层的`ViewGroup`直至传递给`Activity.onTouchEvent()`).
 (冒泡式向上处理).
-
 - 如果`View`没有消费`ACTION_DOWN`事件，之后其他的`MOVE`、`UP`等事件都不会传递过来.
-
 - 事件由父`View(ViewGroup)`传递给子`View`,`ViewGroup`可以通过`onInterceptTouchEvent()`方法对事件进行拦截，停止其往下传递，如果拦截(返回`true`)后该事件
 会直接走到该`ViewGroup`中的`onTouchEvent()`中，不会再往下传递给子`View`.如果从`DOWN`开始，之后的`MOVE`、`UP`都会直接在该`ViewGroup.onTouchEvent()`中进行处理。
 如果子`View`之前在处理某个事件，但是后续被`ViewGroup`拦截，那么子`View`会接收到`ACTION_CANCEL`.
+- `OnTouchListener`优先于`onTouchEvent()`对事件进行消费，而`onTouchEvent()`又优先于`onCickListener.onClick()`。
+- `TouchTarget`是保存手指点击区域属性的一个类，手指的所有移动过程都会被它记录下来, 包含被`touch`的`View`。  
+- ViewGroup默认不拦截任何事件，返回false。
+- View的onTouchEvent默认都会消费事件，返回true，除非它是不可点击的(clickable和longclickable都为false)，View的longClickable默认都是false，clickable对于Button等为true，而TextView等为false。
+- View的enable属性不影响onTouchEvent的默认返回值。
+- 通过requestDisallowInterceptTouchEvent方法可以在子元素中干预父元素的事件分发过程，但是ACTION_DOWN事件除外。
+
+在Android系统中，拥有事件传递处理能力的类有以下三种: 
+
+- Activity：拥有分发和消费两个方法。
+- ViewGroup：拥有分发、拦截和消费三个方法。
+- View：拥有分发、消费两个方法。
+
+
+
+对触摸屏进行操作时，Linux就会收到相应的硬件中断，然后将中断加工成原始的输入事件并写入相应的设备节点中。而Android输入系统所做的事情概括起来说就是监控这些设备节点，当某个设备节点有数据可读时，将数据读出并进行一系列的翻译加工，然后在所有的窗口中找到合适的事件接收者，并派发给它。当点击事件产生后，事件会传递给当前的Activity，由Activity中的PhoneWindow处理，PhoneWindow再把事件处理工作交给DecorView，之后再由DecorView将事件处理工作交给ViewGroup。
 
-- `OnTouchListener`优先于`onTouchEvent()`对事件进行消费。
 
-- `TouchTarget`是保存手指点击区域属性的一个类，手指的所有移动过程都会被它记录下来, 包含被`touch`的`View`。  
 
 废话不多说，直接上源码，源码妥妥的是最新版5.0：
 我们先从`Activity.dispatchTouchEveent()`说起：
@@ -43,9 +51,11 @@ public boolean dispatchTouchEvent(MotionEvent ev) {
 	if (ev.getAction() == MotionEvent.ACTION_DOWN) {
 		onUserInteraction();
 	}
+    // 首先交给本Activity对应的Window来进行分发，如果分发了，就返回true，事件循环结束
 	if (getWindow().superDispatchTouchEvent(ev)) {
 		return true;
 	}
+    // 如果window返回了false，就意味着所有view的ontouchevent都返回了false，那么只能是Activity来决定消费不消费
 	return onTouchEvent(ev);
 }
 ```
@@ -97,8 +107,9 @@ private final class DecorView extends FrameLayout implements RootViewSurfaceTake
 	...
 }
 ```
-它集成子`FrameLayout`所有很多时候我们在用布局工具查看的时候发现`Activity`的布局`FrameLayout`的。就是这个原因。       
+它继承自`FrameLayout`所有很多时候我们在用布局工具查看的时候发现`Activity`的布局`FrameLayout`的。就是这个原因。       
 好了，我们接着看`DecorView`中的`superDispatchTouchEvent()`方法。 
+
 ```java
 public boolean superDispatchTouchEvent(MotionEvent event) {
 	return super.dispatchTouchEvent(event);
@@ -134,6 +145,7 @@ public boolean dispatchTouchEvent(MotionEvent ev) {
 			// The framework may have dropped the up or cancel event for the previous gesture
 			// due to an app switch, ANR, or some other state change.
 			cancelAndClearTouchTargets(ev);
+            // 重置FLAG_DISALLOW_INTERCEPT
 			resetTouchState();
 			// 如果是`Down`，那么`mFirstTouchTarget`到这里肯定是`null`.因为是新一系列手势的开始。
 			// `mFirstTouchTarget`是处理第一个事件的目标。
@@ -142,10 +154,12 @@ public boolean dispatchTouchEvent(MotionEvent ev) {
 		// 检查是否拦截该事件(如果`onInterceptTouchEvent()`返回true就拦截该事件)
 		// Check for interception.
 		final boolean intercepted;
+        // 当事件由ViewGroup的子元素成功处理时，mFirstTouchTarget会被赋值并指向子元素，反之被ViewGroup拦截时，mFirstTouchTarget则为null
 		if (actionMasked == MotionEvent.ACTION_DOWN
 				|| mFirstTouchTarget != null) {
 			// 标记事件不允许被拦截， 默认是`false`， 该值可以通过`requestDisallowInterceptTouchEvent(true)`方法来设置，
-			// 通知父`View`不要拦截该`View`上的事件。
+			// 通知父`View`不要拦截该`View`上的事件。FLG_DISALLOW_INTERCEPT是在View中通过
+            // reqeustDisallowInterceptTouchEvent来设置
 			final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
 			if (!disallowIntercept) {
 				// 判断该`ViewGroup`是否要拦截该事件。`onInterceptTouchEvent()`方法默认返回`false`即不拦截。
@@ -339,7 +353,7 @@ public boolean dispatchTouchEvent(MotionEvent ev) {
 	}
 	return handled;
 }
-```   
+```
 
 接下来还要说说`dispatchTransformedTouchEvent()`方法，虽然上面也说了大体功能，但是看一下源码能说明另一个问题：   
 ```java
@@ -511,8 +525,7 @@ public boolean onTouchEvent(MotionEvent event) {
 		if (event.getAction() == MotionEvent.ACTION_UP && (mPrivateFlags & PFLAG_PRESSED) != 0) {
 			setPressed(false);
 		}
-		// A disabled view that is clickable still consumes the touch
-		// events, it just doesn't respond to them.
+		// 只要view的clickable和long_clickable有一个是true，onTouchEvent就会返回true消耗这个事件。
 		return (((viewFlags & CLICKABLE) == CLICKABLE ||
 				(viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE));
 	}
@@ -708,7 +721,7 @@ public boolean performClick() {
 讲到这里就明白了。`onTouchEvent()`中的`ACTION_UP`中会调用`performClick()`方法。
 
 
-到这里，就全部分析完了，这一块还是比较麻烦的，中间查了很多资料，有些地方自己可能也理解的不太对，如果有哪里理解的不对的地方，还请大家指出来。谢谢。
+到这里，就全部分析完了。
 
 ---
 
diff --git "a/SourceAnalysis/View\347\273\230\345\210\266\350\277\207\347\250\213\350\257\246\350\247\243.md" "b/SourceAnalysis/View\347\273\230\345\210\266\350\277\207\347\250\213\350\257\246\350\247\243.md"
index 57e2712b..e4168121 100644
--- "a/SourceAnalysis/View\347\273\230\345\210\266\350\277\207\347\250\213\350\257\246\350\247\243.md"
+++ "b/SourceAnalysis/View\347\273\230\345\210\266\350\277\207\347\250\213\350\257\246\350\247\243.md"
@@ -3,6 +3,7 @@ View绘制过程详解
 
 界面窗口的根布局是`DecorView`，该类继承自`FrameLayout`.说到`View`绘制，想到的就是从这里入手，而`FrameLayout`继承自`ViewGroup`。感觉绘制肯定会在`ViewGroup`或者`View`中，
 但是木有找到。发现`ViewGroup`实现`ViewParent`接口，而`ViewParent`有一个实现类是`ViewRootImpl`， `ViewGruop`中会使用`ViewRootImpl`...
+
 ```java
 /**
  * The top of a view hierarchy, implementing the needed protocol between View
@@ -18,13 +19,23 @@ public final class ViewRootImpl implements ViewParent,
 		}
 ```
 
-`View`的绘制过程从`ViewRootImpl.performTraversals()`方法开始。
+`View`的绘制过程从`ViewRootImpl.performTraversals()`方法开始，你看这个名字起的多好，叫执行遍历，看到名字就能知道内部的实现:   
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/view_performTraversals.png)
+
 首先先说明一下，这部分代码比较多，逻辑也比较麻烦，很容易弄晕，如果感觉看起来费劲，就跳过这一块，直接到下面的Measure、Layout、Draw部分开始看。
 我也没有全部弄清楚，我只是把里面的步骤标注了下。
+
 ```java
 private void performTraversals() {
 	// ... 此处省略源代码N行
-
+    if (mFirst || windowShouldResize || insetsChanged ||
+                viewVisibilityChanged || params != null || mForceNextWindowRelayout) {
+        // 第一或者resize等都会调用relayoutWindow，而该函数内部会调用sWindowSession.relayout()
+        // 方法来请求WmS按照指定的大小重新分配窗口大小，并会为客户窗口创建的mSurface对象分配真正的现存
+        // 等该函数返回后，应用程序就可以在该Surface中绘制了。
+		relayoutResult = relayoutWindow(params, viewVisibility, insetsPending);
+    }
 	// 是否需要Measure
 	if (!mStopped) {
 		boolean focusChangedDueToTouchMode = ensureTouchModeLocally(
@@ -35,6 +46,7 @@ private void performTraversals() {
 			// getRootMeasureSpec方法内部会使用MeasureSpec.makeMeasureSpec()方法来组装一个MeasureSpec，
 			// 当lp.width参数等于MATCH_PARENT的时候，MeasureSpec的specMode就等于EXACTLY，当lp.width等于WRAP_CONTENT的时候，MeasureSpec的specMode就等于AT_MOST。
 			// 并且MATCH_PARENT和WRAP_CONTENT时的specSize都是等于windowSize的，也就意味着根视图总是会充满全屏的。
+            // 这里lp代表的是根视图的LayoutParams、lp.width和lp.height直接来源于用户的定义比如WRAP_CONTENT、MATCH_PARENT等
 			int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
 			int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);
 
@@ -159,7 +171,14 @@ private void performTraversals() {
 `Measure`
 ===
 
+
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/view_measure.png)
+
+
+
 `performMeasure`方法如下：
+
 ```java
 private void performMeasure(int childWidthMeasureSpec, int childHeightMeasureSpec) {
 	Trace.traceBegin(Trace.TRACE_TAG_VIEW, "measure");
@@ -199,6 +218,7 @@ public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
 		Insets insets = getOpticalInsets();
 		int oWidth  = insets.left + insets.right;
 		int oHeight = insets.top  + insets.bottom;
+        // adjust是微调某个MeasureSpec的大小
 		widthMeasureSpec  = MeasureSpec.adjust(widthMeasureSpec,  optical ? -oWidth  : oWidth);
 		heightMeasureSpec = MeasureSpec.adjust(heightMeasureSpec, optical ? -oHeight : oHeight);
 	}
@@ -556,7 +576,14 @@ ps:譬如我们设置了`setMeasuredDimension(10, 10)`,那么不管布局中怎
 
 `Layout`
 ===
+
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/view_layout.png)
+
+
+
 `performLayout`方法源码如下：
+
 ```java
 private void performLayout(WindowManager.LayoutParams lp, int desiredWindowWidth,
 		int desiredWindowHeight) {
@@ -598,6 +625,7 @@ private void performLayout(WindowManager.LayoutParams lp, int desiredWindowWidth
 							" during layout: running second layout pass");
 					view.requestLayout();
 				}
+                // desiredWindowWidth和desiredWindowHeight是屏幕的尺寸
 				measureHierarchy(host, lp, mView.getContext().getResources(),
 						desiredWindowWidth, desiredWindowHeight);
 				mInLayout = true;
@@ -825,7 +853,12 @@ private void performLayout(WindowManager.LayoutParams lp, int desiredWindowWidth
 `Draw`
 ===
 
+
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/view_draw.png)
+
 绘制阶段是从`ViewRootImpl`中的`performDraw`方法开始的：
+
 ```java
 private void performDraw() {
 	if (mAttachInfo.mDisplayState == Display.STATE_OFF && !mReportNextDraw) {
@@ -887,6 +920,7 @@ private void performDraw() {
 ```java
 private void draw(boolean fullRedrawNeeded) {
 	Surface surface = mSurface;
+    // 首先检查surface是否有效，正常情况下都是有效的，除非WmS发生异常不能为该客户端分配有效的Surface
 	if (!surface.isValid()) {
 		return;
 	}
@@ -941,6 +975,8 @@ private void draw(boolean fullRedrawNeeded) {
 	}
 
 	final Rect dirty = mDirty;
+    // 判断该Surface是否有SurfaceHolder对象，如果有则意味着该Surface是应用程序创建的，因为所有的绘制操作应该由应用程序
+    // 自身去负责，于是View系统推出绘制，如果不是，才开始View绘制的内部流程。
 	if (mSurfaceHolder != null) {
 		// The app owns the surface, we won't draw.
 		dirty.setEmpty();
@@ -982,7 +1018,10 @@ private void draw(boolean fullRedrawNeeded) {
 	}
 
 	if (!dirty.isEmpty() || mIsAnimating) {
+        // Surface的底层驱动模式分为两种，一种是使用图形加速支持的Surface，俗称显卡，另一种是使用CPU及内存模拟的Surface。
+        // 因此这里需要根据不同的模式，进行不同的操作
 		if (mAttachInfo.mHardwareRenderer != null && mAttachInfo.mHardwareRenderer.isEnabled()) {
+            // 硬件绘制
 			// Draw with hardware renderer.
 			mIsAnimating = false;
 			boolean invalidateRoot = false;
@@ -1023,7 +1062,7 @@ private void draw(boolean fullRedrawNeeded) {
 				return;
 			}
 			
-			// draw的部分在这里。。。内部会用canvas去画
+			// 软件绘制
 			if (!drawSoftware(surface, mAttachInfo, xOffset, yOffset, scalingRequired, dirty)) {
 				return;
 			}
@@ -1032,6 +1071,7 @@ private void draw(boolean fullRedrawNeeded) {
 
 	if (animating) {
 		mFullRedrawNeeded = true;
+        // 动画就是让画面动起来，如果正在动画过程中，则需要再次发起一个重绘命令，以便接着绘制，直到滚动结束。
 		scheduleTraversals();
 	}
 }
@@ -1039,6 +1079,7 @@ private void draw(boolean fullRedrawNeeded) {
 我们看一下`drawSoftware`方法： 
 ```java
 /**
+ * 使用CPU的软件绘制方式
  * @return true if drawing was successful, false if an error occurred
  */
 private boolean drawSoftware(Surface surface, AttachInfo attachInfo, int xoff, int yoff,
@@ -1570,6 +1611,10 @@ private void performDraw() {
 而且`getMeasureWidth()`的值是通过`setMeasuredDimension()`设置的，但是`getWidth()`的值是通过视图右边的坐标减去左边的坐标计算出来的。如果我们在`layout`的时候将宽高
 不传`getMeasureWidth`的值，那么这时候`getWidth()`与`getMeasuredWidth`的值就不会再相同了，当然一般也不会这么干...
 
+# MeasureSpec
+
+MeasureSpec是View类的一个静态内部类，用来说明如何测量这个类。MeasureSpec表示的是一个32位的整型值，它的高2位表示测量模式SpecMode，低30位表示某种测量模式下的规格大小SpecSize。MeasureSpec通过将SpecMode和SpecSize打包成一个int值来避免过多的内存分配。
+
 ---
 
 - 邮箱 ：charon.chui@gmail.com  

From 81e42a8d57dfa487bb1086dcab28954bfbc84074 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Tue, 1 Dec 2020 21:39:51 +0800
Subject: [PATCH 037/213] add android kernal

---
 .../ANR\345\210\206\346\236\220.md"           | 66 -------------------
 ...345\217\212ANR\345\210\206\346\236\220.md" | 20 ++++--
 README.md                                     | 27 +++++++-
 3 files changed, 40 insertions(+), 73 deletions(-)
 delete mode 100644 "AdavancedPart/ANR\345\210\206\346\236\220.md"
 rename "AdavancedPart/crash\345\210\206\346\236\220.md" => "AdavancedPart/Crash\345\217\212ANR\345\210\206\346\236\220.md" (84%)

diff --git "a/AdavancedPart/ANR\345\210\206\346\236\220.md" "b/AdavancedPart/ANR\345\210\206\346\236\220.md"
deleted file mode 100644
index fc8ed472..00000000
--- "a/AdavancedPart/ANR\345\210\206\346\236\220.md"
+++ /dev/null
@@ -1,66 +0,0 @@
-# ANR分析
-
-Application Not Responding，字面意思就是应用无响应，稍加解释就是用户的一些操作无法从应用中获取反馈
-
-
-Android系统中的应用被Activity Manager及Window Manager两个系统服务监控着，Android系统会在如下情况展示出ANR的对话框: 
-- Service Timeout:比如前台服务在20s内未执行完成；后台服务超过200没有执行
-- BroadcastQueue Timeout：比如前台广播在10s内未执行完成，后台60s
-- ContentProvider Timeout：内容提供者,在publish过超时10s
-- InputDispatching Timeout: 输入事件分发超时5s，包括按键和触摸事件。
-
-
-
-ANR信息输出到traces.txt文件中
-
-traces.txt文件是一个ANR记录文件，用于开发人员调试，目录位于/data/anr中，无需root权限即可通过pull命令获取，下面的命令可以将traces.txt文件拷贝到当前目录下
-adb pull /data/anr .
-
-
-1) Thread基础信息
-
-输出种包含所有的线程，取其中的一条
-"Thread-1" prio=5 tid=0x00007fde73872800 nid=0x4a03 waiting for monitor entry [0x000000011cb30000]
-   java.lang.Thread.State: BLOCKED (on object monitor)
-    at Test.rightLeft(Test.java:48)
-    - waiting to lock <0x00000007d56540a0> (a Test$LeftObject)
-    - locked <0x00000007d5656180> (a Test$RightObject)
-    at Test$2.run(Test.java:68)
-    at java.lang.Thread.run(Thread.java:745)
-a) "Thread-1" prio=5 tid=0x00007fde73872800 nid=0x4a03 waiting for monitor entry [0x000000011cb30000]
-
-首先描述了线程名是『Thread-1』，然后prio=5表示优先级，tid表示的是线程id，nid表示native层的线程id，他们的值实际都是一个地址，后续给出了对于线程状态的描述，waiting for monitor entry [0x000000011cb30000]这里表示该线程目前处于一个等待进入临界区状态，该临界区的地址是[0x000000011cb30000]
-这里对线程的描述多种多样，简单解释下上面出现的几种状态
-
-    waiting on condition（等待某个事件出现）
-    waiting for monitor entry（等待进入临界区）
-    runnable（正在运行）
-    in Object.wait(处于等待状态)
-
-作者：silentleaf
-链接：https://www.jianshu.com/p/30c1a5ad63a3
-来源：简书
-著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
-
diff --git "a/AdavancedPart/crash\345\210\206\346\236\220.md" "b/AdavancedPart/Crash\345\217\212ANR\345\210\206\346\236\220.md"
similarity index 84%
rename from "AdavancedPart/crash\345\210\206\346\236\220.md"
rename to "AdavancedPart/Crash\345\217\212ANR\345\210\206\346\236\220.md"
index e3dd4ca7..40db0adf 100644
--- "a/AdavancedPart/crash\345\210\206\346\236\220.md"
+++ "b/AdavancedPart/Crash\345\217\212ANR\345\210\206\346\236\220.md"
@@ -48,10 +48,23 @@ Native Crash
 
 
 
-## ANR
+# ANR分析
 
+Application Not Responding，字面意思就是应用无响应，稍加解释就是用户的一些操作无法从应用中获取反馈
 
 
+Android系统中的应用被Activity Manager及Window Manager两个系统服务监控着，Android系统会在如下情况展示出ANR的对话框: 
+- Service Timeout:比如前台服务在20s内未执行完成；后台服务超过200没有执行
+- BroadcastQueue Timeout：比如前台广播在10s内未执行完成，后台60s
+- ContentProvider Timeout：内容提供者,在publish过超时10s
+- InputDispatching Timeout: 输入事件分发超时5s，包括按键和触摸事件。
+
+
+
+ANR信息输出到traces.txt文件中
+
+traces.txt文件是一个ANR记录文件，用于开发人员调试，目录位于/data/anr中，无需root权限即可通过pull命令获取，下面的命令可以将traces.txt文件拷贝到当前目录下
+adb pull /data/anr .
 
 ANR排查流程
 1、Log获取
@@ -111,10 +124,7 @@ sCount：该线程被挂起的次数
 dsCount：该线程被调试器挂起的次数
 self：线程本身的地址
 
-作者：jsonchao
-链接：https://juejin.cn/post/6844903972587716621
-来源：掘金
-著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
+
 
 
 
diff --git a/README.md b/README.md
index 91a59d53..af998819 100644
--- a/README.md
+++ b/README.md
@@ -104,6 +104,16 @@ Android学习笔记
     - [6.文件管理][269]
     - [7.嵌入式系统][270]
     - [8.虚拟机][271]
+        - [Android内核][274]
+            - [1.Android进程间通信][275]
+            - [2.Android线程间通信之Handler消息机制][276]
+            - [3.Android Framework框架][277]
+            - [4.ActivityManagerService简介][278]
+            - [5.Android消息获取][279]
+            - [6.屏幕绘制基础][280]
+            - [7.View绘制原理][281]
+            - [8.WindowManagerService简介][282]
+            - [9.PackageManagerService简介][283]
 - [架构设计][272]
     - [1.架构简介][273]
 
@@ -183,7 +193,7 @@ Android学习笔记
     - [ApplicationId vs PackageName][77]
     - [ART与Dalvik][78]
     - [BroadcastReceiver安全问题][79]
-    - [Handler导致内存泄露分析][80]
+    - [Crash及ANR分析][80]
     - [Library项目中资源id使用case时报错][81]
     - [Mac下配置adb及Android命令][82]
     - [MaterialDesign使用][83]
@@ -378,7 +388,7 @@ Android学习笔记
 [77]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/ApplicationId%20vs%20PackageName.md   "ApplicationId vs PackageName"
 [78]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/ART%E4%B8%8EDalvik.md   "ART与Dalvik"
 [79]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/BroadcastReceiver%E5%AE%89%E5%85%A8%E9%97%AE%E9%A2%98.md   "BroadcastReceiver安全问题"
-[80]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/Handler%E5%AF%BC%E8%87%B4%E5%86%85%E5%AD%98%E6%B3%84%E9%9C%B2%E5%88%86%E6%9E%90.md   "Handler导致内存泄露分析"
+[80]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/Handler%E5%AF%BC%E8%87%B4%E5%86%85%E5%AD%98%E6%B3%84%E9%9C%B2%E5%88%86%E6%9E%90.md   "Crash及ANR分析"
 [81]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/Library%E9%A1%B9%E7%9B%AE%E4%B8%AD%E8%B5%84%E6%BA%90id%E4%BD%BF%E7%94%A8case%E6%97%B6%E6%8A%A5%E9%94%99.md   "Library项目中资源id使用case时报错"
 [82]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/Mac%E4%B8%8B%E9%85%8D%E7%BD%AEadb%E5%8F%8AAndroid%E5%91%BD%E4%BB%A4.md   "Mac下配置adb及Android命令"
 [83]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/MaterialDesign%E4%BD%BF%E7%94%A8.md   "MaterialDesign使用"
@@ -578,6 +588,19 @@ Android学习笔记
 [271]: https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/8.%E8%99%9A%E6%8B%9F%E6%9C%BA.md "8.虚拟机"
 [272]: https://github.com/CharonChui/AndroidNote/tree/master/Architect "架构设计"
 [273]: https://github.com/CharonChui/AndroidNote/blob/master/Architect/1.%E6%9E%B6%E6%9E%84%E7%AE%80%E4%BB%8B.md "1.架构简介"
+[274]: https://github.com/CharonChui/AndroidNote/tree/master/OperatingSystem/AndroidKernal  "Android内核"
+[275]: https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/AndroidKernal/1.Android%E8%BF%9B%E7%A8%8B%E9%97%B4%E9%80%9A%E4%BF%A1.md "1.Android进程间通信"
+[276]:  https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/AndroidKernal/2.Android%E7%BA%BF%E7%A8%8B%E9%97%B4%E9%80%9A%E4%BF%A1%E4%B9%8BHandler%E6%B6%88%E6%81%AF%E6%9C%BA%E5%88%B6.md "2.Android线程间通信之Handler消息机制"
+[277]: https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/AndroidKernal/3.Android%20Framework%E6%A1%86%E6%9E%B6.md "3.Android Framework框架"
+[278]: https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/AndroidKernal/4.ActivityManagerService%E7%AE%80%E4%BB%8B.md "4.ActivityManagerService简介"
+[279]: https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/AndroidKernal/5.Android%E6%B6%88%E6%81%AF%E8%8E%B7%E5%8F%96.md "5.Android消息获取"
+[280]: https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/AndroidKernal/6.%E5%B1%8F%E5%B9%95%E7%BB%98%E5%88%B6%E5%9F%BA%E7%A1%80.md "6.屏幕绘制基础"
+[281]: https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/AndroidKernal/7.View%E7%BB%98%E5%88%B6%E5%8E%9F%E7%90%86.md "7.View绘制原理"
+[282]: https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/AndroidKernal/8.WindowManagerService%E7%AE%80%E4%BB%8B.md "8.WindowManagerService简介"
+
+[283]: https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/AndroidKernal/9.PackageManagerService%E7%AE%80%E4%BB%8B.md "9.PackageManagerService简介"
+
+
 
 
 Developed By

From 969ea96417418e8461b022b5f7aa9a936ac7e327 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Tue, 1 Dec 2020 21:42:28 +0800
Subject: [PATCH 038/213] update readme

---
 README.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index af998819..cb8b3b84 100644
--- a/README.md
+++ b/README.md
@@ -388,7 +388,8 @@ Android学习笔记
 [77]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/ApplicationId%20vs%20PackageName.md   "ApplicationId vs PackageName"
 [78]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/ART%E4%B8%8EDalvik.md   "ART与Dalvik"
 [79]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/BroadcastReceiver%E5%AE%89%E5%85%A8%E9%97%AE%E9%A2%98.md   "BroadcastReceiver安全问题"
-[80]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/Handler%E5%AF%BC%E8%87%B4%E5%86%85%E5%AD%98%E6%B3%84%E9%9C%B2%E5%88%86%E6%9E%90.md   "Crash及ANR分析"
+[80]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/Crash%E5%8F%8AANR%E5%88%86%E6%9E%90.md  "Crash及ANR分析"
+
 [81]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/Library%E9%A1%B9%E7%9B%AE%E4%B8%AD%E8%B5%84%E6%BA%90id%E4%BD%BF%E7%94%A8case%E6%97%B6%E6%8A%A5%E9%94%99.md   "Library项目中资源id使用case时报错"
 [82]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/Mac%E4%B8%8B%E9%85%8D%E7%BD%AEadb%E5%8F%8AAndroid%E5%91%BD%E4%BB%A4.md   "Mac下配置adb及Android命令"
 [83]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/MaterialDesign%E4%BD%BF%E7%94%A8.md   "MaterialDesign使用"

From 2bb6382ef5ee14cb8d5b58b858bbf32c1f1d0220 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 2 Dec 2020 21:47:15 +0800
Subject: [PATCH 039/213] update README

---
 ...73\347\273\237\347\256\200\344\273\213.md" | 42 +++++++-------
 ...13\344\270\216\347\272\277\347\250\213.md" | 57 +++++++------------
 ...05\345\255\230\347\256\241\347\220\206.md" | 37 +++++++-----
 .../4.\350\260\203\345\272\246.md"            | 12 ++--
 OperatingSystem/5.I:O.md                      |  8 ++-
 ...07\344\273\266\347\256\241\347\220\206.md" |  2 +
 ...45\345\274\217\347\263\273\347\273\237.md" |  2 +-
 ...8.\350\231\232\346\213\237\346\234\272.md" |  5 +-
 ...13\351\227\264\351\200\232\344\277\241.md" | 54 +++++++++---------
 9 files changed, 115 insertions(+), 104 deletions(-)

diff --git "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md" "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
index 09bff58c..4e34b27f 100644
--- "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
+++ "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
@@ -148,29 +148,29 @@ Linux内核被装载后，就开始进行内核初始化的过程。
 
 ## CPU(Central Processing Unit)
 
-CPU(中央处理器)是计算机的大脑，它主要和内存进行交互，从内存中提取指令并执行它。它是一块超大规模的集成电路Integrated Circuit)，是信息处理、程序运行的最终执行单元。其功能主要是解释计算机指令以及处理计算机软件中的数据。由于访问内存获取执行或数据要比执行指令花费的时间长，因此所有的 CPU 内部都会包含一些寄存器来保存关键变量和临时结果。因此，在指令集中通常会有一些指令用于把关键字从内存中加载到寄存器中，以及把关键字从寄存器存入到内存中。从功能方面来看，CPU的内部主要由寄存器，控制器，运算器构成，各部分之间由电流信号相互连通。其中运算器负责算术运算和逻辑运算，控制器负责计算指令的解析，产生各种控制指令，寄存器组用来临时存放参加运算的数据和计算的中间结果。CPU计算结果最终需要写到内存中，内存的存取速度远低于CPU，为提升数据交换速率，CPU内部一般还集成了高速缓存（CACHE）,其中缓存分为一级缓存和二级缓存，一级缓存和CPU速率相当，二级缓存次之。
+CPU(中央处理器)是计算机的大脑，它主要和内存进行交互，从内存中提取指令并执行它。它是一块超大规模的集成电路(Integrated Circuit)，是信息处理、程序运行的最终执行单元。其功能主要是解释计算机指令以及处理计算机软件中的数据。由于访问内存获取执行或数据要比执行指令花费的时间长，因此所有的 CPU 内部都会包含一些寄存器来保存关键变量和临时结果。因此，在指令集中通常会有一些指令用于把关键字从内存中加载到寄存器中，以及把关键字从寄存器存入到内存中。从功能方面来看，CPU的内部主要由寄存器，控制器，运算器构成，各部分之间由电流信号相互连通。其中运算器负责算术运算和逻辑运算，控制器负责计算指令的解析，产生各种控制指令，寄存器组用来临时存放参加运算的数据和计算的中间结果。CPU计算结果最终需要写到内存中，内存的存取速度远低于CPU，为提升数据交换速率，CPU内部一般还集成了高速缓存（CACHE）,其中缓存分为一级缓存和二级缓存，一级缓存和CPU速率相当，二级缓存次之。
 
 
 
 **程序是把寄存器作为对象来描述的**
 
-使用高级语言编写的程序会在编译后转化成机器语言，然后通过CPU内部的寄存器来处理。不同类型的CPU，其内部寄存器的数量，种类以及寄存器存储的数值范围都是不同的。根据功能的不同，我们可以将寄存器大致划分为八类。
+使用高级语言编写的程序会在编译后转化成机器语言，然后通过CPU内部的寄存器来处理。不同类型的CPU，其内部寄存器的数量，种类以及寄存器存储的数值范围都是不同的。根据功能的不同，我们可以将寄存器大致划分为八类: 
 
-***累加寄存器简称累加器(Accumulator， AC)***：是一个通用寄存器。存储临时的执行运算的数据和运算后的数据。
+- ***累加寄存器简称累加器(Accumulator， AC)***：是一个通用寄存器。存储临时的执行运算的数据和运算后的数据。
 
-***标志寄存器***：存储运算处理后的CPU的状态。
+- ***标志寄存器***：存储运算处理后的CPU的状态。
 
-***程序计数器(Program Counter, PC)***：存储下一条指令所在内存的地址。
+- ***程序计数器(Program Counter, PC)***：存储下一条指令所在内存的地址。
 
-***基址寄存器***：存储数据内存的起始地址。
+- ***基址寄存器***：存储数据内存的起始地址。
 
-***变址寄存器***：存储基址寄存器的相对地址。
+- ***变址寄存器***：存储基址寄存器的相对地址。
 
-***通用寄存器***：存储任意数据。
+- ***通用寄存器***：存储任意数据。
 
-***指令寄存器(Instruction Register, IR)***：存储指令，CPU取到的指令存放在处理器的一个寄存器中，这个寄存器就是指令寄存器。CPU内部使用，程序员无法通过程序对该寄存器进行读写操作。
+- ***指令寄存器(Instruction Register, IR)***：存储指令，CPU取到的指令存放在处理器的一个寄存器中，这个寄存器就是指令寄存器。CPU内部使用，程序员无法通过程序对该寄存器进行读写操作。
 
-***栈寄存器***：存储栈区域的起始地址。
+- ***栈寄存器***：存储栈区域的起始地址。
 
 其中，程序计数器，累加寄存器，标志寄存器，指令寄存器和栈寄存器都只有一个，其他的寄存器一般有多个。
 
@@ -191,11 +191,11 @@ CPU(中央处理器)是计算机的大脑，它主要和内存进行交互，从
 
 ## CPU 指令执行过程
 
-那么 CPU 是如何执行一条条的指令的呢？
+那么CPU是如何执行一条条的指令的呢？
 
 几乎所有的冯·诺伊曼型计算机的CPU，其工作都可以分为5个阶段：**取指令、指令译码、执行指令、访存取数、结果写回**。
 
-- 取指令阶段是将内存中的指令读取到 CPU 中寄存器的过程，程序寄存器用于存储下一条指令所在的地址
+- 取指令阶段是将内存中的指令读取到CPU中寄存器的过程，程序寄存器用于存储下一条指令所在的地址
 - 指令译码阶段，在取指令完成后，立马进入指令译码阶段，在指令译码阶段，指令译码器按照预定的指令格式，对取回的指令进行拆分和解释，识别区分出不同的指令类别以及各种获取操作数的方法。
 - 执行指令阶段，译码完成后，就需要执行这一条指令了，此阶段的任务是完成指令所规定的各种操作，具体实现指令的功能。
 - 访问取数阶段，根据指令的需要，有可能需要从内存中提取数据，此阶段的任务是：根据指令地址码，得到操作数在主存中的地址，并从主存中读取该操作数用于运算。
@@ -230,13 +230,13 @@ CPU(中央处理器)是计算机的大脑，它主要和内存进行交互，从
 
 
 
-所有计算机都提供了允许其他模块（I/O、存储器)中断处理器正常处理过程的机制。中断最初是用于提高处理器效率的一种手段。例如，多数I/O设备都要远慢于处理器，处理器必须暂停并保持空闲，直到打印机完成工作。暂停的时间长度可能相当于成百上千哥不涉及存储器的指令周期，显然，这对于处理器的使用来说是非常浪费的。这种只有一个单独程序的情况，称为单道程序设计。在单道程序设计中处理器话费一定的运行时间进行计算，直到遇到一个I/O指令，这时它必须等到该I/O指令结束后才能继续执行。这种问题是可以避免的，就是存储器可以保存多个程序，在一个程序等待时通过切换去执行其他的程序，这种处理称为多道程序设计或多任务处理。它是现代操作系统的主要方案。多道程序设计的目的是为了让处理器和I/O设备（包括存储设备）同时报出忙状态，以实现最大的效率。
+所有计算机都提供了允许其他模块（I/O、存储器)中断处理器正常处理过程的机制。中断最初是用于提高处理器效率的一种手段。例如，多数I/O设备都要远慢于处理器，处理器必须暂停并保持空闲，直到打印机完成工作。暂停的时间长度可能相当于成百上千个不涉及存储器的指令周期，显然，这对于处理器的使用来说是非常浪费的。这种只有一个单独程序的情况，称为单道程序设计。在单道程序设计中处理器话费一定的运行时间进行计算，直到遇到一个I/O指令，这时它必须等到该I/O指令结束后才能继续执行。这种问题是可以避免的，就是存储器可以保存多个程序，在一个程序等待时通过切换去执行其他的程序，这种处理称为多道程序设计或多任务处理。它是现代操作系统的主要方案。多道程序设计的目的是为了让处理器和I/O设备（包括存储设备）同时保持忙状态，以实现最大的效率。
 
 
 
-利用中断功能，处理器可以在I/O操作的执行过程中去执行其他命令。在这期间，如果I/O操作已经完成，此时外部设备在做好服务的准备后，即它准备好从处理器接收更多的数据时，外部设备的I/O模块给处理器发送一个中断请求信号。这时处理器会做出相应，暂停当前程序的处理，转去处理服务于特定I/O设备的程序，这种程序被称为中断处理程序(interupt handler)。在对该设备的服务响应完成后，处理器恢复原来的执行。
+利用中断功能，处理器可以在I/O操作的执行过程中去执行其他命令。在这期间，如果I/O操作已经完成，此时外部设备在做好服务的准备后，即它准备好从处理器接收更多的数据时，外部设备的I/O模块给处理器发送一个中断请求信号。这时处理器会做出响应，暂停当前程序的处理，转去处理服务于特定I/O设备的程序，这种程序被称为中断处理程序(interupt handler)。在对该设备的服务响应完成后，处理器恢复原来的执行。
 
-从用户程序的角度来看，中断打断了正常执行的序列。中断处理完成后，再回复执行。因此，用户程序并不需要为中断添加任何特殊的代码，处理器和操作系统负责挂起用户程序，然后在同一个地方恢复执行。
+从用户程序的角度来看，中断打断了正常执行的序列。中断处理完成后，再恢复执行。因此，用户程序并不需要为中断添加任何特殊的代码，处理器和操作系统负责挂起用户程序，然后在同一个地方恢复执行。
 
 为使用中断产生的情况，在指令周期中要增加一个中断阶段。在中断阶段，处理器检查是否有中断发生，即检查是否出现中断信号。若没有中断，处理器继续运行，并在取指周期取当前程序的下一条指令。若有中断，处理器挂起当前程序的执行，并执行一个中断处理程序。这个中断处理程序通常是操作系统的一部分，它确定中断的性质，并执行所需要的操作。
 
@@ -256,7 +256,7 @@ CPU(中央处理器)是计算机的大脑，它主要和内存进行交互，从
 2. 处理器在响应中断前结束当前指令的执行。
 3. 处理器对中断进行测试，确定存在未响应的中断，并给提交中断的设备发送确认信号，确认信号允许该设备取消它的中断信号。
 4. 处理器需要准备把控制权转交给中断程序。首先，需要保存从中断点恢复当前程序所需要的信息，要求的最少信息包括程序状态字（PSW）和保存在程序计数器（PC）中的下一条要执行的指令地址，它们被压入系统控制栈。
-5. 处理器把相应此中断的中断处理程序入口地址装入程序计数器。每类中断可由一个中断处理程序，具体取决于计算机系统架构和操作系统的设计。如果有多个中断程序，这一信息可能已包含在最初的中断信号中，否则处理器必须给发中断的设备发送请求，以获取含有所需信息的响应。一旦装入程序计数器，处理器就继续执行下一个指令周期，该指令周期也从取指开始。由于取指是由程序计数器的内容决定的，因此控制权被转交给中断处理程序，该程序会引起以下操作： 
+5. 处理器把响应此中断的中断处理程序入口地址装入程序计数器。每类中断可由一个中断处理程序，具体取决于计算机系统架构和操作系统的设计。如果有多个中断程序，这一信息可能已包含在最初的中断信号中，否则处理器必须给发中断的设备发送请求，以获取含有所需信息的响应。一旦装入程序计数器，处理器就继续执行下一个指令周期，该指令周期也从取指开始。由于取指是由程序计数器的内容决定的，因此控制权被转交给中断处理程序，该程序会引起以下操作： 
 6. 在这一点，与被中断程序相关的程序计数器和PSW被保存到系统栈中，此外，还有一些其他信息被当做正在执行程序的状态的一部分。特别需要保存处理器寄存器的内容，因为中断处理程序可能会用到这些寄存器，因此所有这些值和任何其他状态信息都需要保存。
 7. 中断处理程序现在可以开始处理中断，其中包括检查与I/O操作相关的状态信息或其他引起中断的事件，还可能包括给I/O设备发送附加命令或应答。
 8. 中断处理结束后，被保存的寄存器值从栈中释放并恢复到寄存器中。
@@ -284,7 +284,7 @@ CPU(中央处理器)是计算机的大脑，它主要和内存进行交互，从
 
 - 高速缓存，它多数由硬件控制。
 
-- 主存：这是存储器系统的主力。主存通常称为随机访问存储器(Random Access Memory，RAM），内存是计算机中主要的内部内部存储器系统。内存中的每个单元位置都有唯一的地址对应，而且大多数机器指令会访问一个或多个内存地址。内存通常是告诉的、容量较小的告诉缓存的扩展。
+- 主存：这是存储器系统的主力。主存通常称为随机访问存储器(Random Access Memory，RAM），内存是计算机中主要的内部内部存储器系统。内存中的每个单元位置都有唯一的地址对应，而且大多数机器指令会访问一个或多个内存地址。内存通常是高速的、容量较小的高速缓存的扩展。
 
 - 磁盘：磁盘同RAM相比，成本降低了，但是随机访问数据时间也慢了。其低速的原因是因为磁盘是一种机械装置。一个磁盘中有一个或多个金属盘片，他们以一定的速度旋转，从边缘开始有一个机械臂悬横在盘面上，这类似于老式播放塑料唱片的唱片机。
 
@@ -294,9 +294,9 @@ CPU(中央处理器)是计算机的大脑，它主要和内存进行交互，从
 
     有时，还有一些实际上不是磁盘的磁盘，比如固态硬盘（Solid State Disk，SSD）。固态硬盘并没有可以移动的部分，外形也不像唱片那样，并且数据是存储在存储器（闪存）中的。与磁盘唯一的相似之处就是它也存储了大量即使在电源关闭时也不会丢失的数据。  
     
-    这里要说一下闪存(flash memory)，闪存是一种基于硅芯片的存储介质，可以用电写入或擦除。在便捷式电子设备中，闪存通常作为存储媒介。闪存是数吗相机中的胶卷。是便捷式音乐播放器的磁盘。这仅仅是闪存用途的两项。闪存在速度上介于RAM和磁盘之间。另外，与磁盘存储器不同的是，如果闪存擦除次数过多，就被磨损了。
+    这里要说一下闪存(flash memory)，闪存是一种基于硅芯片的存储介质，可以用电写入或擦除。在便捷式电子设备中，闪存通常作为存储媒介。闪存是数码相机中的胶卷。是便捷式音乐播放器的磁盘。这仅仅是闪存用途的两项。闪存在速度上介于RAM和磁盘之间。另外，与磁盘存储器不同的是，如果闪存擦除次数过多，就被磨损了。
     
-    那闪存和固态硬盘有什么区别？固态硬盘也是将数据存储在闪存中。在存储行业中使用的最简单的类比之一是闪存就像鸡蛋，而SSD硬盘就像煎蛋卷一样。煎蛋卷主要是由鸡蛋制作的，而SSD硬盘主要由闪存支制成的。
+    那闪存和固态硬盘有什么区别？固态硬盘也是将数据存储在闪存中。在存储行业中使用的最简单的类比之一是闪存就像鸡蛋，而SSD硬盘就像煎蛋卷一样。煎蛋卷主要是由鸡蛋制作的，而SSD硬盘主要由闪存制成的。
 
 
 
@@ -397,6 +397,10 @@ Android在Linux内核中增加了两个提升电源管理能力的新功能： 
 
 
 
+
+
+----
+
 - [下一篇:2.进程与线程](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/2.%E8%BF%9B%E7%A8%8B%E4%B8%8E%E7%BA%BF%E7%A8%8B.md)
 
 
diff --git "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md" "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
index 83bfc7f2..3f5369e6 100644
--- "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
+++ "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
@@ -24,9 +24,9 @@
 
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/cpu_process.png)
 
-上图是一种进程管理方法。两个进程A和B存在与内存中的某些部分，给每个进程（包含程序、数据和上下文信息）分配了一块存储器区域，并且在由操作系统建立和维护的进程表中进行了记录。进程表包含记录每个进程的表项，表项内容包括指向包含进程的存储块地址的指针，还包括该进程的部分和全部上下文。执行上下文的其余部分存放在别处，可能和进程本身存在一起，通常还可能保存在内存中的一块独立区域。进程索引寄存器（process index register）包含当前正在控制处理器的进程在进程表中的索引。程序计数器（program counter）指向该进程中下一条待执行的指令。基址寄存器中保存该存储器区域的开始地址。
+上图是一种进程管理方法。两个进程A和B存在于内存中的某些部分，给每个进程（包含程序、数据和上下文信息）分配了一块存储器区域，并且在由操作系统建立和维护的进程表中进行了记录。进程表包含记录每个进程的表项，表项内容包括指向包含进程的存储块地址的指针，还包括该进程的部分和全部上下文。执行上下文的其余部分存放在别处，可能和进程本身存在一起，通常还可能保存在内存中的一块独立区域。进程索引寄存器（process index register）包含当前正在控制处理器的进程在进程表中的索引。程序计数器（program counter）指向该进程中下一条待执行的指令。基址寄存器中保存该存储器区域的开始地址。
 
-图中表示，进程索引寄存器表明进程B正在执行。以前执行的进程被临时中断，在A中断的同事，所有寄存器的内容被记录在其执行上下文环境中，以后操作系统就可以执行进程切换。恢复进程A的执行。进程切换过程中包括保存B的上下文和恢复A的上下文。在程序计数器中载入指向A的程序区域的值时，进程A自动恢复执行。
+图中表示，进程索引寄存器表明进程B正在执行。以前执行的进程被临时中断，在A中断的同时，所有寄存器的内容被记录在其执行上下文环境中，以后操作系统就可以执行进程切换。恢复进程A的执行。进程切换过程中包括保存B的上下文和恢复A的上下文。在程序计数器中载入指向A的程序区域的值时，进程A自动恢复执行。
 
 在任何多道程序设计系统中，CPU由一个进程快速切换至另一个进程，使每个进程各运行几十或几百毫秒。严格来说，在某一个瞬间，CPU只能运行一个进程。但在1秒钟内，它可能运行多个进程，这样就产生并行的错觉。CPU在各进程之间来回切换，这种快速的切换称为多道程序设计。
 
@@ -68,8 +68,8 @@
 
 - 就绪态：进程做好了准备，只要有机会就开始执行
 - 运行态：进程正在执行
-- 堵塞/等待态：进程在某些事件发生前补鞥呢执行，如I/O操作完成
-- 新建态：刚刚创建的进程，操作系统还未把他加入可执行进程组，它通常是进程控制块已经创建但还未加载到内存中的新进程
+- 堵塞/等待态：进程在某些事件发生前不能执行，如I/O操作完成
+- 新建态：刚刚创建的进程，操作系统还未把它加入可执行进程组，它通常是进程控制块已经创建但还未加载到内存中的新进程
 - 退出态：操作系统从可执行进程组中释放出的进程，要么它自身已停止，要么它因某种原因被取消
 
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/process_state.png)
@@ -82,11 +82,11 @@
 
 ### 进程由哪几部分组成？
 
-进程是程序的一次运行过程，它是由程序段、数据段和进程控制块 PCB 组成的一个实体，其中：
+进程是程序的一次运行过程，它是由程序段、数据段和进程控制块PCB组成的一个实体，其中：
 
 - 程序段：对应程序的操作代码部分，用于描述进程所需要完成的功能。
 - 数据段：对应程序执行时所需要的数据部分，包括数据，堆栈和工作区。
-- 进程控制块(Process Control Block, PCB) ：描述进程的基本信息和运行状态，记录了进程运行时所需要的全部信息，它是进程存在的唯一标识，与进程一一对应。所谓的创建进程和撤销进程，都是指对 PCB 的操作。
+- 进程控制块(Process Control Block, PCB) ：描述进程的基本信息和运行状态，记录了进程运行时所需要的全部信息，它是进程存在的唯一标识，与进程一一对应。所谓的创建进程和撤销进程，都是指对PCB的操作。
 
 #### 进程控制块
 
@@ -101,7 +101,7 @@
 - I/O状态信息:包括显式I/O请求、分配给进程的I/O设备和被进程使用的文件列表等
 - 记账信息:包括处理器时间总和、使用的时钟数总和、时间限制、及账号等
 
-上述列表信息存放在一个被称为进程控制块(process control block)的数据结构中，控制块由操作系统创建和管理。系统通过 PCB 感知进程的存在，并对其进行有效管理和控制。系统创建一个新进程时，为它建立一个PCB；当进程结束时，系统又收回其PCB，该进程也随之消亡。
+上述列表信息存放在一个进程控制块(process control block)的数据结构中，控制块由操作系统创建和管理。系统通过PCB感知进程的存在，并对其进行有效管理和控制。系统创建一个新进程时，为它建立一个PCB；当进程结束时，系统又收回其PCB，该进程也随之消亡。
 
 
 
@@ -119,7 +119,7 @@
 
 ## 进程切换
 
-操作系统为了执行进程间的切换，会维护着一张表格，这张表就是 进程表(process table)。每个进程占用一个进程表项。该表项包含了进程状态的重要信息，包括程序计数器、堆栈指针、内存分配状况、所打开文件的状态、账号和调度信息，以及其他在进程由运行态转换到就绪态或阻塞态时所必须保存的信息，从而保证该进程随后能再次启动，就像从未被中断过一样。
+操作系统为了执行进程间的切换，会维护着一张表格，这张表就是进程表(process table)。每个进程占用一个进程表项。该表项包含了进程状态的重要信息，包括程序计数器、堆栈指针、内存分配状况、所打开文件的状态、账号和调度信息，以及其他在进程由运行态转换到就绪态或阻塞态时所必须保存的信息，从而保证该进程随后能再次启动，就像从未被中断过一样。
 
 **操作系统最底层的就是调度程序**，在它上面有许多进程。所有关于中断处理、启动进程和停止进程的具体细节都隐藏在调度程序中。事实上，调度程序只是一段非常小的程序。
 
@@ -131,7 +131,7 @@
 
 - 时钟中断：操作系统确定当前正运行进程的执行时间是否已超过最大允许时间段(时间片，即进程中断前可以执行的最大时间段)。若超过，进程就切换到就绪态，并调入另一个进程。
 - I/O中断：操作系统确定是否已发生I/O活动。若I/O活动是一个或多个进程正在等待的事件，则操作系统就把所处于堵塞态的进程转换为就绪态( 堵塞/挂起态进程转换为就绪/挂起态)。操作系统必须决定是继续执行当前处于运行态的进程，还是让具有高优先级的就绪态进程抢占这个进程。
-- 内存失效：处理器遇到一个引用不在内存中的字的虚存地址时，操作系统就必须从外村中把包含这一引用的内存块(页或段)调入内存。发出调入内存块的I/O请求后，内存失效进程将进入堵塞态。操作系统然后切换进程，恢复另一个进程的执行。期望的块调入内存后，该进程置为就绪态。
+- 内存失效：处理器遇到一个引用不在内存中的字的虚存地址时，操作系统就必须从外存中把包含这一引用的内存块(页或段)调入内存。发出调入内存块的I/O请求后，内存失效进程将进入堵塞态。操作系统然后切换进程，恢复另一个进程的执行。在等该期望的内存块调入内存后，该进程置为就绪态。
 
 对于陷阱(trap)，操作系统则确定错误或异常条件是否致命。致命时，当前正运行进程置为退出态，并切换进程。不致命时，操作系统的动作将取决于错误的性质和操作系统的设计，操作系统可能会尝试恢复程序，或简单的通知用户。操作系统可能会切换进程或继续当前运行的进程。 
 
@@ -175,7 +175,7 @@
 
 - 信号
 
-    基本原来是：两个或多个进程可以通过简单的信号进行合作，可以强迫一个进程在某个位置停止，直到它接收到一个特定的信号。
+    两个或多个进程可以通过简单的信号进行合作，可以强迫一个进程在某个位置停止，直到它接收到一个特定的信号。
 
 - 共享存储系统
 
@@ -349,7 +349,7 @@ zygote进程对应的具体程序是app_process，该程序存在于system/bin
 
 #### System Server进程
 
-System Server进程是由zygote进程fork而来，System Server是zygote孵化的第一个Dalvik进程，SystemServer仅仅是该进程的别名，而该进程具体对应的程序依然是app_process，因为System是从app_process中孵化出来的。System Server负责启动和管理整个Java framework，SystemServer进程在Android的运行环境中扮演了“神经中枢”的作用，APK应用中能够直接交互的大部分系统服务都在该进程中运行，常见的有WindowManagerServer（WmS）、ActivityManagerSystemService（AmS）、PackageManagerServer（PmS）等，这些系统服务都是以一个线程的方式存在于SystemServer进程中。SystemServer的main()函数会首先创建一个ServerThread对象，该对象是一个线程，然后直接运行该线程。而在ServerThread的run()方法内部真正启动各种服务线程，都有:  
+System Server进程是由zygote进程fork而来，System Server是zygote孵化的第一个Dalvik进程，SystemServer仅仅是该进程的别名，而该进程具体对应的程序依然是app_process，因为System是从app_process中孵化出来的。System Server负责启动和管理整个Java framework，SystemServer进程在Android的运行环境中扮演了“神经中枢”的作用，APK应用中能够直接交互的大部分系统服务都在该进程中运行，常见的有WindowManagerServer（WmS）、ActivityManagerService（AmS）、PackageManagerServer（PmS）等，这些系统服务都是以一个线程的方式存在于SystemServer进程中。SystemServer的main()函数会首先创建一个ServerThread对象，该对象是一个线程，然后直接运行该线程。而在ServerThread的run()方法内部真正启动各种服务线程，都有:  
 
 - EntropyService：提供伪随机数
 - PowerManagerService：电源管理服务
@@ -384,7 +384,7 @@ SystemServer中创建了一个Socket客户端，并有AmS负责管理该客户
 
 从系统架构的角度来看，先创建一个zygote并加载共享类的资源，然后通过该zygote去孵化新的Dalvik进程，该架构的特点有两个:    
 
-- 每一个进程都是一个Dalvik虚拟机，而Dalvik虚拟机是一个类似于Java虚拟机的程序，并且从开发的过程来看，与标准的Java程序开发基本一致。因此对于程序员来讲，必须要学习新的语言，并可以使用Java程序在过去几十年中已经成熟的各种类库资源。
+- 每一个进程都是一个Dalvik虚拟机，而Dalvik虚拟机是一个类似于Java虚拟机的程序，并且从开发的过程来看，与标准的Java程序开发基本一致。因此对于程序员来讲，不须要学习新的语言，并可以使用Java程序在过去几十年中已经成熟的各种类库资源。
 - zygote进程预先会装载共享类和共享资源，这些类及资源实际上就是SDK中定义的大部分类和资源，因此，当通过zygote孵化出新的进程后，新的APK进程只需要去装载APK自身包含的类和资源即可，这就有效的解决了多个APK共享Framework资源的问题。
 
 
@@ -401,7 +401,7 @@ Android使用的进程有些不同。活动管理器是Android负责正在运行
 
 ### 启动进程
 
-为了启动新进程，活动管理器需要与zygote通信。活动管理器首先开始，它创建一个与zygote相连的专用接口，通过接口发送一条指令，表示它需要启动一个进程。这条指令主要描述需要创建的沙箱、新进程运行所需要的UID以及需要遵守的安全性制约。zygote需要作为根来运行：创建新进程时，它合理配置运行所需的UID，最终下放权限，将进程改为该UID。
+为了启动新进程，活动管理器需要与zygote通信。活动管理器首先创建一个与zygote相连的专用接口，通过接口发送一条指令，表示它需要启动一个进程。这条指令主要描述需要创建的沙箱、新进程运行所需要的UID以及需要遵守的安全性制约。zygote需要作为根来运行：创建新进程时，它合理配置运行所需的UID，最终下放权限，将进程改为该UID。
 
 ![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_start_process.png?raw=true)
 
@@ -409,8 +409,8 @@ Android使用的进程有些不同。活动管理器是Android负责正在运行
 
 1. 某个现有进程（如应用程序启动器）调用活动管理器，发出意图，描述它想要启动的新活动。
 2. 活动管理器要求封装管理器将这个意图解析为一个明确的组件。
-3. 活动管理器判断这个应用程序的进程并未正在运行，然后向zygote请求一个具有合适UID的新锦成。
-4. zygote进行一次fork指令，克隆自己来创造一个新进程，下方权限并配置新进程的UID和沙箱，初始化该进程的Dalvik，使得Java runtime开始完全执行。例如，它需要在fork后启动垃圾收集等线程。
+3. 活动管理器判断这个应用程序的进程并未正在运行，然后向zygote请求一个具有合适UID的新进程。
+4. zygote进行一次fork指令，克隆自己来创造一个新进程，下放权限并配置新进程的UID和沙箱，初始化该进程的Dalvik，使得Java runtime开始完全执行。例如，它需要在fork后启动垃圾收集等线程。
 5. 新进程如今是一个zygote的克隆，并运行着完全配置好的Java环境。它回调活动管理器，询问后者“我该做什么”。
 6. 活动管理器返回即将启动的应用程序的完整信息，如源码位置等。
 7. 新进程读取应用程序的源码，开始运行。
@@ -421,23 +421,6 @@ Android使用的进程有些不同。活动管理器是Android负责正在运行
 
 
 
-
-
-### 进程生命周期
-
-活动管理器也负责判断何时进程不再被需要。活动管理器记录一个进程中运行的所有活动、接收器、服务以及内容提供其，据此可判断该进程的重要程度。
-
-Android内核中的内存溢出强制结束指令是使用一个进程的oom_adj进行严格排序，决定哪个进程需要优先强制结束。活动管理器负责基于每个进程的状态，通过将其归类于几个主要用途，从而合理设定器oom_adj。/proc/<pid>/oom_adj:   
-
-- 取值是-17到+15，取值越高，越容易被干掉。如果是-17，则表示不能被kill
-- 该设置参数的存在是为了和旧版本的内核兼容
-
-![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_process_adj.png?raw=true)
-
-让RAM内存不足时，系统已经完成了进程的配置，使得内存溢出强制结束命令优先中止缓存(cache)类型的进程，尝试重新取得足够的所需内存，随后中止界面(home)类别、服务(service)类别，以此类推。在同一个oom_adj水平中，它将优先中止内存占用较大的进程。
-
-
-
 ### Android系统启动的核心流程如下：
 
 
@@ -452,9 +435,9 @@ Android内核中的内存溢出强制结束指令是使用一个进程的oom_adj
 3. Linux内核启动：当内核启动时，设置缓存、被保护存储器、计划列表、加载驱动。当其完成系统设置时，会先在系统文件中寻找init.rc文件，并启动init进程。
 4. init进程启动：初始化和启动属性服务，init进程会孵化出eadbd、logd、等用户守护进程，还会启动ServiceManager(binder服务管家)、botanic(开机动画)等服务，并且启动Zygote进程。
 5. Zygote进程启动：zygote进程是Android系统的第一个Java进程（即虚拟机进程），它是所有Java进程的父进程。它会创建JVM并为其注册JNI方法，创建服务器端Socket，启动SystemServer进程。并且，zygote进程在启动的时候会创建DVM或者ART。因此通过从zygote进程fork创建的应用程序进程和systemserver进程都可以在内部获取一个DVM或者ART的实例副本。它还会提前加载类preloadClasses和提前加载资源preloadResouces。
-6. SystemServer进程启动：System Server是zygote孵化的第一个进程，它会启动Binder线程池和SystemServiceManager，并且启动各种系统服务，包括ActivityManager、WindowManager、PackageManager、PowerManager等服务。
+6. SystemServer进程启动：System Server是zygote孵化的第一个进程，它会启动Binder线程池和SystemServiceManager，并且启动各种系统服务，包括ActivityManagerService、WindowManagerService、PackageManagerService、PowerManagerService等服务。
 7. Media Server进程，是由init进程fork而来，负责启动和管理整个C++ framework，包括AudioFlinger，Camera Service等服务。
-8. Launcher启动：是zygote孵化的第一个App进程，被SystemServer进程启动的AMS会启动Launcher，Launcher启动后会将已安装应用的快捷图标显示到系统桌面上。zygote还会创建Broweer、Phone、Email等App进程，每个App至少运行在一个进程上。
+8. Launcher启动：是zygote孵化的第一个App进程，被SystemServer进程启动的AmS会启动Launcher，Launcher启动后会将已安装应用的快捷图标显示到系统桌面上。zygote还会创建Broweer、Phone、Email等App进程，每个App至少运行在一个进程上。
 
 
 
@@ -494,9 +477,13 @@ Android内核中的内存溢出强制结束指令是使用一个进程的oom_adj
 
 
 
+---
+
+
+
 - [上一篇:1.操作系统简介](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/1.%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E7%AE%80%E4%BB%8B.md)
 
-- [下一篇:2.进程与线程](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/2.%E8%BF%9B%E7%A8%8B%E4%B8%8E%E7%BA%BF%E7%A8%8B.md)
+- [下一篇:3.内存管理](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/3.%E5%86%85%E5%AD%98%E7%AE%A1%E7%90%86.md)
 
 
 ---
diff --git "a/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md" "b/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
index 2490734b..fa5e3048 100644
--- "a/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
+++ "b/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
@@ -19,7 +19,7 @@
 
 
 
-进程对应的内存空间中所包含的5种不同的数据区：  
+进程对应的内存空间中所包含的6种不同的数据区：  
 
 - 代码段(code segment):用来存放程序运行代码的一块内存空间。此空间大小在代码运行前就已经确定。内存空间一般属于只读，某些架构的代码也允许可写。
 
@@ -28,7 +28,7 @@
 - BSS段(bss segment)：存储未初始化的全局变量和未初始化的static变量。bss段中数据的生存期随进程持续性。bss段中的数据一般默认为0.这里很奇怪，一般的书上都会说全局变量和静态变量是会自动初始化的，怎么突然来了个未初始化的变量？其实变量的初始化可以分为显式初始化和隐式初始化，全局变量和静态变量如果程序员自己不初始化的话也会被初始化，那就是不管什么类型都初始化为默认值，这种没有显示初始化的就是这里所说的未初始化。例如整数型的全局变量未初始化的默认隐式初始化的值为0，都是0就没必要把每个0都存储起来，从而节省磁盘空间，这是BSS的主要作用）。BSS的全称是Block Started by Symbol，它属于静态内存分配。BSS节不包含任何数据，只是简单的维护开始和结束的地址，即总大小，以便内存能在运行时分配并被有效的清零。BSS节在应用程序的二进制映像文件中并不存在，既不占用磁盘空间，而只在运行的时候占用内存空间，所以如果全局变量和静态变量未初始化那么其可执行文件要小很多。
 - rodata段(read only data):常量区，存放只读数据。比如程序中定义为const的全局变量，“Hello Word”的字符串常量。有些系统中rodata段是多个进程共享的，目的是为了提高空间利用率。在有的嵌入式系统中，rodata放在ROM中，运行时直接读取，不须加载到RAM内存中。所以在嵌入式开发中，常将已知的常量系数，表格数据等加以const关键字。存放在ROM中，避免占用RAM空间。
 
-- 堆（heap）：堆是用于存放进程运行中被动态分配的内存段，它的大小并不固定，可动态扩张或缩减。当进程调用malloc、realloc等函数分配内存时，新分配的内存就被动态添加到堆上（堆被扩张）；当利用free等函数释放内存时，被释放的内存从堆中被剔除（堆被缩减）
+- 堆(heap)：堆是用于存放进程运行中被动态分配的内存段，它的大小并不固定，可动态扩张或缩减。当进程调用malloc、realloc等函数分配内存时，新分配的内存就被动态添加到堆上（堆被扩张）；当利用free等函数释放内存时，被释放的内存从堆中被剔除（堆被缩减）
 
 - 栈(stack):栈是用户存放程序临时创建的局部变量，也就是说我们函数括弧“{}”中定义的变量（但不包括static声明的变量，static意味着在数据段中存放变量）。栈的生存期随代码块持续性，代码块运行就给你分配空间，代码块结束就自动回收空间。除此以外，在函数被调用时，其参数也会被压入发起调用的进程栈中，并且待到调用结束后，函数的返回值也会被存放回栈中。由于栈的先进先出特点，所以栈特别方便用来保存/恢复调用现场。从这个意义上讲，我们可以把堆栈看成一个寄存、交换临时数据的内存区。
 
@@ -38,11 +38,11 @@
 
 ## 内存的演变
 
-在早些的操作系统中，并没有引入内存抽象的概念。程序直接访问和操作的都是物理内存，内存的管理也非常简单，除去操作系统所用的内存之外，全部给用户程序使用，想怎么折腾都行，只要别超出最大的容量。这种内存操作方式使得操作系统中存在多进程变得完全不可能，比如MS-DOS，你必须执行完一条指令后才能接着执行下一条。如果是多进程的话，由于直接操作物理内存地址，当一个进程给内存地址1000赋值后，另一个进程也同样给内存地址赋值，那么第二个进程对内存的赋值会覆盖第一个进程所赋的值，这回造成两条进程同时崩溃。随着计算机技术发展，要求操作系统支持多进程的需求，所谓多进程，并不需要同时运行这些进程，只要它们都处于 ready  状态，操作系统快速地在它们之间切换，就能达到同时运行的假象。每个进程都需要内存，Context Switch  时，之前内存里的内容怎么办？简单粗暴的方式就是先 dump 到磁盘上，然后再从磁盘上 restore 之前 dump  的内容（如果有的话），但效果并不好，太慢了！那怎么才能不慢呢？把进程对应的内存依旧留在物理内存中，需要的时候就切换到特定的区域。这就涉及到了内存的保护机制，毕竟进程之间可以随意读取、写入内容就乱套了，非常不安全。因此操作系统需要对物理内存做一层抽象，也就是「地址空间」(Address Space)，一个进程的地址空间包含了该进程所有相关内存，比如 code / stack / heap。一个 16 KB  的地址空间可能长这样：
+在早些的操作系统中，并没有引入内存抽象的概念。程序直接访问和操作的都是物理内存，内存的管理也非常简单，除去操作系统所用的内存之外，全部给用户程序使用，想怎么折腾都行，只要别超出最大的容量。这种内存操作方式使得操作系统中存在多进程变得完全不可能，比如MS-DOS，你必须执行完一条指令后才能接着执行下一条。如果是多进程的话，由于直接操作物理内存地址，当一个进程给内存地址1000赋值后，另一个进程也同样给内存地址赋值，那么第二个进程对内存的赋值会覆盖第一个进程所赋的值，这回造成两条进程同时崩溃。随着计算机技术发展，要求操作系统支持多进程的需求，所谓多进程，并不需要同时运行这些进程，只要它们都处于ready 状态，操作系统快速地在它们之间切换，就能达到同时运行的假象。每个进程都需要内存，Context Switch时，之前内存里的内容怎么办？简单粗暴的方式就是先dump到磁盘上，然后再从磁盘上restore之前dump的内容（如果有的话），但效果并不好，太慢了！那怎么才能不慢呢？把进程对应的内存依旧留在物理内存中，需要的时候就切换到特定的区域。这就涉及到了内存的保护机制，毕竟进程之间可以随意读取、写入内容就乱套了，非常不安全。因此操作系统需要对物理内存做一层抽象，也就是「地址空间」(Address Space)，一个进程的地址空间包含了该进程所有相关内存，比如code/stack/heap。一个16KB的地址空间可能长这样：
 
 ![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/memory_1.jpg?raw=true)
 
-Stack 和 Heap 中间有一块 free space，即使没有用，也被占着，那如何才能解放这块区域呢，那就是虚拟内存。
+Stack和Heap中间有一块free space，即使没有用，也被占着，那如何才能解放这块区域呢，那就是虚拟内存。
 
 Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自互不干涉的进程地址空间。该空间是块大小为4G的线性虚拟空间，用户所看到和接触到的都是该虚拟地址，无法看到实际的物理内存地址。利用这种虚拟地址不但能起到保护操作系统的效果（用户不能直接访问物理内存），而且更重要的是，用户程序可使用比实际物理内存更大的地址空间。
 
@@ -138,7 +138,7 @@ Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自
 
 分页和分段的两个特点: 
 
-- 进程中的所有内存访问的都是逻辑地址，这些逻辑地址会在运行时动态地址转换为物理地址。这意味着一个进程可被换入或换出内存，因此进程可在执行过程中的不同时刻占据内存中的不同区域。
+- 进程中的所有内存访问的都是逻辑地址，这些逻辑地址会在运行时把动态地址转换为物理地址。这意味着一个进程可被换入或换出内存，因此进程可在执行过程中的不同时刻占据内存中的不同区域。
 - 一个进程可划分为许多块（页和段），在执行过程中，这些块不需要连续的位于内存中。动态运行时地址转换和页表或段表的使用使得这一点成为可能。
 
 由于上面这两个特点的存在，那么在一个进程的执行过程中，该进程不需要所有页或段都在内存中。如果内存中保存有待取的下一条指令所在块（段或页）及待访问的下一个数据单元所在块，那么执行至少可以暂时继续下去。我们用术语“块”来表示页或段。处理器在需要访问一个不在内存中的逻辑地址时，会产生一个中断，这表明出现了内存访问故障。操作系统会把被中断的进程置于堵塞态。要继续执行这个进程，操作系统必须把包含引发访问故障的逻辑地址的进程块读入内存。为此操作系统产生一个磁盘I/O读请求。产生I/O请求后，在执行磁盘I/O期间，操作系统可以调度另一个进程运行。在需要的块读入内存后，产生一个I/O中断，控制权交回给操作系统，而操作系统则把由于缺少该块而被堵塞的进程置为就绪态。这样的话就会有两种提高系统利用率的方法: 
@@ -162,14 +162,14 @@ Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自
 
 要有效的使用处理器和I/O设备，就需要在内存中保留尽可能多的进程。此外，还需要解除程序在开发时对程序使用内存大小的限制。解决这两个问题的途径就是虚拟内存技术。采用虚拟内存技术时，所有的地址访问都是逻辑访问，并在运行时转换为实地址。
 
-虚拟内存机制使得期望运行大于物理内存的程序称为可能。其方法是将程序放在磁盘上，而将主存作为一种缓存，用来保存最频繁使用的部分程序。这种机制需要快速的映像内存地址，以便把程序生成的地址转换为有关字节在RAM中的物理地址。这种映像由CPU中的一个称为存储器管理单元（Memory Management Unit，MMU）的部件来完成。
+虚拟内存机制使得期望运行大于物理内存的程序成为可能。其方法是将程序放在磁盘上，而将主存作为一种缓存，用来保存最频繁使用的部分程序。这种机制需要快速的映像内存地址，以便把程序生成的地址转换为有关字节在RAM中的物理地址。这种映像由CPU中的一个称为存储器管理单元（Memory Management Unit，MMU）的部件来完成。
 
 **虚拟内存**的**基本思想**是:每个程序都拥有自己的地址空间,这个空间被分割成多个块,每个块被成为一页或页面.
 
 **程序运行时,并不是所有页都在物理内存中**:
 
 - 当程序引用一部分在物理内存的地址空间时,由硬件直接执行必要的映射;
-- 当程序引用一部分不在物理内存的地址空间时,有操作系统将缺失的页装入物理内存,并重新运行
+- 当程序引用一部分不在物理内存的地址空间时,由操作系统将缺失的页装入物理内存,并重新运行
 
 虚拟内存基于分段和分页这两种基本技术或基于这两种技术中的一种。虚拟内存机制允许程序以逻辑方式访问存储器，而不考虑物理内存上可用的空间数量。虚存的构想是为了满足有多个用户作业同时驻留在内存中的要求，因此在一个进程被写出到副主存储器中且后续进程被读入时，连续的进程执行之间将不会脱节。进程大小不同时，若处理器在很多进程间切换，则很难把它们紧密的压入内存，因此人们引入了分页系统。在分页系统中，进程由许多固定大小的块组成。这些块成为页。程序通过虚地址(virtual address)访问，虚地址由页号和页中的偏移量组成。进程的每页都可置于内存中的任何地方，分页系统提供了程序中使用的虚地址和内存中的实地址(real address)或物理地址之间的动态映射。
 
@@ -179,9 +179,9 @@ Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自
 
 1. CPU中包含**MMU内存管理单元**,用于管理虚拟地址空间到物理内存地址的映射.
 2. 假设物理内存地址大小为32k,每4k为一个页框.虚拟地址空间分页,每个页面大小等于一个页框
-3. 当程序想要访问一个虚拟地址x,
-4. 指令将x送到MMU,
-5. MMU根据x的虚拟地址,判断其对应的页面是否在物理内存中:
+3. 当程序想要访问一个虚拟地址x
+4. 指令将x送到MMU
+5. MMU根据x的虚拟地址,判断其对应的页面是否在物理内存中
 6. 若在,MMU将x转化为物理内存地址y
 7. 若不在,则进行缺页中断,操作系统在物理内存中找到一个使用较少的页面回收掉,将需要访问的页面读到被回收的页面处,再将x转化为物理内存地址访问
 
@@ -197,7 +197,7 @@ Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自
 
 - 请求分页
 
-    只有当访问到某页中的一个单元时才将改页取入内存。若内存管理的其他策略比较合适，将发生下述情况：当一个进程首次启动时，会在一段时间出现大量的缺页中断，取入越来越多的页后，局部性原理表明大多数将来访问的页都是最近去读的页。因此在一段时间后错误会逐渐减少，缺页中断的数量会降低到很低。
+    只有当访问到某页中的一个单元时才将该页取入内存。若内存管理的其他策略比较合适，将发生下述情况：当一个进程首次启动时，会在一段时间出现大量的缺页中断，取入越来越多的页后，局部性原理表明大多数将来访问的页都是最近去读的页。因此在一段时间后错误会逐渐减少，缺页中断的数量会降低到很低。
 
 - 预先分页
 
@@ -233,7 +233,7 @@ Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自
 
 #### 6.加载控制
 
-加载控制会影响到驻留内存中的进程数量，这称为系统并发度。加载控制策略在有效的内存管理中非常重要。如果某一时刻驻留的进程太少，那么所有进程都处于堵塞态的概率就较大，因为会有许多时间话费在交换上。另一方面，如果驻留的进程太多，平均每个进程的驻留集大小将会不够用，此时会频繁发生缺页中断，从而导致系统抖动。
+加载控制会影响到驻留内存中的进程数量，这称为系统并发度。加载控制策略在有效的内存管理中非常重要。如果某一时刻驻留的进程太少，那么所有进程都处于堵塞态的概率就较大，因为会有许多时间花费在交换上。另一方面，如果驻留的进程太多，平均每个进程的驻留集大小将会不够用，此时会频繁发生缺页中断，从而导致系统抖动。
 
 
 
@@ -244,14 +244,21 @@ Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自
 Android包含了标准Linux内核中内存管理设施的许多扩展，具体如下: 
 
 - ASHMem：这个功能提供匿名共享内存，它将内存抽象为文件描述符。文件描述符可以传递给另一个进程以共享内存。
+
 - Pmen：这个功能分配虚拟内存，使的它在物理上是连续的，因此对于那些不支持虚拟内存的设备非常实用。
-- Low Memory Killer：andorid基于oomKiller原理所扩展的一个多层次oomKiller。在Android中运行了一个OOM进程，该进程启动时会首先向Linux内核中把自己注册为一个OOM Killer，即当Linux内核的内存管理模块检测到系统内存低的时候会通知已经注册的OOM进程，然后这些OOMkille会选择性杀掉进程，到oom的时候，系统可能已经不太稳定，而LowMemoryKiller是一种根据内存阈值级别触发的内存回收的机制，在系统可用内存较低时，就会选择性杀死进程的策略，相对OOMKiller，更加灵活。主存耗尽时，使用大量内存的应用不是让步对内存的使用就是被终结。这个功能可让系统通知应用释放内存，如果应用不配合，则终结应用。
 
+- Low Memory Killer：andorid基于OOM Killer原理所扩展的一个多层次OOM Killer。在Android中运行了一个OOM进程，该进程启动时会首先向Linux内核中把自己注册为一个OOM Killer，即当Linux内核的内存管理模块检测到系统内存低的时候会通知已经注册的OOM进程，然后这些OOM kille会选择性杀掉进程，到OOM的时候，系统可能已经不太稳定，而LowMemoryKiller是一种根据内存阈值级别触发的内存回收的机制，在系统可用内存较低时，就会选择性杀死进程的策略，相对OOM Killer，更加灵活。主存耗尽时，使用大量内存的应用不是让步对内存的使用就是被终结。这个功能可让系统通知应用释放内存，如果应用不配合，则终结应用。这些都是由活动管理器来负责判断何时进程不再被需要。活动管理器记录一个进程中运行的所有活动、接收器、服务以及内容提供者，据此可判断该进程的重要程度。
+
+    Android内核中的内存溢出强制结束指令是使用一个进程的oom_adj进行严格排序，决定哪个进程需要优先强制结束。活动管理器负责基于每个进程的状态，通过将其归类于几个主要用途，从而合理设定其oom_adj。/proc/<pid>/oom_adj:   
 
+    - 取值是-17到+15，取值越高，越容易被干掉。如果是-17，则表示不能被kill
+    - 该设置参数的存在是为了和旧版本的内核兼容
 
-Android的底层Linux未采用磁盘虚拟内存机制，程序只能使用屋里内存作为最大内存，所以AmS中采用了自动杀死优先级较低进程的方法以达到释放内存的目的。
+    ![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_process_adj.png?raw=true)
 
+    让RAM内存不足时，系统已经完成了进程的配置，使得内存溢出强制结束命令优先中止缓存(cache)类型的进程，尝试重新取得足够的所需内存，随后中止界面(home)类别、服务(service)类别，以此类推。在同一个oom_adj水平中，它将优先中止内存占用较大的进程。
 
+    Android的底层Linux未采用磁盘虚拟内存机制，程序只能使用屋里内存作为最大内存，所以AmS中采用了自动杀死优先级较低进程的方法以达到释放内存的目的。
 
 
 
@@ -261,6 +268,8 @@ Android的底层Linux未采用磁盘虚拟内存机制，程序只能使用屋
 
 
 
+---
+
 
 
 - [上一篇:2.进程和线程](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/2.%E8%BF%9B%E7%A8%8B%E4%B8%8E%E7%BA%BF%E7%A8%8B.md)
diff --git "a/OperatingSystem/4.\350\260\203\345\272\246.md" "b/OperatingSystem/4.\350\260\203\345\272\246.md"
index 568d6cf7..97635ae5 100644
--- "a/OperatingSystem/4.\350\260\203\345\272\246.md"
+++ "b/OperatingSystem/4.\350\260\203\345\272\246.md"
@@ -2,7 +2,7 @@
 
 
 
-在多道程序设计系统中，内存中有多个进程，每个进程要么正在处理器上运行，要么正在等待某些事件的发生，比如I/O完成。处理器调度的目的是：以满足系统目标（如响应时间、吞吐率、处理器效率）的方式，把进程分配到一个或多个处理器上执行。处理器（或处理器组）通过执行某个进程而保持忙状态，而此时其他进程处理堵塞状态。典型的调度有四种： 
+在多道程序设计系统中，内存中有多个进程，每个进程要么正在处理器上运行，要么正在等待某些事件的发生，比如I/O完成。处理器调度的目的是：以满足系统目标（如响应时间、吞吐率、处理器效率）的方式，把进程分配到一个或多个处理器上执行。处理器（或处理器组）通过执行某个进程而保持忙状态，而此时其他进程处于堵塞状态。典型的调度有四种： 
 
 ### 长程调度
 
@@ -41,13 +41,13 @@
 
 多处理器系统分为以下几类: 
 
-- 松耦合、分布式多处理器、集群：又一系列相对自治的系统组成，每个处理器都有自身的内存和I/O通道。
+- 松耦合、分布式多处理器、集群：由一系列相对自治的系统组成，每个处理器都有自身的内存和I/O通道。
 - 专用处理器：I/O处理器是一个典型的例子。此时，有一个通用的主处理器，专用处理器由主处理器控制，并为主处理器提供服务。
 - 紧耦合多处理器：由一些列共享同一个内存并受操作系统完全控制的处理器组成。
 
 
 
-多处理器中的调度设计三个相互关联的问题： 
+多处理器中的调度涉及三个相互关联的问题： 
 
 - 把进程分配到处理器
 
@@ -71,17 +71,19 @@
 
 在多处理器线程调度和处理器分配的各种方案中，有四个比较突出的方法：
 
-- 负载分配：进程不分配到某个特定的从处理器。系统维护一个就绪线程的全局队列，每个处理器只要空闲就从队列中选择一个线程。
+- 负载分配：进程不分配到某个特定的处理器。系统维护一个就绪线程的全局队列，每个处理器只要空闲就从队列中选择一个线程。
 - 组调度：一组相关的的线程基于一对一的原则，同时调度到一组处理器上运行。
 - 专用处理器分配：这种方法与负载分配方法正好相反，它通过把线程指定到处理器来定义隐式的调度。每个程序在其执行过程中，都分配给一组处理器，处理器的数量与程序中线程的数量相等。程序终止时，处理器返回总处理器池，以便分配给另一个程序。
 - 动态调度：在执行期间，进程中线程的数据可以改变，允许动态地改变进程中的线程数量，这就使得操作系统可以通过调整负载情况来提高利用率。
 
 
 
+---
+
 
 
 - [上一篇:3.内存管理](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/3.%E5%86%85%E5%AD%98%E7%AE%A1%E7%90%86.md)
-- [下一篇：5.I/O](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/5.I:O.md)
+- [下一篇:5.I/O](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/5.I:O.md)
 
 
 ---
diff --git a/OperatingSystem/5.I:O.md b/OperatingSystem/5.I:O.md
index 29367863..35535833 100644
--- a/OperatingSystem/5.I:O.md
+++ b/OperatingSystem/5.I:O.md
@@ -18,7 +18,7 @@
 
     DMA技术工作流程如下： 
 
-    如果处理器想读或写一块数据时，它通过想DMA模块发送以下信息来给DMA模块发出一条命令: 
+    如果处理器想读或写一块数据时，它通过向DMA模块发送以下信息来给DMA模块发出一条命令: 
 
     - 请求读操作或写操作的信号，通过在处理器和DMA模块之间使用读写控制线发送。
     - 相关I/O设备地址，通过数据线发送。
@@ -33,7 +33,7 @@
 
 
 
-高速缓冲存储器（cache memory）通常指比内存小且比内存块的存储器，它位于内存和处理器之间。这种高速缓冲存储器利用局部性原理来减少平均存储器的存取时间。同样的原理也适用于磁盘存储器。磁盘高速缓存是内存中为磁盘扇区设置的一个缓冲区，它包含有磁盘中某些扇区的副本。出现对某一特定扇区的I/O请求时，首先会进行检测，以确定该扇区是否在磁盘的告诉缓存中。若在则该请求可通过这个告诉缓存来满足。若不在，则把被请求的扇区从磁盘读到磁盘高速缓存中。
+高速缓冲存储器（cache memory）通常指比内存小且比内存块的存储器，它位于内存和处理器之间。这种高速缓冲存储器利用局部性原理来减少平均存储器的存取时间。同样的原理也适用于磁盘存储器。磁盘高速缓存是内存中为磁盘扇区设置的一个缓冲区，它包含有磁盘中某些扇区的副本。出现对某一特定扇区的I/O请求时，首先会进行检测，以确定该扇区是否在磁盘的高速缓存中。若在则该请求可通过这个高速缓存来满足。若不在，则把被请求的扇区从磁盘读到磁盘高速缓存中。
 
 
 
@@ -46,6 +46,10 @@
 
 
 
+---
+
+
+
 - [上一篇:4.调度](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/4.%E8%B0%83%E5%BA%A6.md)
 - [下一篇:6.文件管理](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/6.%E6%96%87%E4%BB%B6%E7%AE%A1%E7%90%86.md)
 
diff --git "a/OperatingSystem/6.\346\226\207\344\273\266\347\256\241\347\220\206.md" "b/OperatingSystem/6.\346\226\207\344\273\266\347\256\241\347\220\206.md"
index 3621dd4d..4940fb5d 100644
--- "a/OperatingSystem/6.\346\226\207\344\273\266\347\256\241\347\220\206.md"
+++ "b/OperatingSystem/6.\346\226\207\344\273\266\347\256\241\347\220\206.md"
@@ -54,6 +54,8 @@ Android文件系统目录的顶层部分：
 
 
 
+---
+
 
 
 - [上一篇:5.I/O](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/5.I:O.md)
diff --git "a/OperatingSystem/7.\345\265\214\345\205\245\345\274\217\347\263\273\347\273\237.md" "b/OperatingSystem/7.\345\265\214\345\205\245\345\274\217\347\263\273\347\273\237.md"
index e37630e3..ac818dfb 100644
--- "a/OperatingSystem/7.\345\265\214\345\205\245\345\274\217\347\263\273\347\273\237.md"
+++ "b/OperatingSystem/7.\345\265\214\345\205\245\345\274\217\347\263\273\347\273\237.md"
@@ -18,7 +18,7 @@ Android是基于Linux内核的一个嵌入式系统，因此我们可以认为An
 
 
 
-
+---
 
 - [上一篇:6.文件管理](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/6.%E6%96%87%E4%BB%B6%E7%AE%A1%E7%90%86.md)
 - [下一篇:8.虚拟机](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/8.%E8%99%9A%E6%8B%9F%E6%9C%BA.md)
diff --git "a/OperatingSystem/8.\350\231\232\346\213\237\346\234\272.md" "b/OperatingSystem/8.\350\231\232\346\213\237\346\234\272.md"
index 47f61216..ea7fd949 100644
--- "a/OperatingSystem/8.\350\231\232\346\213\237\346\234\272.md"
+++ "b/OperatingSystem/8.\350\231\232\346\213\237\346\234\272.md"
@@ -16,7 +16,7 @@
 
 尽管Java虚拟机（JVM）用“虚拟机”作为其名称的一部分，但其实现和用途与我们前面所讲的模型不同。虚拟机管理程序支持在主机上运行一个或多个虚拟机。这些虚拟机独立的处理工作负载，支持操作系统和应用，且在它们自身看来，访问一系列提供计算、存储和输入/输出的资源。Java虚拟机的目的是，无须更改任何Java代码就可在任意硬件平台的任意操作系统上，提供运行时空间。两种模型的目的都是通过使用某种程度的抽象化来实现平台无关性。       
 
-JVM可描述为一个抽象的计算设备，它包含指令集、一个PC（程序计数器）寄存器、一个用来保存变量和结果的栈、一个保存运行时数据和垃圾手机的堆、一个存储代码和常量的方法区。 
+JVM可描述为一个抽象的计算设备，它包含指令集、一个PC（程序计数器）寄存器、一个用来保存变量和结果的栈、一个保存运行时数据和垃圾收集的堆、一个存储代码和常量的方法区。 
 
 JVM支持多个线程，每个线程都有自己的寄存器和堆栈区，且所有线程共享栈和方法区。
 
@@ -81,9 +81,10 @@ DVM运行Java语言的应用和代码。标准的Java编译器将源代码（写
 
     以上命令首先将jar包push到/data/app目录下，因为该目录一般用于存放应用程序，接着使用adb shell执行dalvikvm程序。dalvikvm的执行语法是: dalvikvm -cp 类路径 类名，从这里可以感觉到，dalvikvm的作用就像在pc上执行java程序一样。
 
-
+---
 
 - [上一篇:7.嵌入式系统](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/7.%E5%B5%8C%E5%85%A5%E5%BC%8F%E7%B3%BB%E7%BB%9F.md)
+- [下一篇:Android内核](https://github.com/CharonChui/AndroidNote/tree/master/OperatingSystem/AndroidKernal)
 
 
 ---
diff --git "a/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md" "b/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md"
index 0a6b51a4..68b17d24 100644
--- "a/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md"
+++ "b/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md"
@@ -11,9 +11,9 @@ Binder，英文的意思是别针、回形针。我们经常用别针把两张
 无论是Android系统，还是各种Linux衍生系统，各个组件、模块往往运行在各种不同的进程和线程内，这里就必然涉及进程/线程之间的通信。对于IPC(Inter-Process Communication,  进程间通信)，Linux目前有一下这些IPC机制: 
 
 -  管道：在创建时分配一个page大小的内存，缓存区大小比较有限；
-- 消息队列：信息复制两次，额外的CPU消耗；不合适频繁或信息量大的通信；
-- 共享内存：无须复制，共享缓冲区直接付附加到进程虚拟地址空间，速度快；但进程间的同步问题操作系统无法实现，必须各进程利用同步工具解决；
-- 套接字：作为更通用的接口，传输效率低，主要用于不通机器或跨网络的通信；
+- 消息队列：信息会复制两次，会有额外的CPU消耗；不合适频繁或信息量大的通信；
+- 共享内存：无须复制，共享缓冲区直接附加到进程虚拟地址空间，速度快；但进程间的同步问题操作系统无法实现，必须各进程利用同步工具解决；
+- 套接字：作为更通用的接口，传输效率低，主要用于不同机器或跨网络的通信；
 - 信号量：常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。
 - 信号: 不适用于信息交换，更适用于进程中断控制，比如非法内存访问，杀死某个进程等；
 
@@ -44,7 +44,7 @@ Binder作为Android系统提供的一种IPC机制。首先一个问题就是为
 
 **接下来正面回答这个问题，从5个角度来展开对Binder的分析：**
 
-**（1）从性能的角度** **数据拷贝次数：**Binder数据拷贝只需要一次，而管道、消息队列、Socket都需要2次，但共享内存方式一次内存拷贝都不需要；从性能角度看，Binder性能仅次于共享内存。
+**（1）从性能的角度** ：数据拷贝次数，Binder数据拷贝只需要一次，而管道、消息队列、Socket都需要2次，但共享内存方式一次内存拷贝都不需要；从性能角度看，Binder性能仅次于共享内存。
 
 **（2）从稳定性的角度**
 Binder是基于C/S架构的，简单解释下C/S架构，是指客户端(Client)和服务端(Server)组成的架构，Client端有什么需求，直接发送给Server端去完成，架构清晰明朗，Server端与Client端相对独立，稳定性较好；而共享内存实现方式复杂，没有客户与服务端之别， 需要充分考虑到访问临界资源的并发同步问题，否则可能会出现死锁等问题；从这稳定性角度看，Binder架构优越于共享内存。
@@ -52,18 +52,14 @@ Binder是基于C/S架构的，简单解释下C/S架构，是指客户端(Client)
 仅仅从以上两点，各有优劣，还不足以支撑google去采用binder的IPC机制，那么更重要的原因是：
 
 **（3）从安全的角度**
-传统Linux IPC的接收方无法获得对方进程可靠的UID/PID，从而无法鉴别对方身份；而Android作为一个开放的开源体系，拥有非常多的开发平台，App来源甚广，因此手机的安全显得额外重要；对于普通用户，绝不希望从App商店下载偷窥隐射数据、后台造成手机耗电等等问题，传统Linux IPC无任何保护措施，完全由上层协议来确保。 
+传统Linux IPC的接收方无法获得对方进程可靠的UID/PID，从而无法鉴别对方身份；而Android作为一个开放的开源体系，拥有非常多的开发平台，App来源甚广，因此手机的安全显得额外重要；对于普通用户，绝不希望从App商店下载偷窥隐私数据、后台造成手机耗电等等问题，传统Linux IPC无任何保护措施，完全由上层协议来确保。 
 
 Android为每个安装好的应用程序分配了自己的UID，故进程的UID是鉴别进程身份的重要标志，前面提到C/S架构，**Android系统中对外只暴露Client端，Client端将任务发送给Server端，Server端会根据权限控制策略，判断UID/PID是否满足访问权限，目前权限控制很多时候是通过弹出权限询问对话框，让用户选择是否运行**。Android 6.0，也称为Android M，在6.0之前的系统是在App第一次安装时，会将整个App所涉及的所有权限一次询问，只要留意看会发现很多App根本用不上通信录和短信，但在这一次性权限权限时会包含进去，让用户拒绝不得，因为拒绝后App无法正常使用，而一旦授权后，应用便可以胡作非为。
 
-针对这个问题，google在Android M做了调整，不再是安装时一并询问所有权限，而是在App运行过程中，需要哪个权限再弹框询问用户是否给相应的权限，对权限做了更细地控制，让用户有了更多的可控性，但**同时也带来了另一个用户诟病的地方，那也就是权限询问的弹框的次数大幅度增多。**对于Android M平台上，有些App开发者可能会写出让手机异常频繁弹框的App，企图直到用户授权为止，这对用户来说是不能忍的，用户最后吐槽的可不光是App，还有Android系统以及手机厂商，有些用户可能就跳果粉了，这还需要广大Android开发者以及手机厂商共同努力，共同打造安全与体验俱佳的Android手机。
+针对这个问题，google在Android M做了调整，不再是安装时一并询问所有权限，而是在App运行过程中，需要哪个权限再弹框询问用户是否给相应的权限，对权限做了更细地控制，让用户有了更多的可控性，但同时也带来了另一个用户诟病的地方，那也就是权限询问的弹框的次数大幅度增多。对于Android M平台上，有些App开发者可能会写出让手机异常频繁弹框的App，企图直到用户授权为止，这对用户来说是不能忍的，用户最后吐槽的可不光是App，还有Android系统以及手机厂商，有些用户可能就跳果粉了，这还需要广大Android开发者以及手机厂商共同努力，共同打造安全与体验俱佳的Android手机。
 
 Android中权限控制策略有SELinux等多方面手段。传统IPC只能由用户在数据包里填入UID/PID；另外，可靠的身份标记只有由IPC机制本身在内核中添加。其次传统IPC访问接入点是开放的，无法建立私有通道。从安全角度，Binder的安全性更高。
 
-**说到这，可能有人要反驳**，Android就算用了Binder架构，而现如今Android手机的各种流氓软件，不就是干着这种偷窥隐射，后台偷偷跑流量的事吗？没错，确实存在，但这不能说Binder的安全性不好，因为Android系统仍然是掌握主控权，可以控制这类App的流氓行为，只是对于该采用何种策略来控制，在这方面android的确存在很多有待进步的空间，这也是google以及各大手机厂商一直努力改善的地方之一。在Android 6.0，google对于app的权限问题作为较多的努力，大大收紧的应用权限；另外，在**Google举办的Android Bootcamp 2016**大会中，google也表示在Android 7.0 （也叫Android N）的权限隐私方面会进一步加强加固，比如SELinux，Memory safe language(还在research中)等等，在今年的5月18日至5月20日，google将推出Android N。 
-
-话题扯远了，继续说Binder。
-
 **（4）从语言层面的角度**
 大家多知道Linux是基于C语言(面向过程的语言)，而Android是基于Java语言(面向对象的语句)，而对于Binder恰恰也符合面向对象的思想，将进程间通信转化为通过对某个Binder对象的引用调用该对象的方法，而其独特之处在于Binder对象是一个可以跨进程引用的对象，它的实体位于一个进程中，而它的引用却遍布于系统的各个进程之中。可以从一个进程传给其它进程，让大家都能访问同一Server，就像将一个对象或引用赋值给另一个引用一样。Binder模糊了进程边界，淡化了进程间通信过程，整个系统仿佛运行于同一个面向对象的程序之中。从语言层面，Binder更适合基于面向对象语言的Android系统，对于Linux系统可能会有点“水土不服”。
 
@@ -73,11 +69,11 @@ Android中权限控制策略有SELinux等多方面手段。传统IPC只能由用
 
 总所周知，Linux内核是开源的系统，所开放源代码许可协议GPL保护，该协议具有“病毒式感染”的能力，怎么理解这句话呢？受GPL保护的Linux Kernel是运行在内核空间，对于上层的任何类库、服务、应用等运行在用户空间，一旦进行SysCall（系统调用），调用到底层Kernel，那么也必须遵循GPL协议。 
 
-而Android 之父 Andy Rubin对于GPL显然是不能接受的，为此，Google巧妙地将GPL协议控制在内核空间，将用户空间的协议采用Apache-2.0协议（允许基于Android的开发商不向社区反馈源码），同时在GPL协议与Apache-2.0之间的Lib库中采用BSD证授权方法，有效隔断了GPL的传染性，仍有较大争议，但至少目前缓解Android，让GPL止步于内核空间，这是Google在GPL Linux下 开源与商业化共存的一个成功典范。
+而Android 之父 Andy Rubin对于GPL显然是不能接受的，为此，Google巧妙地将GPL协议控制在内核空间，将用户空间的协议采用Apache-2.0协议（允许基于Android的开发商不向社区反馈源码），同时在GPL协议与Apache-2.0之间的Lib库中采用BSD证授权方法，有效隔断了GPL的传染性，仍有较大争议，但至少目前缓解Android，让GPL止步于内核空间，这是Google在GPL Linux下开源与商业化共存的一个成功典范。
 
 **有了这些铺垫，我们再说说Binder的今世前缘**
 
-Binder是基于开源的 [OpenBinder](https://link.zhihu.com/?target=http%3A//www.angryredplanet.com/~hackbod/openbinder/docs/html/BinderIPCMechanism.html)实现的，OpenBinder是一个开源的系统IPC机制,最初是由 [Be Inc.](https://link.zhihu.com/?target=https%3A//en.wikipedia.org/wiki/Be_Inc.) 开发，接着由[Palm, Inc.](https://link.zhihu.com/?target=https%3A//en.wikipedia.org/wiki/Palm%2C_Inc.)公司负责开发，现在OpenBinder的作者在Google工作，既然作者在Google公司，在用户空间采用Binder 作为核心的IPC机制，再用Apache-2.0协议保护，自然而然是没什么问题，减少法律风险，以及对开发成本也大有裨益的，那么从公司战略角度，Binder也是不错的选择。
+Binder是基于开源的[OpenBinder](https://link.zhihu.com/?target=http%3A//www.angryredplanet.com/~hackbod/openbinder/docs/html/BinderIPCMechanism.html)实现的，OpenBinder是一个开源的系统IPC机制,最初是由 [Be Inc.](https://link.zhihu.com/?target=https%3A//en.wikipedia.org/wiki/Be_Inc.) 开发，接着由[Palm, Inc.](https://link.zhihu.com/?target=https%3A//en.wikipedia.org/wiki/Palm%2C_Inc.)公司负责开发，现在OpenBinder的作者在Google工作，既然作者在Google公司，在用户空间采用Binder 作为核心的IPC机制，再用Apache-2.0协议保护，自然而然是没什么问题，减少法律风险，以及对开发成本也大有裨益的，那么从公司战略角度，Binder也是不错的选择。
 
 另外，再说一点关于OpenBinder，在2015年OpenBinder以及合入到Linux Kernel主线 3.19版本，这也算是Google对Linux的一点回馈吧。
 
@@ -87,10 +83,10 @@ Binder是基于开源的 [OpenBinder](https://link.zhihu.com/?target=http%3A//ww
 
 **最后，简单讲讲Android Binder架构**
 
-Binder在Android系统中江湖地位非常之高。在Zygote孵化出system_server进程后，在system_server进程中出初始化支持整个Android framework的各种各样的Service，而这些Service从大的方向来划分，分为Java层Framework和Native Framework层(C++)的Service，几乎都是基于BInder IPC机制。
+Binder在Android系统中江湖地位非常之高。在Zygote孵化出system_server进程后，在system_server进程中出初始化支持整个Android framework的各种各样的Service，而这些Service从大的方向来划分，分为Java层Framework和Native Framework层(C++)的Service，几乎都是基于BInder IPC机制： 
 
-1. **Java framework：作为Server端继承(或间接继承)于Binder类，Client端继承(或间接继承)于BinderProxy类。**例如 ActivityManagerService(用于控制Activity、Service、进程等) 这个服务作为Server端，间接继承Binder类，而相应的ActivityManager作为Client端，间接继承于BinderProxy类。 当然还有PackageManagerService、WindowManagerService等等很多系统服务都是采用C/S架构；
-2. **Native Framework层：这是C++层，作为Server端继承(或间接继承)于BBinder类，Client端继承(或间接继承)于BpBinder。**例如MediaPlayService(用于多媒体相关)作为Server端，继承于BBinder类，而相应的MediaPlay作为Client端，间接继承于BpBinder类。
+1. Java framework：作为Server端继承(或间接继承)于Binder类，Client端继承(或间接继承)于BinderProxy类。例如 ActivityManagerService(用于控制Activity、Service、进程等) 这个服务作为Server端，间接继承Binder类，而相应的ActivityManager作为Client端，间接继承于BinderProxy类。 当然还有PackageManagerService、WindowManagerService等等很多系统服务都是采用C/S架构；
+2. Native Framework层：这是C++层，作为Server端继承(或间接继承)于BBinder类，Client端继承(或间接继承)于BpBinder。例如MediaPlayService(用于多媒体相关)作为Server端，继承于BBinder类，而相应的MediaPlay作为Client端，间接继承于BpBinder类。
 
 
 
@@ -100,21 +96,21 @@ Binder在Android系统中江湖地位非常之高。在Zygote孵化出system_ser
 
 前面人都说了Binder的优点，我来讲故事
 
-1. 当年Andy Rubin有个公司 Palm 做掌上设备的 就是当年那种PDA 有个系统叫PalmOS 后来palm被收购了以后 Andy Rubin 创立了Android
+1. 当年Andy Rubin有个公司Palm做掌上设备的就是当年那种PDA有个系统叫PalmOS后来palm被收购了以后 Andy Rubin创立了Android
 
-2. Palm收购过一个公司叫 Be 里面有个移动系统 叫 BeOS 进程通信自己学了个实现 叫Binder 由一个叫 Dianne Hackbod的人开发并维护 后来Binder 也被用到了 PalmOS里
+2. Palm收购过一个公司叫Be里面有个移动系统叫BeOS，进程通信自己写了个实现叫Binder由一个叫Dianne Hackbod的人开发并维护后来Binder也被用到了PalmOS里
 
-3. Android创立了以后 Andy从Palm带走了一大批人，其中就有Dianne。Dianne成为安卓系统总架构师。
+3. Android创立了以后Andy从Palm带走了一大批人，其中就有Dianne。Dianne成为安卓系统总架构师。
 
-- 如果你是她，你会选择用a.Linux已有的进程通信手段吗？ 不会，要不当年也不会搞个新东西出来 
+- 如果你是她，你会选择用Linux已有的进程通信手段吗？ 不会，要不当年也不会搞个新东西出来 
 
-- 重写一个新东西 也不会 binder反正是自己写的开源库
+- 重写一个新东西?也不会，binder反正是自己写的开源库
 
-- 用binder 已经被两个公司用过 而且是自己写的 可靠放心
+- 用binder?已经被两个公司用过而且是自己写的可靠放心
 
-我是她我就选C
+我是她我就用binder。
 
-你可以看到 如果当年Dianne没有加入Be 或者Be没有被收购 ，又或者Dianne没有和Andy加入Android 那Android也不一定会用binder。
+你可以看到 如果当年Dianne没有加入Be或者Be没有被收购 ，又或者Dianne没有和Andy加入Android 那Android也不一定会用binder。
 
 
 
@@ -146,7 +142,7 @@ Binder是一种架构，这种架构提供了服务端接口、Binder驱动、
 
 
 
-每个Android的进程，只能运行在自己进程所拥有的虚拟地址空间。对应一个4GB的虚拟地址空间，其中3GB是用户空间，1GB是内核空间，当然内核空间的大小是可以通过参数配置调整的。对于用户空间，不同进程之间彼此是不能共享的，而内核空间却是可共享的。Client进程向Server进程通信，恰恰是利用进程间可共享的内核内存空间来完成底层通信工作的，Client端与Server端进程往往采用ioctl等方法跟内核空间的驱动进行交互。
+每个Android的进程，只能运行在自己进程所拥有的虚拟地址空间。对应一个4GB的虚拟地址空间，其中3GB是用户空间，1GB是内核空间，当然内核空间的大小是可以通过参数配置调整的。对于用户空间，不同进程之间彼此是不能共享的，而内核空间却是可共享的。Client进程向Server进程通信，恰恰是利用进程间可共享的内核内存空间来完成底层通信工作的，Client端与Server端进程往往采用ioctl(设备驱动程序中设备控制接口函数，进程与内核通信的一种方法)等方法跟内核空间的驱动进行交互。
 
 
 
@@ -154,7 +150,7 @@ Binder通信采用C/S架构，从组件视角来说，包含Client、Server、Se
 
 ![ServiceManager](http://gityuan.com/images/binder/prepare/IPC-Binder.jpg)
 
-可以看出无论是注册服务和获取服务的过程都需要ServiceManager，需要注意的是此处的Service  Manager是指Native层的ServiceManager（C++），并非指framework层的ServiceManager(Java)。ServiceManager是整个Binder通信机制的大管家，是Android进程间通信机制Binder的守护进程，要掌握Binder机制，首先需要了解系统是如何首次[启动Service Manager](http://gityuan.com/2015/11/07/binder-start-sm/)。当Service Manager启动之后，Client端和Server端通信时都需要先[获取Service Manager](http://gityuan.com/2015/11/08/binder-get-sm/)接口，才能开始通信服务。
+可以看出无论是注册服务和获取服务的过程都需要ServiceManager，需要注意的是此处的Service  Manager是指Native层的ServiceManager（C++），并非指framework层的ServiceManager(Java)。ServiceManager是整个Binder通信机制的大管家，是Android进程间通信机制Binder的守护进程。
 
 图中Client/Server/ServiceManage之间的相互通信都是基于Binder机制。既然基于Binder机制通信，那么同样也是C/S架构，则图中的3大步骤都有相应的Client端与Server端。
 
@@ -189,8 +185,14 @@ BpBinder(客户端)和BBinder(服务端)都是Android中Binder通信相关的代
 
 
 
+---
+
+- [上一篇:8.虚拟机](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/8.%E8%99%9A%E6%8B%9F%E6%9C%BA.md)
 
-- [上一篇:7.嵌入式系统](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/7.%E5%B5%8C%E5%85%A5%E5%BC%8F%E7%B3%BB%E7%BB%9F.md)
+
+- [下一篇:2.Android线程间通信之Handler消息机制](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/AndroidKernal/2.Android%E7%BA%BF%E7%A8%8B%E9%97%B4%E9%80%9A%E4%BF%A1%E4%B9%8BHandler%E6%B6%88%E6%81%AF%E6%9C%BA%E5%88%B6.md)
+
+    
 
 
 ---

From cd425547bca4d9585c4c3f435bdc32fc6eef5bdf Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Fri, 4 Dec 2020 19:48:54 +0800
Subject: [PATCH 040/213] format text

---
 ...13\351\227\264\351\200\232\344\277\241.md" |    2 -
 ...10\346\201\257\346\234\272\345\210\266.md" |   85 +-
 ...roid Framework\346\241\206\346\236\266.md" |    7 +-
 ...ManagerService\347\256\200\344\273\213.md" |   15 +-
 ...10\346\201\257\350\216\267\345\217\226.md" |   11 +-
 ...30\345\210\266\345\237\272\347\241\200.md" |    5 +-
 ...30\345\210\266\345\216\237\347\220\206.md" | 1613 +++++++++++++++++
 ...ManagerService\347\256\200\344\273\213.md" |    9 +-
 ...ManagerService\347\256\200\344\273\213.md" |   10 +-
 9 files changed, 1704 insertions(+), 53 deletions(-)

diff --git "a/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md" "b/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md"
index 68b17d24..7263e837 100644
--- "a/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md"
+++ "b/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md"
@@ -183,8 +183,6 @@ BpBinder(客户端)和BBinder(服务端)都是Android中Binder通信相关的代
 
 
 
-
-
 ---
 
 - [上一篇:8.虚拟机](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/8.%E8%99%9A%E6%8B%9F%E6%9C%BA.md)
diff --git "a/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md" "b/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md"
index df78f0cf..dbcaf9bb 100644
--- "a/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md"
+++ "b/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md"
@@ -15,7 +15,7 @@ Binder/Socket用于进程间通信，而Handler消息机制用于同进程的线
 
 - Message：消息分为硬件产生的消息(如按钮、触摸)和软件生成的消息；Message中有一个用于处理消息的Handler；
 - MessageQueue：消息队列的主要功能向消息池投递消息(MessageQueue.enqueueMessage)和取走消息池的消息(MessageQueue.next)；MessageQueue有一组待处理的Message；
-- Handler：消息辅助类，主要功能向消息池发送各种消息事件(Handler.sendMessage)和处理相应消息事件(Handler.handleMessage)；Handler中有Looper和MessageQueue。
+- Handler：消息辅助类，主要功能向消息池发送各种消息事件(Handler.sendMessage)和处理相应消息事件(Handler.handleMessage)；Handler中有Looper和MessageQueue的成员变量。
 - Looper：不断循环执行(Looper.loop)，按分发机制将消息分发给目标处理者。Looper有一个MessageQueue消息队列；
 
 
@@ -57,7 +57,7 @@ public Handler(@NonNull Looper looper) {
 }
 
 public Handler(@Nullable Callback callback, boolean async) {
-	// 匿名类、内部类和本地类都必须申请为static，否则会警告可能出现内存泄露
+    // 匿名类、内部类和本地类都必须申请为static，否则会警告可能出现内存泄露
     if (FIND_POTENTIAL_LEAKS) {
         final Class<? extends Handler> klass = getClass();
         if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
@@ -73,7 +73,7 @@ public Handler(@Nullable Callback callback, boolean async) {
             "Can't create handler inside thread " + Thread.currentThread()
                     + " that has not called Looper.prepare()");
     }
-    // 获取Looper中的MessageQueue
+    // 获取Looper中的MessageQueue赋值给当前的MessageQueue变量
     mQueue = mLooper.mQueue;
     // 回调接口
     mCallback = callback;
@@ -181,11 +181,11 @@ private Looper(boolean quitAllowed) {
 
 ```java
 /**
-     * Initialize the current thread as a looper, marking it as an
-     * application's main looper. The main looper for your application
-     * is created by the Android environment, so you should never need
-     * to call this function yourself.  See also: {@link #prepare()}
-     */
+* Initialize the current thread as a looper, marking it as an
+* application's main looper. The main looper for your application
+* is created by the Android environment, so you should never need
+* to call this function yourself.  See also: {@link #prepare()}
+*/
 public static void prepareMainLooper() {
     prepare(false);
     synchronized (Looper.class) {
@@ -393,11 +393,11 @@ public static void loop() {
                 Trace.traceEnd(traceTag);
             }
         }
- 		// 恢复调用者信息
+        // 恢复调用者信息
         // Make sure that during the course of dispatching the
         // identity of the thread wasn't corrupted.
         final long newIdent = Binder.clearCallingIdentity();
-		// 将Message放入消息池
+        // 将Message放入消息池
         msg.recycleUnchecked();
     }
 }
@@ -503,8 +503,8 @@ public void handleMessage(@NonNull Message msg) {
 }
 
 /**
-     * Handle system messages here.
-     */
+ * Handle system messages here.
+ */
 public void dispatchMessage(@NonNull Message msg) {
     if (msg.callback != null) {
         // 如果Message存在回调方法，就回调Message.callback.run()方法
@@ -571,7 +571,7 @@ public final class MessageQueue {
             if (nextPollTimeoutMillis != 0) {
                 Binder.flushPendingCommands();
             }
-			// 该方法的作用是从消息队列中取出一个消息。MessageQueue中没有保存消息队列，真正的消息队列在JNI的C代码中
+            // 该方法的作用是从消息队列中取出一个消息。MessageQueue中没有保存消息队列，真正的消息队列在JNI的C代码中
             // 也就是在C环境中创建了一个NativeMessageQueue数据对象。该方法的第一个参数是int型变量，在C环境中该变量
             // 会被强制转换为一个NativeMessageQueue对象。如果消息队列中没消息，当前线程会被挂起。
             // 堵塞操作，当等待nextPollTimeoutMillis时长或消息队列别唤醒，都会返回
@@ -640,7 +640,7 @@ public final class MessageQueue {
                 }
                 mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
             }
-			// 空闲回调函数
+            // 空闲回调函数
             // Run the idle handlers.
             // We only ever reach this code block during the first iteration.
             for (int i = 0; i < pendingIdleHandlerCount; i++) {
@@ -770,7 +770,7 @@ public final class MessageQueue {
 
         synchronized (this) {
             Message p = mMessages;
-			// 从消息队列的头开始，移除所有符合条件的消息
+            // 从消息队列的头开始，移除所有符合条件的消息
             // Remove all messages at front.
             while (p != null && p.target == h
                    && (object == null || p.obj == object)) {
@@ -779,7 +779,7 @@ public final class MessageQueue {
                 p.recycleUnchecked();
                 p = n;
             }
-			// 移除剩余符合条件的消息
+            // 移除剩余符合条件的消息
             // Remove all messages after front.
             while (p != null) {
                 Message n = p.next;
@@ -807,7 +807,7 @@ public final class MessageQueue {
 
 
 
-有关内存泄露请猛戳[内存泄露][1]
+有关内存泄露请猛戳[内存泄露](https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E5%86%85%E5%AD%98%E6%B3%84%E6%BC%8F.md)
 
 在上面分析Handler类源码时，其构造函数中第一部分的代码就是 匿名类、内部类和本地类都必须申请为static，否则会警告可能出现内存泄露。那为什么会导致内存泄露呢？
 
@@ -815,7 +815,7 @@ public final class MessageQueue {
 Handler mHandler = new Handler() {
     @Override
     public void handleMessage(Message msg) {
-	    // do something.
+        // do something.
     }
 }
 ```
@@ -832,24 +832,25 @@ Handler mHandler = new Handler() {
 ```java
 public class SampleActivity extends Activity {
 
-  private final Handler mHandler = new Handler() {
-		@Override
-		public void handleMessage(Message msg) {
-		  // do something
-		}
-  }
+    private final Handler mHandler = new Handler() {
+        @Override
+        public void handleMessage(Message msg) {
+            // do something
+        }
+    }
 
-  @Override
-  protected void onCreate(Bundle savedInstanceState) {
-    super.onCreate(savedInstanceState);
-	// 发送一个10分钟后执行的一个消息
-	mHandler.postDelayed(new Runnable() {
-	  @Override
-	  public void run() { }
-	}, 600000);
-
-	// 结束当前的Activity
-	finish();
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        // 发送一个10分钟后执行的一个消息
+        mHandler.postDelayed(new Runnable() {
+            @Override
+            public void run() { }
+        }, 600000);
+
+        // 结束当前的Activity
+        finish();
+    }
 }
 ```
 在`finish()`的时候，该`Message`还没有被处理，`Message`持有`Handler`,`Handler`持有`Activity`,这样会导致该`Activity`不会被回收，就发生了内存泄露.
@@ -861,14 +862,13 @@ public class SampleActivity extends Activity {
     - 如果`Handler`是被`delay`的`Message`持有了引用，那么在`Activity`的`onDestroy()`方法要调用`Handler`的`remove*`方法，把消息对象从消息队列移除就行了。 
 	    - 关于`Handler.remove*`方法
 			- `removeCallbacks(Runnable r)` ——清除r匹配上的Message。    
-			- `removeC4allbacks(Runnable r, Object token)` ——清除r匹配且匹配token（Message.obj）的Message，token为空时，只匹配r。
-			- `removeCallbacksAndMessages(Object token)` ——清除token匹配上的Message。
+			- `removeCallbacks(Runnable r, Object token)` ——清除r匹配且匹配token（Message.obj）的Message，token为空时，只匹配r。
+			- `removeCallbacksAndMessages(Object token)` ——清除所有callback以及token匹配上的Message，如果token是null就会清楚所有callback和message。我们更多需要的是清除以该`Handler`为`target`的所有`Message(Callback)`就调用如下方法即可`handler.removeCallbacksAndMessages(null)`;
 			- `removeMessages(int what)` ——按what来匹配     
 			- `removeMessages(int what, Object object)` ——按what来匹配      
-			我们更多需要的是清除以该`Handler`为`target`的所有`Message(Callback)`就调用如下方法即可`handler.removeCallbacksAndMessages(null)`;
+			
 - 将`Handler`声明为静态类。
     静态类不持有外部类的对象，所以你的`Activity`可以随意被回收。但是不持有`Activity`的引用，如何去操作`Activity`中的一些对象？ 这里要用到弱引用
-	
 ```java
 public class MyActivity extends Activity {
 	private MyHandler mHandler;
@@ -905,9 +905,14 @@ public class MyActivity extends Activity {
 }
 ```
 
-[1]:(https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/%E5%86%85%E5%AD%98%E6%B3%84%E6%BC%8F.md)
 
 
+---
+
+
+
+- [上一篇:1.Android进程间通信](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/AndroidKernal/1.Android%E8%BF%9B%E7%A8%8B%E9%97%B4%E9%80%9A%E4%BF%A1.md)
+- [下一篇:3.Android Framework框架](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/AndroidKernal/3.Android%20Framework%E6%A1%86%E6%9E%B6.md)
 
 
 
diff --git "a/OperatingSystem/AndroidKernal/3.Android Framework\346\241\206\346\236\266.md" "b/OperatingSystem/AndroidKernal/3.Android Framework\346\241\206\346\236\266.md"
index 100b61d7..f550d1ee 100644
--- "a/OperatingSystem/AndroidKernal/3.Android Framework\346\241\206\346\236\266.md"	
+++ "b/OperatingSystem/AndroidKernal/3.Android Framework\346\241\206\346\236\266.md"	
@@ -33,7 +33,7 @@ AmS的作用是管理所有应用程序中的Activity。
 - Activity类：该类为APK程序中的一个最小运行单元，一个APK程序中可以包含多个Activity对象，ActivityThread类会根据用户操作选择运行哪个Activity对象。
 - PhoneWindow类：该类继承于Window类，同时，PhoneWindow类内部包含了一个DecorView对象。简而言之，PhoneWindow是把一个FrameLayout进行了一定的包装，并提供了一组通用的窗口操作接口。
 - Window类：该类提供了一组通用的窗口（Window)操作API，这里的窗口仅仅是程序层面上的，WmS所管理的窗口并不是Window类，而是一个View或者ViewGroup类，一般就是指DecorView类，即一个DecorView就是WmS所管理的一个窗口。Window是一个abstract类型。
-- DecorView类：该类是一个FrameLayout的子类，并且是PhoneWindow中的一个内部类。Decor的英文是Decoration，即”装饰“的意思，DecorView就是对普通的FrameLayout进行了一定的装饰，比如添加一个通用的Titlebar，并相应特定的按键消息等。
+- DecorView类：该类是一个FrameLayout的子类，并且是PhoneWindow中的一个内部类。Decor的英文是Decoration，即”装饰“的意思，DecorView就是对普通的FrameLayout进行了一定的装饰，比如添加一个通用的Titlebar，并响应特定的按键消息等。
 - ViewRoot类：WmS管理客户端窗口时，需要通知客户端进行某种操作，这些都是通过异步消息完成的，实现的方式就是使用Handler，ViewRoot类就是继承于Handler，其作用主要是接收WmS的通知。
 - W类：该类继承于Binder，并且是ViewRoot的一个内部类。
 - WindowManager类：客户端要申请创建一个窗口，而具体创建窗口的任务是由WmS完成的，WindowManager类就像是一个部门经理，谁有什么需求就告诉它，由它和WmS进行交互，客户端不能直接和WmS进行交互。
@@ -69,7 +69,7 @@ Linux驱动和Framework相关的主要包含两部分：
 
 - 窗口（Window）：这是一个纯语义的说法，即程序员所看到的屏幕上的某个独立的界面，比如一个带有TitleBar的Activity界面、一个对话框、一个Menu菜单等，这些都称之为窗口。从WmS的角度来讲，窗口是接收用户消息的最小单元，WmS内部用特定的类表示一个窗口，以实现对窗口的管理。WmS接收到用户消息后，首先要判断这个消息属于哪个窗口，然后通过IPC调用把这个消息传递给客户端的ViewRoot类。
 - Window类：该类在android.view包中，是一个abstract类，该类是对包含有可视界面的窗口的一种包装，所谓的可视界面就是指各种View或者ViewGroup，一般可以通过res/layout目录下的xml文件描述。
-- ViewRoot类：该类是android.view包中，客户端申请创建窗口时需要一个客户端代理，用以和WmS进行交互，这个就是ViewRoot的功能，每个客户端的窗口都会对应一个ViewRoot类。
+- ViewRoot类：该类是android.view包中，客户端申请创建窗口时需要一个客户端代理，用以和WmS进行交互，这个就是ViewRoot的功能，每个客户端的窗口都会对应一个ViewRoot类。ViewRoot类在Android2.2之后就被ViewRootImpl替换了。但是为了方便，后面还是会用ViewRoot类来介绍。
 - W类：该类是ViewRoot类的一个内部类，继承于Binder，用于想WmS提供一个IPC接口，从而让WmS控制窗口客户端的行为。
 
 描述一个窗口之所以有这么多类的原因在于，窗口的概念存在于客户端和服务端（WmS）之中，客户端所理解的窗口和服务端理解的窗口是不同的，因此，在客户端和服务端会用不同的类来描述窗口。比如在客户端，用户能看到的窗口一般是View或者ViewGroup组成的窗口，而与Activity对应的窗口却是一个DecorView类，而具备常规Phone操作的接口却又是一个PhoneWindow类。所以无论是在客户端还是服务端，对窗口都有不同层面的抽象。
@@ -94,7 +94,10 @@ Context在应用程序开发中会经常被使用，在一般的计算机书记
 
 
 
+---
 
+- [上一篇:2.Android线程间通信之Handler消息机制](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/AndroidKernal/2.Android%E7%BA%BF%E7%A8%8B%E9%97%B4%E9%80%9A%E4%BF%A1%E4%B9%8BHandler%E6%B6%88%E6%81%AF%E6%9C%BA%E5%88%B6.md)
+- [下一篇:4.ActivityManagerService简介](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/AndroidKernal/4.ActivityManagerService%E7%AE%80%E4%BB%8B.md)
 
 
 
diff --git "a/OperatingSystem/AndroidKernal/4.ActivityManagerService\347\256\200\344\273\213.md" "b/OperatingSystem/AndroidKernal/4.ActivityManagerService\347\256\200\344\273\213.md"
index 0a5b9007..3e88e552 100644
--- "a/OperatingSystem/AndroidKernal/4.ActivityManagerService\347\256\200\344\273\213.md"
+++ "b/OperatingSystem/AndroidKernal/4.ActivityManagerService\347\256\200\344\273\213.md"
@@ -1,6 +1,6 @@
 # 4.ActivityManagerService简介
 
-ActivityManagerService.java文件，简称AmS，是Android内核的三大核心功能之一，另外两个是WindowManagerService.java和View.java。Activity的管理实际上由三个主要类完成，分别是AmS、ActivityRecord及ActivityTask。AmS内部用ActivityRecord来表示一个Activity对象。ActivityStack是一个描述Task的类，所有和Task相关的数据以及控制都由ActivityStack来实现。
+ActivityManagerService简称AmS，是Android内核的三大核心功能之一，另外两个是WindowManagerService和View。Activity的管理实际上由三个主要类完成，分别是AmS、ActivityRecord及ActivityTask。AmS内部用ActivityRecord来表示一个Activity对象。ActivityStack是一个描述Task的类，所有和Task相关的数据以及控制都由ActivityStack来实现。
 
 AmS所提供的主要功能包括以下几项:   
 
@@ -16,7 +16,7 @@ AmS所提供的主要功能包括以下几项:
 
 在Android中，Activity调度的基本思路是：各应用进程要启动新的Activity或者停止当前的Activity，都要首先报告给AmS，而不能“擅自处理”。AmS在内部为所有应用程序都做了记录，当AmS接到启动或停止的报告时，首先更新内部记录，然后再通知相应客户进程运行或者停止指定的Activity。由于AmS内部有所有Activity的记录，也就理所当然地能够调度这些Activity，并根据Activity和系统内存的状态自动杀死后台的Activity。
 
-具体的讲，启动一个Activity有以下集中方式:  
+具体的讲，启动一个Activity有以下几种方式:  
 
 - 在应用程序中调用startActivity()启动指定的Activity。
 - 在Home程序中单击一个应用图标，启动新的Activity。
@@ -40,7 +40,7 @@ ProcessRecord记录一个进程中的相关信息，该类中内部变量可以
 AmS中使用HistoryRecord数据类来保存每个Activity的信息，这里非常奇怪，Activity本身也是一个类，为什么还要用HistoryRecord来保存Activity的信息，而不是直接用Activity呢？这是因为Activity是具体的功能类，这就好比每一个读者都是一个Activity，而学校要为每一个读者建立一个档案，这些档案中并不包含每个读者具体的学习能力，而只是学生的籍贯信息、姓名、出生日期等，HistoryRecord就是AmS为每一个Activity建立的档案，该数据类中的变量主要包含两部分:  
 
 - 环境信息：该Activity的工作环境，比如隶属于哪个Package，所在的进程名称、文件路径、数据路径、图标主题等。
-- 运行状态信息：比如idle、stop、finishing等，这些变量一般问boolean类型，这些状态值与应用程序中的onCreate、onPause、onStart等状态有所不同。
+- 运行状态信息：比如idle、stop、finishing等，这些变量一般为boolean类型，这些状态值与应用程序中的onCreate、onPause、onStart等状态有所不同。
 
 HistoryRecord类也是一个Binder，它基于IApplication.Stub类，因此它可以被IPC调用，一般是在WmS中进行该对象的IPC调用。
 
@@ -131,7 +131,7 @@ TaskRecord中并没有该任务中所包含的Activity的列表，比如ArrayLis
 
 
 
-## startActivi()启动流程
+## startActiviy()启动流程
 
 
 
@@ -142,6 +142,13 @@ TaskRecord中并没有该任务中所包含的Activity的列表，比如ArrayLis
 
 
 
+---
+
+- [上一篇:3.Android Framework框架](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/AndroidKernal/3.Android%20Framework%E6%A1%86%E6%9E%B6.md)
+- [下一篇:5.Android消息获取](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/AndroidKernal/5.Android%E6%B6%88%E6%81%AF%E8%8E%B7%E5%8F%96.md)
+
+
+
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
diff --git "a/OperatingSystem/AndroidKernal/5.Android\346\266\210\346\201\257\350\216\267\345\217\226.md" "b/OperatingSystem/AndroidKernal/5.Android\346\266\210\346\201\257\350\216\267\345\217\226.md"
index f731b4e9..3fe0e833 100644
--- "a/OperatingSystem/AndroidKernal/5.Android\346\266\210\346\201\257\350\216\267\345\217\226.md"
+++ "b/OperatingSystem/AndroidKernal/5.Android\346\266\210\346\201\257\350\216\267\345\217\226.md"
@@ -24,7 +24,7 @@
 1. 首先，InputReader线程会持续调用输入设备的驱动，读取所有用户输入的消息，该线程和InputDispatcher线程都在系统进程(system_process)空间中运行。InputDispatcher线程从自己的消息队列中取出原始消息，取出的消息有可能经过两种方式进行派发。
     - 经过管道（Pipe）直接派发到客户窗口中。
     - 先派发到WmS中，由WmS经过一定的处理，如果WmS没有处理该消息，则再派发给客户窗口中，否则，不派发到客户窗口。
-2. 应用程序添加窗口时，会在本地创建一个ViewRoot对象，然后通过IPC调用WmS中的Session对象的addWindow（）方法，从而请求WmS创建一个窗口。WmS会把窗口的相关信息保存在内部的一个窗口列表类InputMonitore中，然后使用InputManager类把这些窗口信息传递给InputDispatcher线程。传递的过程中，InputManager类需要调用JNI代码，把这些窗口信息传递给NativeInputManager对象中。
+2. 应用程序添加窗口时，会在本地创建一个ViewRoot对象，然后通过IPC调用WmS中的Session对象的addWindow()方法，从而请求WmS创建一个窗口。WmS会把窗口的相关信息保存在内部的一个窗口列表类InputMonitor中，然后使用InputManager类把这些窗口信息传递给InputDispatcher线程。传递的过程中，InputManager类需要调用JNI代码，把这些窗口信息传递给NativeInputManager对象中。
 3. 当InputDispatcher得到用户消息后，会根据NativeInputManager中保存的所有窗口信息判断当前的活动窗口是哪个，并把消息传递给该活动窗口。另外，如果是按键消息，InputDispatcher会先回调InputManager中定义的回调函数，这既会回调InputMonitor中的回调函数，又会回调WmS中定义的相关函数，所以这些回调函数的返回值类型是boolean。对于系统按键消息，比如“Home键”、电话按键等，WmS内部会按默认的方式处理，并返回false，从而InputDispatcher不会继续把这些按键消息传递给客户窗口。对于触摸屏消息，InputDispatcher则直接传递给客户窗口。
 4. 在InputDispatcher和客户窗口之间使用了管道（Pipe）机制进行消息传递。Pipe是Linux的一种系统调用，Linux会在内核地址空间中开辟一段共享内存，并产生一个Pipe对象。每个Pipe对象内部都会自动创建两个文件描述符，一个用于读，另一个用于写。应用程序可以调用pipe()函数产生一个Pipe对象，并获得该对象中的读、写文件描述符。文件描述符是全局唯一的，从而使得两个进程之间可以借助这两个描述符，一个往管道中写数据，另一个从管道中读数据。管道只能是单向的，因此，如果两个进程要进行双向消息传递，必须创建两个管道。当客户窗口请求WmS创建窗口时，WmS内部会创建两个管道，其中一个管道用于InputDispatcher向客户窗口传递消息，另一个用户客户窗口向InputDispatcher报告消息的执行结果。因此，有多少个客户窗口，就有多少个管道与InputDispatcher相连。
 5. 由于创建管道属于Linux系统调用，Java不能直接调用，另外也由于程序结构的需要，Android中把调用管道的相关操作封装到了InputChannel.java类中，同时该类中保存了InputDispatcher和客户窗口的管道收、发描述符。因此，InputChannel也可以理解为一个“通道”，在InputDispatcher端存在一个服务端消息通道（serverChannel）。在客户窗口端存在一个客户端消息通道（clientChannel）。管道和通道的区别是，管道是Linux系统的概念，使用pipe()系统调用就可以创建一个管道，而通道是Android内部定义的一个概念，主要保存了通信双发所使用的管道描述符。
@@ -54,6 +54,15 @@
 
 
 
+
+---
+
+- [上一篇:4.ActivityManagerService简介](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/AndroidKernal/4.ActivityManagerService%E7%AE%80%E4%BB%8B.md)
+- [下一篇:6.屏幕绘制基础](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/AndroidKernal/6.%E5%B1%8F%E5%B9%95%E7%BB%98%E5%88%B6%E5%9F%BA%E7%A1%80.md)
+
+
+
+
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
diff --git "a/OperatingSystem/AndroidKernal/6.\345\261\217\345\271\225\347\273\230\345\210\266\345\237\272\347\241\200.md" "b/OperatingSystem/AndroidKernal/6.\345\261\217\345\271\225\347\273\230\345\210\266\345\237\272\347\241\200.md"
index b4f24bb7..95e4f084 100644
--- "a/OperatingSystem/AndroidKernal/6.\345\261\217\345\271\225\347\273\230\345\210\266\345\237\272\347\241\200.md"
+++ "b/OperatingSystem/AndroidKernal/6.\345\261\217\345\271\225\347\273\230\345\210\266\345\237\272\347\241\200.md"
@@ -7,7 +7,7 @@ Android的屏幕绘制架构如下图：
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_draw_process_archi.jpg)
 
 - SurfaceFlinger服务进程：简称sf。该进程在整个系统中只有一个实例，在系统开机后自动运行，它的作用是给每个客户端分配窗口，程序中用Surface类表示这个窗口。正如Surface字面的意义，它是一个平面，即每个窗口是一个平面，每个平面在程序中都对应一段内存，也就是所谓的屏幕缓冲区，不同窗口的缓冲区大小不同，这取决于该窗口的大小，即宽度和高度，一般来讲缓冲区的大小为宽度x高度。sf的客户端必须使用SurfaceFlinger的客户端接口驱动来和sf打交道，系统中使用该接口驱动的最重要的进程就是SystemServer进程。
-- 当一个APK程序需要创建窗口时，会使用WindowManager类的addView()函数，该函数会创建一个ViewRoot对象，而ViewRoot类中会使用Surface的无参构造函数创建一个Surface对象，此时该Surface仅仅是一个空壳，然后调用WindowManager类向WmS服务发起一个请求，请求的参数中包含该Surface对象。虽然它表示的是一个窗口，但它必须经过初始化后才真正能够对应一个再屏幕上显示的窗口，而初始化的本质就是给该Surface对象分配一段屏幕缓冲区的内存。
+- 当一个APK程序需要创建窗口时，会使用WindowManager类的addView()函数，该函数会创建一个ViewRoot(ViewRoot类在Android2.2之后就被ViewRootImpl替换了，这里因为方便后面还是会叫做ViewRoot)对象，而ViewRoot类中会使用Surface的无参构造函数创建一个Surface对象，此时该Surface仅仅是一个空壳，然后调用WindowManager类向WmS服务发起一个请求，请求的参数中包含该Surface对象。虽然它表示的是一个窗口，但它必须经过初始化后才真正能够对应一个再屏幕上显示的窗口，而初始化的本质就是给该Surface对象分配一段屏幕缓冲区的内存。
 - WmS收到这个请求后，会通过Surface类的JNI调用到SurfaceFlinger_client驱动，通过该client接口驱动请求sf进程创建指定的窗口。于是sf创建一段屏幕缓冲区，并在sf内部记录该窗口，然后sf会把该窗口的缓冲区地址传递给WmS，WmS再用这个地址去初始化APK程序传入的Surface对象，并最终回到APK程序中。此时APK程序中的Surface对象是一个真正的Surface对象了，因为它包含的屏幕缓冲区已经由sf创建并备案了。 
 - APK程序有了这个Surface后，就可以给这个平面上绘制任意的内容了，比如绘制矩阵、绘制文本、绘制图片等。然后Surface类本质上仅仅表示了一个平面，而绘制不同图片显然是一种操作，而不是一段数据，因此Android中使用了一个叫做Skia的绘图驱动库，该库使用C/C++语言编写而成，其作用就是能够进行各种平面绘制。在程序中用Canvas类来表示这个功能对象，Canvas类有很多绘制函数，比如drawColor()、drawLine()等。Surface类包含了一个函数lockCanvas()，APK应用程序可以通过该函数返回一个Canvas功能对象，然后就可以调用该对象的各种绘制函数完成对平面的绘制。
 
@@ -40,7 +40,10 @@ Android的屏幕绘制架构如下图：
 
 
 
+---
 
+- [上一篇:5.Android消息获取](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/AndroidKernal/5.Android%E6%B6%88%E6%81%AF%E8%8E%B7%E5%8F%96.md)
+- [下一篇:7.View绘制原理](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/AndroidKernal/7.View%E7%BB%98%E5%88%B6%E5%8E%9F%E7%90%86.md)
 
 
 
diff --git "a/OperatingSystem/AndroidKernal/7.View\347\273\230\345\210\266\345\216\237\347\220\206.md" "b/OperatingSystem/AndroidKernal/7.View\347\273\230\345\210\266\345\216\237\347\220\206.md"
index a5def400..325c231f 100644
--- "a/OperatingSystem/AndroidKernal/7.View\347\273\230\345\210\266\345\216\237\347\220\206.md"
+++ "b/OperatingSystem/AndroidKernal/7.View\347\273\230\345\210\266\345\216\237\347\220\206.md"
@@ -2,11 +2,1624 @@
 
 
 
+界面窗口的根布局是`DecorView`，该类继承自`FrameLayout`.说到`View`绘制，想到的就是从这里入手，而`FrameLayout`继承自`ViewGroup`。感觉绘制肯定会在`ViewGroup`或者`View`中，
+但是木有找到。发现`ViewGroup`实现`ViewParent`接口，而`ViewParent`有一个实现类是`ViewRootImpl`， `ViewGruop`中会使用`ViewRootImpl`...
 
+```java
+/**
+ * The top of a view hierarchy, implementing the needed protocol between View
+ * and the WindowManager.  This is for the most part an internal implementation
+ * detail of {@link WindowManagerGlobal}.
+ *
+ * {@hide}
+ */
+@SuppressWarnings({"EmptyCatchBlock", "PointlessBooleanExpression"})
+public final class ViewRootImpl implements ViewParent,
+        View.AttachInfo.Callbacks, HardwareRenderer.HardwareDrawCallbacks {
+		
+		}
+```
 
+`View`的绘制过程从`ViewRootImpl.performTraversals()`方法开始，你看这个名字起的多好，叫执行遍历，看到名字就能知道内部的实现:   
 
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/view_performTraversals.png)
 
+首先先说明一下，这部分代码比较多，逻辑也比较麻烦，很容易弄晕，如果感觉看起来费劲，就跳过这一块，直接到下面的Measure、Layout、Draw部分开始看。
+我也没有全部弄清楚，我只是把里面的步骤标注了下。
 
+```java
+private void performTraversals() {
+	// ... 此处省略源代码N行
+    if (mFirst || windowShouldResize || insetsChanged ||
+                viewVisibilityChanged || params != null || mForceNextWindowRelayout) {
+        // 第一或者resize等都会调用relayoutWindow，而该函数内部会调用sWindowSession.relayout()
+        // 方法来请求WmS按照指定的大小重新分配窗口大小，并会为客户窗口创建的mSurface对象分配真正的现存
+        // 等该函数返回后，应用程序就可以在该Surface中绘制了。
+		relayoutResult = relayoutWindow(params, viewVisibility, insetsPending);
+    }
+	// 是否需要Measure
+	if (!mStopped) {
+		boolean focusChangedDueToTouchMode = ensureTouchModeLocally(
+				(relayoutResult&WindowManagerGlobal.RELAYOUT_RES_IN_TOUCH_MODE) != 0);
+		if (focusChangedDueToTouchMode || mWidth != host.getMeasuredWidth()
+				|| mHeight != host.getMeasuredHeight() || contentInsetsChanged) {
+			// 这里是获取widthMeasureSpec,这俩参数不是一般的尺寸数值，而是将模式和尺寸组合在一起的数值.
+			// getRootMeasureSpec方法内部会使用MeasureSpec.makeMeasureSpec()方法来组装一个MeasureSpec，
+			// 当lp.width参数等于MATCH_PARENT的时候，MeasureSpec的specMode就等于EXACTLY，当lp.width等于WRAP_CONTENT的时候，MeasureSpec的specMode就等于AT_MOST。
+			// 并且MATCH_PARENT和WRAP_CONTENT时的specSize都是等于windowSize的，也就意味着根视图总是会充满全屏的。
+            // 这里lp代表的是根视图的LayoutParams、lp.width和lp.height直接来源于用户的定义比如WRAP_CONTENT、MATCH_PARENT等
+			int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
+			int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);
+
+			if (DEBUG_LAYOUT) Log.v(TAG, "Ooops, something changed!  mWidth="
+					+ mWidth + " measuredWidth=" + host.getMeasuredWidth()
+					+ " mHeight=" + mHeight
+					+ " measuredHeight=" + host.getMeasuredHeight()
+					+ " coveredInsetsChanged=" + contentInsetsChanged);
+			
+			// 调用PerformMeasure方法。
+			 // Ask host how big it wants to be
+			performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
+
+			// Implementation of weights from WindowManager.LayoutParams
+			// We just grow the dimensions as needed and re-measure if
+			// needs be
+			int width = host.getMeasuredWidth();
+			int height = host.getMeasuredHeight();
+			boolean measureAgain = false;
+
+			if (lp.horizontalWeight > 0.0f) {
+				width += (int) ((mWidth - width) * lp.horizontalWeight);
+				childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(width,
+						MeasureSpec.EXACTLY);
+				measureAgain = true;
+			}
+			if (lp.verticalWeight > 0.0f) {
+				height += (int) ((mHeight - height) * lp.verticalWeight);
+				childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(height,
+						MeasureSpec.EXACTLY);
+				measureAgain = true;
+			}
+
+			if (measureAgain) {
+				if (DEBUG_LAYOUT) Log.v(TAG,
+						"And hey let's measure once more: width=" + width
+						+ " height=" + height);
+				performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
+			}
+
+			layoutRequested = true;
+		}
+	}
+
+	final boolean didLayout = layoutRequested && !mStopped;
+	boolean triggerGlobalLayoutListener = didLayout
+			|| mAttachInfo.mRecomputeGlobalAttributes;
+	// 是否需要Layout
+	if (didLayout) {
+		// 调用performLayout方法。
+		performLayout(lp, desiredWindowWidth, desiredWindowHeight);
+
+		// By this point all views have been sized and positioned
+		// We can compute the transparent area
+
+		if ((host.mPrivateFlags & View.PFLAG_REQUEST_TRANSPARENT_REGIONS) != 0) {
+			// start out transparent
+			// TODO: AVOID THAT CALL BY CACHING THE RESULT?
+			host.getLocationInWindow(mTmpLocation);
+			mTransparentRegion.set(mTmpLocation[0], mTmpLocation[1],
+					mTmpLocation[0] + host.mRight - host.mLeft,
+					mTmpLocation[1] + host.mBottom - host.mTop);
+
+			host.gatherTransparentRegion(mTransparentRegion);
+			if (mTranslator != null) {
+				mTranslator.translateRegionInWindowToScreen(mTransparentRegion);
+			}
+
+			if (!mTransparentRegion.equals(mPreviousTransparentRegion)) {
+				mPreviousTransparentRegion.set(mTransparentRegion);
+				mFullRedrawNeeded = true;
+				// reconfigure window manager
+				try {
+					mWindowSession.setTransparentRegion(mWindow, mTransparentRegion);
+				} catch (RemoteException e) {
+				}
+			}
+		}
+
+		if (DBG) {
+			System.out.println("======================================");
+			System.out.println("performTraversals -- after setFrame");
+			host.debug();
+		}
+	}
+
+	// 是否需要Draw
+	if (!cancelDraw && !newSurface) {
+		if (!skipDraw || mReportNextDraw) {
+			if (mPendingTransitions != null && mPendingTransitions.size() > 0) {
+				for (int i = 0; i < mPendingTransitions.size(); ++i) {
+					mPendingTransitions.get(i).startChangingAnimations();
+				}
+				mPendingTransitions.clear();
+			}
+			// 调用performDraw方法
+			performDraw();
+		}
+	} else {
+		if (viewVisibility == View.VISIBLE) {
+			// Try again
+			scheduleTraversals();
+		} else if (mPendingTransitions != null && mPendingTransitions.size() > 0) {
+			for (int i = 0; i < mPendingTransitions.size(); ++i) {
+				mPendingTransitions.get(i).endChangingAnimations();
+			}
+			mPendingTransitions.clear();
+		}
+	}
+
+	mIsInTraversal = false;
+}
+```
+
+从上面源码可以看出,`performTraversals()`方法中会依次做三件事：
+- `performMeasure()`, 内部是` mView.measure(childWidthMeasureSpec, childHeightMeasureSpec);`测量`View`大小。这里顺便提一下，这个`mView`是什么？它就是`Window`最顶成的`View(DecorView)`,它是`FrameLayout`的子类。
+- `performLayout()`, 内部是`mView.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());`视图布局，确定`View`位置。
+- `performDraw()`, 内部是`draw(fullRedrawNeeded);` 绘制界面。
+
+至此`View`绘制的三个过程已经展现：
+
+`Measure`
+===
+
+
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/view_measure.png)
+
+
+
+`performMeasure`方法如下：
+
+```java
+private void performMeasure(int childWidthMeasureSpec, int childHeightMeasureSpec) {
+	Trace.traceBegin(Trace.TRACE_TAG_VIEW, "measure");
+	try {
+		mView.measure(childWidthMeasureSpec, childHeightMeasureSpec);
+	} finally {
+		Trace.traceEnd(Trace.TRACE_TAG_VIEW);
+	}
+}
+```
+
+在`performMeasure()`方法中会调用`View.measure()`方法， 源码如下：
+```java
+/**
+ * <p>
+ * This is called to find out how big a view should be. The parent
+ * supplies constraint information in the width and height parameters.
+ * </p>
+ *
+ * <p>
+ * The actual measurement work of a view is performed in
+ * {@link #onMeasure(int, int)}, called by this method. Therefore, only
+ * {@link #onMeasure(int, int)} can and must be overridden by subclasses.
+ * </p>
+ *
+ *
+ * @param widthMeasureSpec Horizontal space requirements as imposed by the
+ *        parent
+ * @param heightMeasureSpec Vertical space requirements as imposed by the
+ *        parent
+ *
+ * @see #onMeasure(int, int)
+ */
+public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
+	boolean optical = isLayoutModeOptical(this);
+	if (optical != isLayoutModeOptical(mParent)) {
+		Insets insets = getOpticalInsets();
+		int oWidth  = insets.left + insets.right;
+		int oHeight = insets.top  + insets.bottom;
+        // adjust是微调某个MeasureSpec的大小
+		widthMeasureSpec  = MeasureSpec.adjust(widthMeasureSpec,  optical ? -oWidth  : oWidth);
+		heightMeasureSpec = MeasureSpec.adjust(heightMeasureSpec, optical ? -oHeight : oHeight);
+	}
+
+	// Suppress sign extension for the low bytes
+	long key = (long) widthMeasureSpec << 32 | (long) heightMeasureSpec & 0xffffffffL;
+	if (mMeasureCache == null) mMeasureCache = new LongSparseLongArray(2);
+
+	if ((mPrivateFlags & PFLAG_FORCE_LAYOUT) == PFLAG_FORCE_LAYOUT ||
+			widthMeasureSpec != mOldWidthMeasureSpec ||
+			heightMeasureSpec != mOldHeightMeasureSpec) {
+
+		// first clears the measured dimension flag
+		mPrivateFlags &= ~PFLAG_MEASURED_DIMENSION_SET;
+
+		resolveRtlPropertiesIfNeeded();
+
+		int cacheIndex = (mPrivateFlags & PFLAG_FORCE_LAYOUT) == PFLAG_FORCE_LAYOUT ? -1 :
+				mMeasureCache.indexOfKey(key);
+		if (cacheIndex < 0 || sIgnoreMeasureCache) {
+			// 调用onMeasure方法
+			// measure ourselves, this should set the measured dimension flag back
+			onMeasure(widthMeasureSpec, heightMeasureSpec);
+			mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
+		} else {
+			long value = mMeasureCache.valueAt(cacheIndex);
+			// Casting a long to int drops the high 32 bits, no mask needed
+			setMeasuredDimensionRaw((int) (value >> 32), (int) value);
+			mPrivateFlags3 |= PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
+		}
+
+		// flag not set, setMeasuredDimension() was not invoked, we raise
+		// an exception to warn the developer
+		if ((mPrivateFlags & PFLAG_MEASURED_DIMENSION_SET) != PFLAG_MEASURED_DIMENSION_SET) {
+			// 重写onMeausre方法的时，必须调用setMeasuredDimension或者super.onMeasure方法，不然就会走到这里报错。
+			// setMeasuredDimension中回去改变mPrivateFlags的值
+			throw new IllegalStateException("onMeasure() did not set the"
+					+ " measured dimension by calling"
+					+ " setMeasuredDimension()");
+		}
+
+		mPrivateFlags |= PFLAG_LAYOUT_REQUIRED;
+	}
+
+	mOldWidthMeasureSpec = widthMeasureSpec;
+	mOldHeightMeasureSpec = heightMeasureSpec;
+
+	mMeasureCache.put(key, ((long) mMeasuredWidth) << 32 |
+			(long) mMeasuredHeight & 0xffffffffL); // suppress sign extension
+}
+```
+
+在`measure`方法中会调用`onMeasure`方法。`ViewGroup`的子类会重写该方法来进行测量大小，因为`mView`是`DecorView`，
+而`DecorView`是`FrameLayout`的子类。所以我们看一下`FrameLayout.onMeasure`方法：
+`FrameLayout.onMeasure`源码如下：
+```java
+/**
+ * {@inheritDoc}
+ */
+@Override
+protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+	int count = getChildCount();
+
+	final boolean measureMatchParentChildren =
+			MeasureSpec.getMode(widthMeasureSpec) != MeasureSpec.EXACTLY ||
+			MeasureSpec.getMode(heightMeasureSpec) != MeasureSpec.EXACTLY;
+	mMatchParentChildren.clear();
+
+	int maxHeight = 0;
+	int maxWidth = 0;
+	int childState = 0;
+
+	for (int i = 0; i < count; i++) {
+		final View child = getChildAt(i);
+		if (mMeasureAllChildren || child.getVisibility() != GONE) {
+			// 调用该方法去测量每个子View
+			measureChildWithMargins(child, widthMeasureSpec, 0, heightMeasureSpec, 0);
+			final LayoutParams lp = (LayoutParams) child.getLayoutParams();
+			maxWidth = Math.max(maxWidth,
+					child.getMeasuredWidth() + lp.leftMargin + lp.rightMargin);
+			maxHeight = Math.max(maxHeight,
+					child.getMeasuredHeight() + lp.topMargin + lp.bottomMargin);
+			childState = combineMeasuredStates(childState, child.getMeasuredState());
+			if (measureMatchParentChildren) {
+				if (lp.width == LayoutParams.MATCH_PARENT ||
+						lp.height == LayoutParams.MATCH_PARENT) {
+					mMatchParentChildren.add(child);
+				}
+			}
+		}
+	}
+
+	// Account for padding too
+	maxWidth += getPaddingLeftWithForeground() + getPaddingRightWithForeground();
+	maxHeight += getPaddingTopWithForeground() + getPaddingBottomWithForeground();
+
+	// Check against our minimum height and width
+	maxHeight = Math.max(maxHeight, getSuggestedMinimumHeight());
+	maxWidth = Math.max(maxWidth, getSuggestedMinimumWidth());
+
+	// Check against our foreground's minimum height and width
+	final Drawable drawable = getForeground();
+	if (drawable != null) {
+		maxHeight = Math.max(maxHeight, drawable.getMinimumHeight());
+		maxWidth = Math.max(maxWidth, drawable.getMinimumWidth());
+	}
+
+	setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),
+			resolveSizeAndState(maxHeight, heightMeasureSpec,
+					childState << MEASURED_HEIGHT_STATE_SHIFT));
+
+	count = mMatchParentChildren.size();
+	if (count > 1) {
+		for (int i = 0; i < count; i++) {
+			final View child = mMatchParentChildren.get(i);
+
+			final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();
+			int childWidthMeasureSpec;
+			int childHeightMeasureSpec;
+			
+			if (lp.width == LayoutParams.MATCH_PARENT) {
+				childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(getMeasuredWidth() -
+						getPaddingLeftWithForeground() - getPaddingRightWithForeground() -
+						lp.leftMargin - lp.rightMargin,
+						MeasureSpec.EXACTLY);
+			} else {
+				childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec,
+						getPaddingLeftWithForeground() + getPaddingRightWithForeground() +
+						lp.leftMargin + lp.rightMargin,
+						lp.width);
+			}
+			
+			if (lp.height == LayoutParams.MATCH_PARENT) {
+				childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(getMeasuredHeight() -
+						getPaddingTopWithForeground() - getPaddingBottomWithForeground() -
+						lp.topMargin - lp.bottomMargin,
+						MeasureSpec.EXACTLY);
+			} else {
+				childHeightMeasureSpec = getChildMeasureSpec(heightMeasureSpec,
+						getPaddingTopWithForeground() + getPaddingBottomWithForeground() +
+						lp.topMargin + lp.bottomMargin,
+						lp.height);
+			}
+
+			child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
+		}
+	}
+}
+```
+
+我们看到内部会调用`measureChildWithMargins()`方法,该方法源码如下：
+```java
+/**
+ * Ask one of the children of this view to measure itself, taking into
+ * account both the MeasureSpec requirements for this view and its padding
+ * and margins. The child must have MarginLayoutParams The heavy lifting is
+ * done in getChildMeasureSpec.
+ *
+ * @param child The child to measure
+ * @param parentWidthMeasureSpec The width requirements for this view
+ * @param widthUsed Extra space that has been used up by the parent
+ *        horizontally (possibly by other children of the parent)
+ * @param parentHeightMeasureSpec The height requirements for this view
+ * @param heightUsed Extra space that has been used up by the parent
+ *        vertically (possibly by other children of the parent)
+ */
+protected void measureChildWithMargins(View child,
+		int parentWidthMeasureSpec, int widthUsed,
+		int parentHeightMeasureSpec, int heightUsed) {
+	final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();
+
+	final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
+			mPaddingLeft + mPaddingRight + lp.leftMargin + lp.rightMargin
+					+ widthUsed, lp.width);
+	final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
+			mPaddingTop + mPaddingBottom + lp.topMargin + lp.bottomMargin
+					+ heightUsed, lp.height);
+
+	child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
+}
+```
+里面就是对该子`View`调用了`measure`方法，我们假设这个`View`已经不是`ViewGroup`了，就会又和上面一样，又调用`onMeasure`方法，
+下面我们直接看一下`View.onMeasure()`方法：
+`View.onMeasure()`方法的源码如下：
+```java
+/**
+ * <p>
+ * Measure the view and its content to determine the measured width and the
+ * measured height. This method is invoked by {@link #measure(int, int)} and
+ * should be overriden by subclasses to provide accurate and efficient
+ * measurement of their contents.
+ * </p>
+ *
+ * <p>
+ * <strong>CONTRACT:</strong> When overriding this method, you
+ * <em>must</em> call {@link #setMeasuredDimension(int, int)} to store the
+ * measured width and height of this view. Failure to do so will trigger an
+ * <code>IllegalStateException</code>, thrown by
+ * {@link #measure(int, int)}. Calling the superclass'
+ * {@link #onMeasure(int, int)} is a valid use.
+ * </p>
+ *
+ * <p>
+ * The base class implementation of measure defaults to the background size,
+ * unless a larger size is allowed by the MeasureSpec. Subclasses should
+ * override {@link #onMeasure(int, int)} to provide better measurements of
+ * their content.
+ * </p>
+ *
+ * <p>
+ * If this method is overridden, it is the subclass's responsibility to make
+ * sure the measured height and width are at least the view's minimum height
+ * and width ({@link #getSuggestedMinimumHeight()} and
+ * {@link #getSuggestedMinimumWidth()}).
+ * </p>
+ *
+ * @param widthMeasureSpec horizontal space requirements as imposed by the parent.
+ *                         The requirements are encoded with
+ *                         {@link android.view.View.MeasureSpec}.
+ * @param heightMeasureSpec vertical space requirements as imposed by the parent.
+ *                         The requirements are encoded with
+ *                         {@link android.view.View.MeasureSpec}.
+ *
+ * @see #getMeasuredWidth()
+ * @see #getMeasuredHeight()
+ * @see #setMeasuredDimension(int, int)
+ * @see #getSuggestedMinimumHeight()
+ * @see #getSuggestedMinimumWidth()
+ * @see android.view.View.MeasureSpec#getMode(int)
+ * @see android.view.View.MeasureSpec#getSize(int)
+ */
+protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+	// 如果不重写onMeasure方法，默认会调用getDefaultSize获取大小，下面会说getDefaultSize这个方法。
+	setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
+			getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
+}
+```
+
+`setMeasuredDimension()`方法如下： 
+```java
+/**
+ * <p>This method must be called by {@link #onMeasure(int, int)} to store the
+ * measured width and measured height. Failing to do so will trigger an
+ * exception at measurement time.</p>
+ *
+ * @param measuredWidth The measured width of this view.  May be a complex
+ * bit mask as defined by {@link #MEASURED_SIZE_MASK} and
+ * {@link #MEASURED_STATE_TOO_SMALL}.
+ * @param measuredHeight The measured height of this view.  May be a complex
+ * bit mask as defined by {@link #MEASURED_SIZE_MASK} and
+ * {@link #MEASURED_STATE_TOO_SMALL}.
+ */
+protected final void setMeasuredDimension(int measuredWidth, int measuredHeight) {
+	boolean optical = isLayoutModeOptical(this);
+	if (optical != isLayoutModeOptical(mParent)) {
+		Insets insets = getOpticalInsets();
+		int opticalWidth  = insets.left + insets.right;
+		int opticalHeight = insets.top  + insets.bottom;
+
+		measuredWidth  += optical ? opticalWidth  : -opticalWidth;
+		measuredHeight += optical ? opticalHeight : -opticalHeight;
+	}
+	setMeasuredDimensionRaw(measuredWidth, measuredHeight);
+}
+```
+`setMeasuredDimensionRaw()`方法如下： 
+```java
+/**
+ * Sets the measured dimension without extra processing for things like optical bounds.
+ * Useful for reapplying consistent values that have already been cooked with adjustments
+ * for optical bounds, etc. such as those from the measurement cache.
+ *
+ * @param measuredWidth The measured width of this view.  May be a complex
+ * bit mask as defined by {@link #MEASURED_SIZE_MASK} and
+ * {@link #MEASURED_STATE_TOO_SMALL}.
+ * @param measuredHeight The measured height of this view.  May be a complex
+ * bit mask as defined by {@link #MEASURED_SIZE_MASK} and
+ * {@link #MEASURED_STATE_TOO_SMALL}.
+ */
+private void setMeasuredDimensionRaw(int measuredWidth, int measuredHeight) {
+	// 赋值给mMeasuredWidth，getMeasuredWidth就会调用该值。
+	mMeasuredWidth = measuredWidth;
+	mMeasuredHeight = measuredHeight;
+
+	// 这就是重写onMeasure方法时如果不调用setMeasuredDimension方法时为什么会报错的原因。
+	mPrivateFlags |= PFLAG_MEASURED_DIMENSION_SET;
+}
+```
+
+我们接着看一下上面用到的`getDefaultSize()`方法，源码如下：
+```java
+/**
+ * Utility to return a default size. Uses the supplied size if the
+ * MeasureSpec imposed no constraints. Will get larger if allowed
+ * by the MeasureSpec.
+ *
+ * @param size Default size for this view
+ * @param measureSpec Constraints imposed by the parent
+ * @return The size this view should be.
+ */
+public static int getDefaultSize(int size, int measureSpec) {
+	int result = size;
+	// measureSpec值用于获取宽度(高度)的规格和大小，解析出对应的size和mode
+	int specMode = MeasureSpec.getMode(measureSpec);
+	int specSize = MeasureSpec.getSize(measureSpec);
+
+	switch (specMode) {
+	case MeasureSpec.UNSPECIFIED:
+		result = size;
+		break;
+	case MeasureSpec.AT_MOST:
+	case MeasureSpec.EXACTLY:
+		result = specSize;
+		break;
+	}
+	return result;
+}
+```
+`getDefaultSize`方法又会使用到`MeasureSpec`类，文档中对`MeasureSpec`是这样介绍的`A MeasureSpec is comprised of a size and a mode. There are three possible modes:`
+- MeasureSpec.EXACTLY The parent has determined an exact size for the child. The child is going to be given those bounds regardless of how big it wants to be. 
+    理解成MATCH_PARENT或者在布局中指定了宽高值，如layout:width='50dp'
+- MeasureSpec.AT_MOST The child can be as large as it wants up to the specified size.理解成WRAP_CONTENT,这是的值是父View可以允许的最大的值，只要不超过这个值都可以。
+- MeasureSpec.UNSPECIFIED The parent has not imposed any constraint on the child. It can be whatever size it wants. 这种情况比较少，一般用不到。
+
+这里简单总结一下上面的过程:
+```java
+performMeasure() {
+	- 1.调用View.measure方法
+	mView.measure():
+		- 2.measure内部会调用onMeasure方法,但是因为这里mView是DecorView，所以会调用FrameLayout的onMeasure方法。
+	        onMeasure(FrameLayout)
+			- 3. 内部设置ViewGroup的宽高
+				setMeasuredDimension
+				并且对每个子View进行遍历测量
+				for (int i = 0; i < count; i++) {
+					final View child = getChildAt(i);
+					- 4. 对每个子View调用measureChildWithMargins方法
+					measureChildWithMargins(child, widthMeasureSpec, 0, heightMeasureSpec, 0);	
+					    -5. measureChildWithMargins内部调用子View的measure方法
+					        meausre
+							- 6. measure方法内部又调用onMeasure方法
+					            onMeasure(View)
+					            - 7. onMeasure方法内部调用setMeasuredDimension
+									setMeasuredDimension
+									- 8. setMeasuredDimension内部调用setMeasuredDimensionRaw
+									    setMeasuredDimensionRaw
+				}
+}
+```
+
+从上面代码中能看到`measure`是`final`的，我们可以重写`onMeasure`来实现`measure`过程。
+到这里基本都讲完了，我们在开发中会按照需要重写`onMeasure`方法，然后调用`setMeasuredDimension`方法设置大小，
+ps:譬如我们设置了`setMeasuredDimension(10, 10)`,那么不管布局中怎么设置这个`View`的大小
+都是没用的，最后显示出来大小都是10*10。
+
+`Layout`
+===
+
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/view_layout.png)
+
+
+
+`performLayout`方法源码如下：
+
+```java
+private void performLayout(WindowManager.LayoutParams lp, int desiredWindowWidth,
+		int desiredWindowHeight) {
+	mLayoutRequested = false;
+	mScrollMayChange = true;
+	mInLayout = true;
+
+	final View host = mView;
+	if (DEBUG_ORIENTATION || DEBUG_LAYOUT) {
+		Log.v(TAG, "Laying out " + host + " to (" +
+				host.getMeasuredWidth() + ", " + host.getMeasuredHeight() + ")");
+	}
+
+	Trace.traceBegin(Trace.TRACE_TAG_VIEW, "layout");
+	try {
+		// 把刚才测量的宽高设置进来
+		host.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());
+
+		mInLayout = false;
+		int numViewsRequestingLayout = mLayoutRequesters.size();
+		if (numViewsRequestingLayout > 0) {
+			// requestLayout() was called during layout.
+			// If no layout-request flags are set on the requesting views, there is no problem.
+			// If some requests are still pending, then we need to clear those flags and do
+			// a full request/measure/layout pass to handle this situation.
+			ArrayList<View> validLayoutRequesters = getValidLayoutRequesters(mLayoutRequesters,
+					false);
+			if (validLayoutRequesters != null) {
+				// Set this flag to indicate that any further requests are happening during
+				// the second pass, which may result in posting those requests to the next
+				// frame instead
+				mHandlingLayoutInLayoutRequest = true;
+
+				// Process fresh layout requests, then measure and layout
+				int numValidRequests = validLayoutRequesters.size();
+				for (int i = 0; i < numValidRequests; ++i) {
+					final View view = validLayoutRequesters.get(i);
+					Log.w("View", "requestLayout() improperly called by " + view +
+							" during layout: running second layout pass");
+					view.requestLayout();
+				}
+                // desiredWindowWidth和desiredWindowHeight是屏幕的尺寸
+				measureHierarchy(host, lp, mView.getContext().getResources(),
+						desiredWindowWidth, desiredWindowHeight);
+				mInLayout = true;
+				host.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());
+
+				mHandlingLayoutInLayoutRequest = false;
+
+				// Check the valid requests again, this time without checking/clearing the
+				// layout flags, since requests happening during the second pass get noop'd
+				validLayoutRequesters = getValidLayoutRequesters(mLayoutRequesters, true);
+				if (validLayoutRequesters != null) {
+					final ArrayList<View> finalRequesters = validLayoutRequesters;
+					// Post second-pass requests to the next frame
+					getRunQueue().post(new Runnable() {
+						@Override
+						public void run() {
+							int numValidRequests = finalRequesters.size();
+							for (int i = 0; i < numValidRequests; ++i) {
+								final View view = finalRequesters.get(i);
+								Log.w("View", "requestLayout() improperly called by " + view +
+										" during second layout pass: posting in next frame");
+								view.requestLayout();
+							}
+						}
+					});
+				}
+			}
+
+		}
+	} finally {
+		Trace.traceEnd(Trace.TRACE_TAG_VIEW);
+	}
+	mInLayout = false;
+}
+```
+
+内部会调用`layout()`方法，因为`host`是`mView`，`ViewGroup`中重写了`layout`方法，并调用了`super.layout`.
+所以我们直接看`View.layout()`方法，该方法源码如下： 
+```java
+/**
+ * Assign a size and position to a view and all of its
+ * descendants
+ *
+ * <p>This is the second phase of the layout mechanism.
+ * (The first is measuring). In this phase, each parent calls
+ * layout on all of its children to position them.
+ * This is typically done using the child measurements
+ * that were stored in the measure pass().</p>
+ *
+ * <p>Derived classes should not override this method.
+ * Derived classes with children should override
+ * onLayout. In that method, they should
+ * call layout on each of their children.</p>
+ *
+ * @param l Left position, relative to parent
+ * @param t Top position, relative to parent
+ * @param r Right position, relative to parent
+ * @param b Bottom position, relative to parent
+ */
+@SuppressWarnings({"unchecked"})
+public void layout(int l, int t, int r, int b) {
+	if ((mPrivateFlags3 & PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT) != 0) {
+		onMeasure(mOldWidthMeasureSpec, mOldHeightMeasureSpec);
+		mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
+	}
+
+	int oldL = mLeft;
+	int oldT = mTop;
+	int oldB = mBottom;
+	int oldR = mRight;
+
+	// 这部分是判断这个View的大小是否已经发生了变化，来判断是否需要重绘。
+	boolean changed = isLayoutModeOptical(mParent) ?
+			setOpticalFrame(l, t, r, b) : setFrame(l, t, r, b);
+
+	if (changed || (mPrivateFlags & PFLAG_LAYOUT_REQUIRED) == PFLAG_LAYOUT_REQUIRED) {
+		// 内部调用onLayout方法
+		onLayout(changed, l, t, r, b);
+		mPrivateFlags &= ~PFLAG_LAYOUT_REQUIRED;
+
+		ListenerInfo li = mListenerInfo;
+		if (li != null && li.mOnLayoutChangeListeners != null) {
+			ArrayList<OnLayoutChangeListener> listenersCopy =
+					(ArrayList<OnLayoutChangeListener>)li.mOnLayoutChangeListeners.clone();
+			int numListeners = listenersCopy.size();
+			for (int i = 0; i < numListeners; ++i) {
+				listenersCopy.get(i).onLayoutChange(this, l, t, r, b, oldL, oldT, oldR, oldB);
+			}
+		}
+	}
+
+	mPrivateFlags &= ~PFLAG_FORCE_LAYOUT;
+	mPrivateFlags3 |= PFLAG3_IS_LAID_OUT;
+}
+```
+这里会调用`onLayout`方法，同样因为`mView`是`FrameLayout`的子类，所以我们要看`FrameLayout`的`onLayout`方法，
+这里我们先看一下`ViewGroup.onLayout`方法:
+```java
+/**
+ * {@inheritDoc}
+ */
+@Override
+protected abstract void onLayout(boolean changed,
+		int l, int t, int r, int b);
+```
+是个抽象方法，所以`ViewGroup`的子类都需要实现该方法。
+我们看一下`FrameLayout.onLayout`方法,源码如下：
+```java
+ /**
+ * {@inheritDoc}
+ */
+@Override
+protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
+	layoutChildren(left, top, right, bottom, false /* no force left gravity */);
+}
+
+void layoutChildren(int left, int top, int right, int bottom,
+							  boolean forceLeftGravity) {
+	final int count = getChildCount();
+
+	final int parentLeft = getPaddingLeftWithForeground();
+	final int parentRight = right - left - getPaddingRightWithForeground();
+
+	final int parentTop = getPaddingTopWithForeground();
+	final int parentBottom = bottom - top - getPaddingBottomWithForeground();
+
+	mForegroundBoundsChanged = true;
+	
+	for (int i = 0; i < count; i++) {
+		final View child = getChildAt(i);
+		if (child.getVisibility() != GONE) {
+			final LayoutParams lp = (LayoutParams) child.getLayoutParams();
+
+			final int width = child.getMeasuredWidth();
+			final int height = child.getMeasuredHeight();
+
+			int childLeft;
+			int childTop;
+
+			int gravity = lp.gravity;
+			if (gravity == -1) {
+				gravity = DEFAULT_CHILD_GRAVITY;
+			}
+
+			final int layoutDirection = getLayoutDirection();
+			final int absoluteGravity = Gravity.getAbsoluteGravity(gravity, layoutDirection);
+			final int verticalGravity = gravity & Gravity.VERTICAL_GRAVITY_MASK;
+
+			switch (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) {
+				case Gravity.CENTER_HORIZONTAL:
+					childLeft = parentLeft + (parentRight - parentLeft - width) / 2 +
+					lp.leftMargin - lp.rightMargin;
+					break;
+				case Gravity.RIGHT:
+					if (!forceLeftGravity) {
+						childLeft = parentRight - width - lp.rightMargin;
+						break;
+					}
+				case Gravity.LEFT:
+				default:
+					childLeft = parentLeft + lp.leftMargin;
+			}
+
+			switch (verticalGravity) {
+				case Gravity.TOP:
+					childTop = parentTop + lp.topMargin;
+					break;
+				case Gravity.CENTER_VERTICAL:
+					childTop = parentTop + (parentBottom - parentTop - height) / 2 +
+					lp.topMargin - lp.bottomMargin;
+					break;
+				case Gravity.BOTTOM:
+					childTop = parentBottom - height - lp.bottomMargin;
+					break;
+				default:
+					childTop = parentTop + lp.topMargin;
+			}
+			//调用子View的layout方法
+			child.layout(childLeft, childTop, childLeft + width, childTop + height);
+		}
+	}
+}
+```
+而`View.layout`方法，又会调用到`View.onLayout`方法，我们假设这个子`View`不是`ViewGroup`.
+看一下`View.onLayout`方法源码如下： 
+```java
+/**
+ * Called from layout when this view should
+ * assign a size and position to each of its children.
+ *
+ * Derived classes with children should override
+ * this method and call layout on each of
+ * their children.
+ * @param changed This is a new size or position for this view
+ * @param left Left position, relative to parent
+ * @param top Top position, relative to parent
+ * @param right Right position, relative to parent
+ * @param bottom Bottom position, relative to parent
+ */
+protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
+}
+```
+是一个空方法，这是因为`Layout`需要`ViewGroup`来控制进行。      
+
+这里也总结一下`layout`的过程。
+```java
+private void performLayout(WindowManager.LayoutParams lp, int desiredWindowWidth,
+		int desiredWindowHeight) {
+	- 1. host.layout
+	host.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());
+		-2. layout方法会分别调用setFrame()和onLayout()方法
+			setFrame()
+			onLayout()
+			-3. 因为host是mView也就是DecorView也就是FrameLayout的子类。FrameLayout的onLayout方法如下
+				for (int i = 0; i < count; i++) {
+					final View child = getChildAt(i);
+					if (child.getVisibility() != GONE) {
+					    -4. 遍历每个子View，并分别调用layout方法。
+						child.layout(childLeft, childTop, childLeft + width, childTop + height);
+					}
+				}
+}
+```
+
+`Draw`
+===
+
+
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/view_draw.png)
+
+绘制阶段是从`ViewRootImpl`中的`performDraw`方法开始的：
+
+```java
+private void performDraw() {
+	if (mAttachInfo.mDisplayState == Display.STATE_OFF && !mReportNextDraw) {
+		return;
+	}
+
+	final boolean fullRedrawNeeded = mFullRedrawNeeded;
+	mFullRedrawNeeded = false;
+
+	mIsDrawing = true;
+	Trace.traceBegin(Trace.TRACE_TAG_VIEW, "draw");
+	try {
+		// 开始draw了
+		draw(fullRedrawNeeded);
+	} finally {
+		mIsDrawing = false;
+		Trace.traceEnd(Trace.TRACE_TAG_VIEW);
+	}
+
+	// For whatever reason we didn't create a HardwareRenderer, end any
+	// hardware animations that are now dangling
+	if (mAttachInfo.mPendingAnimatingRenderNodes != null) {
+		final int count = mAttachInfo.mPendingAnimatingRenderNodes.size();
+		for (int i = 0; i < count; i++) {
+			mAttachInfo.mPendingAnimatingRenderNodes.get(i).endAllAnimators();
+		}
+		mAttachInfo.mPendingAnimatingRenderNodes.clear();
+	}
+
+	if (mReportNextDraw) {
+		mReportNextDraw = false;
+		if (mAttachInfo.mHardwareRenderer != null) {
+			mAttachInfo.mHardwareRenderer.fence();
+		}
+
+		if (LOCAL_LOGV) {
+			Log.v(TAG, "FINISHED DRAWING: " + mWindowAttributes.getTitle());
+		}
+		if (mSurfaceHolder != null && mSurface.isValid()) {
+			mSurfaceHolderCallback.surfaceRedrawNeeded(mSurfaceHolder);
+			SurfaceHolder.Callback callbacks[] = mSurfaceHolder.getCallbacks();
+			if (callbacks != null) {
+				for (SurfaceHolder.Callback c : callbacks) {
+					if (c instanceof SurfaceHolder.Callback2) {
+						((SurfaceHolder.Callback2)c).surfaceRedrawNeeded(
+								mSurfaceHolder);
+					}
+				}
+			}
+		}
+		try {
+			mWindowSession.finishDrawing(mWindow);
+		} catch (RemoteException e) {
+		}
+	}
+}
+```
+内部会调用`draw`方法，`draw`方法源码如下：
+```java
+private void draw(boolean fullRedrawNeeded) {
+	Surface surface = mSurface;
+    // 首先检查surface是否有效，正常情况下都是有效的，除非WmS发生异常不能为该客户端分配有效的Surface
+	if (!surface.isValid()) {
+		return;
+	}
+
+	if (DEBUG_FPS) {
+		trackFPS();
+	}
+
+	if (!sFirstDrawComplete) {
+		synchronized (sFirstDrawHandlers) {
+			sFirstDrawComplete = true;
+			final int count = sFirstDrawHandlers.size();
+			for (int i = 0; i< count; i++) {
+				mHandler.post(sFirstDrawHandlers.get(i));
+			}
+		}
+	}
+
+	scrollToRectOrFocus(null, false);
+
+	if (mAttachInfo.mViewScrollChanged) {
+		mAttachInfo.mViewScrollChanged = false;
+		mAttachInfo.mTreeObserver.dispatchOnScrollChanged();
+	}
+
+	boolean animating = mScroller != null && mScroller.computeScrollOffset();
+	final int curScrollY;
+	if (animating) {
+		curScrollY = mScroller.getCurrY();
+	} else {
+		curScrollY = mScrollY;
+	}
+	if (mCurScrollY != curScrollY) {
+		mCurScrollY = curScrollY;
+		fullRedrawNeeded = true;
+	}
+
+	final float appScale = mAttachInfo.mApplicationScale;
+	final boolean scalingRequired = mAttachInfo.mScalingRequired;
+
+	int resizeAlpha = 0;
+	if (mResizeBuffer != null) {
+		long deltaTime = SystemClock.uptimeMillis() - mResizeBufferStartTime;
+		if (deltaTime < mResizeBufferDuration) {
+			float amt = deltaTime/(float) mResizeBufferDuration;
+			amt = mResizeInterpolator.getInterpolation(amt);
+			animating = true;
+			resizeAlpha = 255 - (int)(amt*255);
+		} else {
+			disposeResizeBuffer();
+		}
+	}
+
+	final Rect dirty = mDirty;
+    // 判断该Surface是否有SurfaceHolder对象，如果有则意味着该Surface是应用程序创建的，因为所有的绘制操作应该由应用程序
+    // 自身去负责，于是View系统推出绘制，如果不是，才开始View绘制的内部流程。
+	if (mSurfaceHolder != null) {
+		// The app owns the surface, we won't draw.
+		dirty.setEmpty();
+		if (animating) {
+			if (mScroller != null) {
+				mScroller.abortAnimation();
+			}
+			disposeResizeBuffer();
+		}
+		return;
+	}
+
+	if (fullRedrawNeeded) {
+		mAttachInfo.mIgnoreDirtyState = true;
+		dirty.set(0, 0, (int) (mWidth * appScale + 0.5f), (int) (mHeight * appScale + 0.5f));
+	}
+
+	if (DEBUG_ORIENTATION || DEBUG_DRAW) {
+		Log.v(TAG, "Draw " + mView + "/"
+				+ mWindowAttributes.getTitle()
+				+ ": dirty={" + dirty.left + "," + dirty.top
+				+ "," + dirty.right + "," + dirty.bottom + "} surface="
+				+ surface + " surface.isValid()=" + surface.isValid() + ", appScale:" +
+				appScale + ", width=" + mWidth + ", height=" + mHeight);
+	}
+
+	mAttachInfo.mTreeObserver.dispatchOnDraw();
+
+	int xOffset = 0;
+	int yOffset = curScrollY;
+	final WindowManager.LayoutParams params = mWindowAttributes;
+	final Rect surfaceInsets = params != null ? params.surfaceInsets : null;
+	if (surfaceInsets != null) {
+		xOffset -= surfaceInsets.left;
+		yOffset -= surfaceInsets.top;
+
+		// Offset dirty rect for surface insets.
+		dirty.offset(surfaceInsets.left, surfaceInsets.right);
+	}
+
+	if (!dirty.isEmpty() || mIsAnimating) {
+        // Surface的底层驱动模式分为两种，一种是使用图形加速支持的Surface，俗称显卡，另一种是使用CPU及内存模拟的Surface。
+        // 因此这里需要根据不同的模式，进行不同的操作
+		if (mAttachInfo.mHardwareRenderer != null && mAttachInfo.mHardwareRenderer.isEnabled()) {
+            // 硬件绘制
+			// Draw with hardware renderer.
+			mIsAnimating = false;
+			boolean invalidateRoot = false;
+			if (mHardwareYOffset != yOffset || mHardwareXOffset != xOffset) {
+				mHardwareYOffset = yOffset;
+				mHardwareXOffset = xOffset;
+				mAttachInfo.mHardwareRenderer.invalidateRoot();
+			}
+			mResizeAlpha = resizeAlpha;
+
+			dirty.setEmpty();
+
+			mBlockResizeBuffer = false;
+			mAttachInfo.mHardwareRenderer.draw(mView, mAttachInfo, this);
+		} else {
+			// If we get here with a disabled & requested hardware renderer, something went
+			// wrong (an invalidate posted right before we destroyed the hardware surface
+			// for instance) so we should just bail out. Locking the surface with software
+			// rendering at this point would lock it forever and prevent hardware renderer
+			// from doing its job when it comes back.
+			// Before we request a new frame we must however attempt to reinitiliaze the
+			// hardware renderer if it's in requested state. This would happen after an
+			// eglTerminate() for instance.
+			if (mAttachInfo.mHardwareRenderer != null &&
+					!mAttachInfo.mHardwareRenderer.isEnabled() &&
+					mAttachInfo.mHardwareRenderer.isRequested()) {
+
+				try {
+					mAttachInfo.mHardwareRenderer.initializeIfNeeded(
+							mWidth, mHeight, mSurface, surfaceInsets);
+				} catch (OutOfResourcesException e) {
+					handleOutOfResourcesException(e);
+					return;
+				}
+
+				mFullRedrawNeeded = true;
+				scheduleTraversals();
+				return;
+			}
+			
+			// 软件绘制
+			if (!drawSoftware(surface, mAttachInfo, xOffset, yOffset, scalingRequired, dirty)) {
+				return;
+			}
+		}
+	}
+
+	if (animating) {
+		mFullRedrawNeeded = true;
+        // 动画就是让画面动起来，如果正在动画过程中，则需要再次发起一个重绘命令，以便接着绘制，直到滚动结束。
+		scheduleTraversals();
+	}
+}
+```
+我们看一下`drawSoftware`方法： 
+```java
+/**
+ * 使用CPU的软件绘制方式
+ * @return true if drawing was successful, false if an error occurred
+ */
+private boolean drawSoftware(Surface surface, AttachInfo attachInfo, int xoff, int yoff,
+		boolean scalingRequired, Rect dirty) {
+
+	// Draw with software renderer.
+	final Canvas canvas;
+	try {
+		final int left = dirty.left;
+		final int top = dirty.top;
+		final int right = dirty.right;
+		final int bottom = dirty.bottom;
+
+		canvas = mSurface.lockCanvas(dirty);
+
+		// The dirty rectangle can be modified by Surface.lockCanvas()
+		//noinspection ConstantConditions
+		if (left != dirty.left || top != dirty.top || right != dirty.right
+				|| bottom != dirty.bottom) {
+			attachInfo.mIgnoreDirtyState = true;
+		}
+
+		// TODO: Do this in native
+		canvas.setDensity(mDensity);
+	} catch (Surface.OutOfResourcesException e) {
+		handleOutOfResourcesException(e);
+		return false;
+	} catch (IllegalArgumentException e) {
+		Log.e(TAG, "Could not lock surface", e);
+		// Don't assume this is due to out of memory, it could be
+		// something else, and if it is something else then we could
+		// kill stuff (or ourself) for no reason.
+		mLayoutRequested = true;    // ask wm for a new surface next time.
+		return false;
+	}
+
+	try {
+		if (DEBUG_ORIENTATION || DEBUG_DRAW) {
+			Log.v(TAG, "Surface " + surface + " drawing to bitmap w="
+					+ canvas.getWidth() + ", h=" + canvas.getHeight());
+			//canvas.drawARGB(255, 255, 0, 0);
+		}
+
+		// If this bitmap's format includes an alpha channel, we
+		// need to clear it before drawing so that the child will
+		// properly re-composite its drawing on a transparent
+		// background. This automatically respects the clip/dirty region
+		// or
+		// If we are applying an offset, we need to clear the area
+		// where the offset doesn't appear to avoid having garbage
+		// left in the blank areas.
+		if (!canvas.isOpaque() || yoff != 0 || xoff != 0) {
+			canvas.drawColor(0, PorterDuff.Mode.CLEAR);
+		}
+
+		dirty.setEmpty();
+		mIsAnimating = false;
+		attachInfo.mDrawingTime = SystemClock.uptimeMillis();
+		mView.mPrivateFlags |= View.PFLAG_DRAWN;
+
+		if (DEBUG_DRAW) {
+			Context cxt = mView.getContext();
+			Log.i(TAG, "Drawing: package:" + cxt.getPackageName() +
+					", metrics=" + cxt.getResources().getDisplayMetrics() +
+					", compatibilityInfo=" + cxt.getResources().getCompatibilityInfo());
+		}
+		try {
+			canvas.translate(-xoff, -yoff);
+			if (mTranslator != null) {
+				mTranslator.translateCanvas(canvas);
+			}
+			canvas.setScreenDensity(scalingRequired ? mNoncompatDensity : 0);
+			attachInfo.mSetIgnoreDirtyState = false;
+			
+			// 内部会去调用View.draw()；
+			mView.draw(canvas);
+		} finally {
+			if (!attachInfo.mSetIgnoreDirtyState) {
+				// Only clear the flag if it was not set during the mView.draw() call
+				attachInfo.mIgnoreDirtyState = false;
+			}
+		}
+	} finally {
+		try {
+			surface.unlockCanvasAndPost(canvas);
+		} catch (IllegalArgumentException e) {
+			Log.e(TAG, "Could not unlock surface", e);
+			mLayoutRequested = true;    // ask wm for a new surface next time.
+			//noinspection ReturnInsideFinallyBlock
+			return false;
+		}
+
+		if (LOCAL_LOGV) {
+			Log.v(TAG, "Surface " + surface + " unlockCanvasAndPost");
+		}
+	}
+	return true;
+}
+```
+代码中调用了`mView.draw()`方法，所以我们看一下`FrameLayout.draw()`方法：
+```java
+/**
+ * {@inheritDoc}
+ */
+@Override
+public void draw(Canvas canvas) {
+	super.draw(canvas);
+
+	if (mForeground != null) {
+		final Drawable foreground = mForeground;
+
+		if (mForegroundBoundsChanged) {
+			mForegroundBoundsChanged = false;
+			final Rect selfBounds = mSelfBounds;
+			final Rect overlayBounds = mOverlayBounds;
+
+			final int w = mRight-mLeft;
+			final int h = mBottom-mTop;
+
+			if (mForegroundInPadding) {
+				selfBounds.set(0, 0, w, h);
+			} else {
+				selfBounds.set(mPaddingLeft, mPaddingTop, w - mPaddingRight, h - mPaddingBottom);
+			}
+
+			final int layoutDirection = getLayoutDirection();
+			Gravity.apply(mForegroundGravity, foreground.getIntrinsicWidth(),
+					foreground.getIntrinsicHeight(), selfBounds, overlayBounds,
+					layoutDirection);
+			foreground.setBounds(overlayBounds);
+		}
+		
+		foreground.draw(canvas);
+	}
+}
+```
+内部调用了`super.draw()`，而`ViewGroup`没有重写该方法，所以直接看`View`的`draw()`方法.
+`View.draw()`方法如下：
+```java
+/**
+ * Manually render this view (and all of its children) to the given Canvas.
+ * The view must have already done a full layout before this function is
+ * called.  When implementing a view, implement
+ * {@link #onDraw(android.graphics.Canvas)} instead of overriding this method.
+ * If you do need to override this method, call the superclass version.
+ *
+ * @param canvas The Canvas to which the View is rendered.
+ */
+public void draw(Canvas canvas) {
+	final int privateFlags = mPrivateFlags;
+	final boolean dirtyOpaque = (privateFlags & PFLAG_DIRTY_MASK) == PFLAG_DIRTY_OPAQUE &&
+			(mAttachInfo == null || !mAttachInfo.mIgnoreDirtyState);
+	mPrivateFlags = (privateFlags & ~PFLAG_DIRTY_MASK) | PFLAG_DRAWN;
+
+	// 这里注释说的很明白了，draw的6个步骤。
+	/*
+	 * Draw traversal performs several drawing steps which must be executed
+	 * in the appropriate order:
+	 *
+	 *      1. Draw the background
+	 *      2. If necessary, save the canvas' layers to prepare for fading
+	 *      3. Draw view's content, 调用onDraw方法绘制自身
+	 *      4. Draw children, 调用dispatchDraw方法绘制子View
+	 *      5. If necessary, draw the fading edges and restore layers
+	 *      6. Draw decorations (scrollbars for instance)
+	 */
+
+	// Step 1, draw the background, if needed
+	int saveCount;
+
+	if (!dirtyOpaque) {
+		drawBackground(canvas);
+	}
+
+	// skip step 2 & 5 if possible (common case)
+	final int viewFlags = mViewFlags;
+	boolean horizontalEdges = (viewFlags & FADING_EDGE_HORIZONTAL) != 0;
+	boolean verticalEdges = (viewFlags & FADING_EDGE_VERTICAL) != 0;
+	if (!verticalEdges && !horizontalEdges) {
+		// Step 3, draw the content
+		if (!dirtyOpaque) onDraw(canvas);
+
+		// Step 4, draw the children
+		dispatchDraw(canvas);
+
+		// Step 6, draw decorations (scrollbars)
+		onDrawScrollBars(canvas);
+
+		if (mOverlay != null && !mOverlay.isEmpty()) {
+			mOverlay.getOverlayView().dispatchDraw(canvas);
+		}
+
+		// we're done...
+		return;
+	}
+
+	/*
+	 * Here we do the full fledged routine...
+	 * (this is an uncommon case where speed matters less,
+	 * this is why we repeat some of the tests that have been
+	 * done above)
+	 */
+
+	boolean drawTop = false;
+	boolean drawBottom = false;
+	boolean drawLeft = false;
+	boolean drawRight = false;
+
+	float topFadeStrength = 0.0f;
+	float bottomFadeStrength = 0.0f;
+	float leftFadeStrength = 0.0f;
+	float rightFadeStrength = 0.0f;
+
+	// Step 2, save the canvas' layers
+	int paddingLeft = mPaddingLeft;
+
+	final boolean offsetRequired = isPaddingOffsetRequired();
+	if (offsetRequired) {
+		paddingLeft += getLeftPaddingOffset();
+	}
+
+	int left = mScrollX + paddingLeft;
+	int right = left + mRight - mLeft - mPaddingRight - paddingLeft;
+	int top = mScrollY + getFadeTop(offsetRequired);
+	int bottom = top + getFadeHeight(offsetRequired);
+
+	if (offsetRequired) {
+		right += getRightPaddingOffset();
+		bottom += getBottomPaddingOffset();
+	}
+
+	final ScrollabilityCache scrollabilityCache = mScrollCache;
+	final float fadeHeight = scrollabilityCache.fadingEdgeLength;
+	int length = (int) fadeHeight;
+
+	// clip the fade length if top and bottom fades overlap
+	// overlapping fades produce odd-looking artifacts
+	if (verticalEdges && (top + length > bottom - length)) {
+		length = (bottom - top) / 2;
+	}
+
+	// also clip horizontal fades if necessary
+	if (horizontalEdges && (left + length > right - length)) {
+		length = (right - left) / 2;
+	}
+
+	if (verticalEdges) {
+		topFadeStrength = Math.max(0.0f, Math.min(1.0f, getTopFadingEdgeStrength()));
+		drawTop = topFadeStrength * fadeHeight > 1.0f;
+		bottomFadeStrength = Math.max(0.0f, Math.min(1.0f, getBottomFadingEdgeStrength()));
+		drawBottom = bottomFadeStrength * fadeHeight > 1.0f;
+	}
+
+	if (horizontalEdges) {
+		leftFadeStrength = Math.max(0.0f, Math.min(1.0f, getLeftFadingEdgeStrength()));
+		drawLeft = leftFadeStrength * fadeHeight > 1.0f;
+		rightFadeStrength = Math.max(0.0f, Math.min(1.0f, getRightFadingEdgeStrength()));
+		drawRight = rightFadeStrength * fadeHeight > 1.0f;
+	}
+
+	saveCount = canvas.getSaveCount();
+
+	int solidColor = getSolidColor();
+	if (solidColor == 0) {
+		final int flags = Canvas.HAS_ALPHA_LAYER_SAVE_FLAG;
+
+		if (drawTop) {
+			canvas.saveLayer(left, top, right, top + length, null, flags);
+		}
+
+		if (drawBottom) {
+			canvas.saveLayer(left, bottom - length, right, bottom, null, flags);
+		}
+
+		if (drawLeft) {
+			canvas.saveLayer(left, top, left + length, bottom, null, flags);
+		}
+
+		if (drawRight) {
+			canvas.saveLayer(right - length, top, right, bottom, null, flags);
+		}
+	} else {
+		scrollabilityCache.setFadeColor(solidColor);
+	}
+
+	// Step 3, draw the content
+	if (!dirtyOpaque) onDraw(canvas);
+
+	// Step 4, draw the children
+	dispatchDraw(canvas);
+
+	// Step 5, draw the fade effect and restore layers
+	final Paint p = scrollabilityCache.paint;
+	final Matrix matrix = scrollabilityCache.matrix;
+	final Shader fade = scrollabilityCache.shader;
+
+	if (drawTop) {
+		matrix.setScale(1, fadeHeight * topFadeStrength);
+		matrix.postTranslate(left, top);
+		fade.setLocalMatrix(matrix);
+		p.setShader(fade);
+		canvas.drawRect(left, top, right, top + length, p);
+	}
+
+	if (drawBottom) {
+		matrix.setScale(1, fadeHeight * bottomFadeStrength);
+		matrix.postRotate(180);
+		matrix.postTranslate(left, bottom);
+		fade.setLocalMatrix(matrix);
+		p.setShader(fade);
+		canvas.drawRect(left, bottom - length, right, bottom, p);
+	}
+
+	if (drawLeft) {
+		matrix.setScale(1, fadeHeight * leftFadeStrength);
+		matrix.postRotate(-90);
+		matrix.postTranslate(left, top);
+		fade.setLocalMatrix(matrix);
+		p.setShader(fade);
+		canvas.drawRect(left, top, left + length, bottom, p);
+	}
+
+	if (drawRight) {
+		matrix.setScale(1, fadeHeight * rightFadeStrength);
+		matrix.postRotate(90);
+		matrix.postTranslate(right, top);
+		fade.setLocalMatrix(matrix);
+		p.setShader(fade);
+		canvas.drawRect(right - length, top, right, bottom, p);
+	}
+
+	canvas.restoreToCount(saveCount);
+
+	// Step 6, draw decorations (scrollbars)
+	onDrawScrollBars(canvas);
+
+	if (mOverlay != null && !mOverlay.isEmpty()) {
+		mOverlay.getOverlayView().dispatchDraw(canvas);
+	}
+}
+```
+
+上面会调用`onDraw`和`dispatchDraw`方法。
+我们先看一下`View.onDraw`方法：
+```java
+/**
+ * Implement this to do your drawing.
+ *
+ * @param canvas the canvas on which the background will be drawn
+ */
+protected void onDraw(Canvas canvas) {
+}
+```
+是空方法，这是也很好理解，因为每个`View`的展现都不一样，例如`TextView`、`ProgressBar`等，
+所以`View`不会去实现`onDraw`方法，具体是要子类去根据自己的显示要求实现该方法。
+
+再看一下`dispatchDraw`方法，这个方法是用来绘制子`View`的，所以要看`ViewGroup.dispatchDraw`方法，`View.dispatchDraw`是空的。 
+```java
+/**
+ * {@inheritDoc}
+ */
+@Override
+protected void dispatchDraw(Canvas canvas) {
+	boolean usingRenderNodeProperties = canvas.isRecordingFor(mRenderNode);
+	final int childrenCount = mChildrenCount;
+	final View[] children = mChildren;
+	int flags = mGroupFlags;
+
+	if ((flags & FLAG_RUN_ANIMATION) != 0 && canAnimate()) {
+		final boolean cache = (mGroupFlags & FLAG_ANIMATION_CACHE) == FLAG_ANIMATION_CACHE;
+
+		final boolean buildCache = !isHardwareAccelerated();
+		for (int i = 0; i < childrenCount; i++) {
+			final View child = children[i];
+			if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE) {
+				final LayoutParams params = child.getLayoutParams();
+				attachLayoutAnimationParameters(child, params, i, childrenCount);
+				bindLayoutAnimation(child);
+				if (cache) {
+					child.setDrawingCacheEnabled(true);
+					if (buildCache) {
+						child.buildDrawingCache(true);
+					}
+				}
+			}
+		}
+
+		final LayoutAnimationController controller = mLayoutAnimationController;
+		if (controller.willOverlap()) {
+			mGroupFlags |= FLAG_OPTIMIZE_INVALIDATE;
+		}
+
+		controller.start();
+
+		mGroupFlags &= ~FLAG_RUN_ANIMATION;
+		mGroupFlags &= ~FLAG_ANIMATION_DONE;
+
+		if (cache) {
+			mGroupFlags |= FLAG_CHILDREN_DRAWN_WITH_CACHE;
+		}
+
+		if (mAnimationListener != null) {
+			mAnimationListener.onAnimationStart(controller.getAnimation());
+		}
+	}
+
+	int clipSaveCount = 0;
+	final boolean clipToPadding = (flags & CLIP_TO_PADDING_MASK) == CLIP_TO_PADDING_MASK;
+	if (clipToPadding) {
+		clipSaveCount = canvas.save();
+		canvas.clipRect(mScrollX + mPaddingLeft, mScrollY + mPaddingTop,
+				mScrollX + mRight - mLeft - mPaddingRight,
+				mScrollY + mBottom - mTop - mPaddingBottom);
+	}
+
+	// We will draw our child's animation, let's reset the flag
+	mPrivateFlags &= ~PFLAG_DRAW_ANIMATION;
+	mGroupFlags &= ~FLAG_INVALIDATE_REQUIRED;
+
+	boolean more = false;
+	final long drawingTime = getDrawingTime();
+
+	if (usingRenderNodeProperties) canvas.insertReorderBarrier();
+	// Only use the preordered list if not HW accelerated, since the HW pipeline will do the
+	// draw reordering internally
+	final ArrayList<View> preorderedList = usingRenderNodeProperties
+			? null : buildOrderedChildList();
+	final boolean customOrder = preorderedList == null
+			&& isChildrenDrawingOrderEnabled();
+	for (int i = 0; i < childrenCount; i++) {
+		int childIndex = customOrder ? getChildDrawingOrder(childrenCount, i) : i;
+		final View child = (preorderedList == null)
+				? children[childIndex] : preorderedList.get(childIndex);
+		if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null) {
+			// 调用drawChild方法
+			more |= drawChild(canvas, child, drawingTime);
+		}
+	}
+	if (preorderedList != null) preorderedList.clear();
+
+	// Draw any disappearing views that have animations
+	if (mDisappearingChildren != null) {
+		final ArrayList<View> disappearingChildren = mDisappearingChildren;
+		final int disappearingCount = disappearingChildren.size() - 1;
+		// Go backwards -- we may delete as animations finish
+		for (int i = disappearingCount; i >= 0; i--) {
+			final View child = disappearingChildren.get(i);
+			more |= drawChild(canvas, child, drawingTime);
+		}
+	}
+	if (usingRenderNodeProperties) canvas.insertInorderBarrier();
+
+	if (debugDraw()) {
+		onDebugDraw(canvas);
+	}
+
+	if (clipToPadding) {
+		canvas.restoreToCount(clipSaveCount);
+	}
+
+	// mGroupFlags might have been updated by drawChild()
+	flags = mGroupFlags;
+
+	if ((flags & FLAG_INVALIDATE_REQUIRED) == FLAG_INVALIDATE_REQUIRED) {
+		invalidate(true);
+	}
+
+	if ((flags & FLAG_ANIMATION_DONE) == 0 && (flags & FLAG_NOTIFY_ANIMATION_LISTENER) == 0 &&
+			mLayoutAnimationController.isDone() && !more) {
+		// We want to erase the drawing cache and notify the listener after the
+		// next frame is drawn because one extra invalidate() is caused by
+		// drawChild() after the animation is over
+		mGroupFlags |= FLAG_NOTIFY_ANIMATION_LISTENER;
+		final Runnable end = new Runnable() {
+		   public void run() {
+			   notifyAnimationListener();
+		   }
+		};
+		post(end);
+	}
+}
+```
+可以看到上面的方法中会调用`drawChild`方法，该方法如下： 
+```java
+/**
+ * Draw one child of this View Group. This method is responsible for getting
+ * the canvas in the right state. This includes clipping, translating so
+ * that the child's scrolled origin is at 0, 0, and applying any animation
+ * transformations.
+ *
+ * @param canvas The canvas on which to draw the child
+ * @param child Who to draw
+ * @param drawingTime The time at which draw is occurring
+ * @return True if an invalidate() was issued
+ */
+protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
+	return child.draw(canvas, this, drawingTime);
+}
+```
+
+这里也简单总结一下`draw`的过程：
+```java
+// 1. ViewRootImpl.performDraw()
+private void performDraw() {
+	// 2. ViewRootImpl.draw()
+	draw(fullRedrawNeeded);	
+		// 3. ViewRootImpl.drawSoftware
+		drawSoftware
+			// 4. 内部调用mView.draw,也就是FrameLayout.draw(). 
+			mView.draw()(FrameLayout)
+				// 5. FrameLayout.draw方法内部会调用super.draw方法，也就是View.draw方法.
+				super.draw(canvas);
+					// 6. View.draw方法内部会分别调用onDraw绘制自己以及dispatchDraw绘制子View.
+					onDraw
+					// 绘制子View
+					dispatchDraw
+						// 7. dispatchDraw方法内部会遍历所有子View.
+						for (int i = 0; i < childrenCount; i++) {
+							// 8. 对每个子View分别调用drawChild方法
+							drawChild()
+								// 9. drawChild方法内部会对该子View调用draw方法，进行绘制。然后draw又会调用onDraw等，循环就开始了。 
+									child.draw()
+						}
+}
+```
+
+最后补充一个小问题： `getWidth()`与`getMeasuredWidth()`有什么区别呢？                          
+一般情况下这两个的值是相同的，`getMeasureWidth()`方法在`measure()`过程结束后就可以获取到了，而`getWidth()`方法要在`layout()`过程结束后才能获取到。
+而且`getMeasureWidth()`的值是通过`setMeasuredDimension()`设置的，但是`getWidth()`的值是通过视图右边的坐标减去左边的坐标计算出来的。如果我们在`layout`的时候将宽高
+不传`getMeasureWidth`的值，那么这时候`getWidth()`与`getMeasuredWidth`的值就不会再相同了，当然一般也不会这么干...
+
+# MeasureSpec
+
+MeasureSpec是View类的一个静态内部类，用来说明如何测量这个类。MeasureSpec表示的是一个32位的整型值，它的高2位表示测量模式SpecMode，低30位表示某种测量模式下的规格大小SpecSize。MeasureSpec通过将SpecMode和SpecSize打包成一个int值来避免过多的内存分配。
+
+---
+
+- [上一篇:6.屏幕绘制基础](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/AndroidKernal/6.%E5%B1%8F%E5%B9%95%E7%BB%98%E5%88%B6%E5%9F%BA%E7%A1%80.md)
+- [下一篇:8.WindowManagerService简介](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/AndroidKernal/8.WindowManagerService%E7%AE%80%E4%BB%8B.md)
 
 
 
diff --git "a/OperatingSystem/AndroidKernal/8.WindowManagerService\347\256\200\344\273\213.md" "b/OperatingSystem/AndroidKernal/8.WindowManagerService\347\256\200\344\273\213.md"
index 7fa274dc..cb3820e1 100644
--- "a/OperatingSystem/AndroidKernal/8.WindowManagerService\347\256\200\344\273\213.md"
+++ "b/OperatingSystem/AndroidKernal/8.WindowManagerService\347\256\200\344\273\213.md"
@@ -1,7 +1,7 @@
 # 8.WindowManagerService简介
 
 
-WmS是Android中图形用户接口的引擎，它管理者所有窗口，包括创建、删除窗口以及将某个窗口设置为焦点等。
+WmS是Android中图形用户接口的引擎，它管理着所有窗口，包括创建、删除窗口以及将某个窗口设置为焦点等。
 
 在WmS中，窗口是由两部分内容构成: 
 
@@ -63,7 +63,7 @@ WmS接口结构是指WmS功能模块与其他模块之间的交互接口，其
 
 ### Session
 
-和SurfaceFlinger直接打交道的类本来是SurfaceSession。当应用程序需要创建Surface时，会请求WmS去完成创建的工作，WmS回味每一个应用程序分配一个SurfaceSession对象。然而一个surfaceSession对象不足以表示一个客户端，因此，WmS定义了Session类，它可被认为是SurfaceSession的一个包装。Session对象是当应用程序调用WmS的openSession()函数时创建的，而应用程序又是在ViewRoot类中调用openSession的。
+和SurfaceFlinger直接打交道的类本来是SurfaceSession。当应用程序需要创建Surface时，会请求WmS去完成创建的工作，WmS会为每一个应用程序分配一个SurfaceSession对象。然而一个surfaceSession对象不足以表示一个客户端，因此，WmS定义了Session类，它可被认为是SurfaceSession的一个包装。Session对象是当应用程序调用WmS的openSession()函数时创建的，而应用程序又是在ViewRoot类中调用openSession的。
 
 
 
@@ -122,6 +122,11 @@ Surface的销毁有两种情况:
 
 
 
+---
+
+- [上一篇:7.View绘制原理](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/AndroidKernal/7.View%E7%BB%98%E5%88%B6%E5%8E%9F%E7%90%86.md)
+- [下一篇:9.PackageManagerService简介](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/AndroidKernal/9.PackageManagerService%E7%AE%80%E4%BB%8B.md)
+
 
 
 
diff --git "a/OperatingSystem/AndroidKernal/9.PackageManagerService\347\256\200\344\273\213.md" "b/OperatingSystem/AndroidKernal/9.PackageManagerService\347\256\200\344\273\213.md"
index 803a99df..83a469b5 100644
--- "a/OperatingSystem/AndroidKernal/9.PackageManagerService\347\256\200\344\273\213.md"
+++ "b/OperatingSystem/AndroidKernal/9.PackageManagerService\347\256\200\344\273\213.md"
@@ -20,7 +20,7 @@
 
     和AmS、WmS等其他系统服务一样，包管理服务运行于SystemServer进程。PmS服务运行时，使用了两个目录下的XML文件保存相关的包管理信息。
 
-    - 第一个目录是system/etc/permissions：该目录下的所有xml文件用于permission的管理，具体包含两件时间。第一个是定义系统中都包含了哪些feature，应用程序可以在AndroidManifest.xml中使用use-feature标签声明程序都需要哪些feature。
+    - 第一个目录是system/etc/permissions：该目录下的所有xml文件用于permission的管理，具体包含两个事件。第一个是定义系统中都包含了哪些feature，应用程序可以在AndroidManifest.xml中使用use-feature标签声明程序都需要哪些feature。
     - 第二个目录是/data/system/packages.xml，该文件保存了所有安装程序的基本包信息，有点像系统的注册表，比如程序的包名称是什么，安装包路径在哪里，程序都是用了哪些系统权限。
 
     PmS在启动时，会从这两个目录中解析相关的XML文件，从而建立一个庞大的包信息树，应用程序可以间接从这个信息树中查询所有所需的程序包信息。
@@ -58,6 +58,14 @@
 
 
 
+
+---
+
+- [上一篇:8.WindowManagerService简介](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/AndroidKernal/8.WindowManagerService%E7%AE%80%E4%BB%8B.md)
+
+
+
+
 ---
 
 - 邮箱 ：charon.chui@gmail.com  

From ddd5aaecaf8526f0fd3ab3c02a128b19b2a41a5c Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 9 Dec 2020 20:26:16 +0800
Subject: [PATCH 041/213] add files

---
 ...73\347\273\237\347\256\200\344\273\213.md" |   8 +-
 ...13\344\270\216\347\272\277\347\250\213.md" |   4 +
 ...13\351\227\264\351\200\232\344\277\241.md" | 283 ++++++++++++++----
 ...roid Framework\346\241\206\346\236\266.md" |  17 +-
 ...72\347\241\200\347\237\245\350\257\206.md" |   2 +-
 5 files changed, 257 insertions(+), 57 deletions(-)
 rename "VideoDevelopment/\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md" => "VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md" (97%)

diff --git "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md" "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
index 4e34b27f..82ba0f2a 100644
--- "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
+++ "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
@@ -134,7 +134,7 @@
 
 目前的Android系统大多运行在ARM处理器之上。ARM本身是一个公司的名称，从技术的角度来看，它又是一种微处理器内核的架构。
 
-对于ARM处理器，当复位完毕后，处理器首先还行其片上ROM中的一小块程序。这块ROM的大小一般只有几KB，改段程序就是Bootloader程序，这段程序执行时会根据处理器上一些特定引脚的高低电平状态，选择从何种物理接口上装载用户程序，比如USB口、SD卡、并口Flash等。
+对于ARM处理器，当复位完毕后，处理器首先还行其片上ROM中的一小块程序。这块ROM的大小一般只有几KB，该段程序就是Bootloader程序，这段程序执行时会根据处理器上一些特定引脚的高低电平状态，选择从何种物理接口上装载用户程序，比如USB口、SD卡、并口Flash等。
 
 多数基于ARM的实际硬件系统，会从并口NAND Flash芯片上的0x00000000地址处装载程序。对于一些小型嵌入式系统而言，该地址中的程序就是最终要执行的用户程序；而对于Android而言，该地址中的程序还不是Android程序，而是一个叫做uboot或者fastboot的程序，其作用是初始化硬件设备，比如网口、SDRAM、RS232等，并提供一些调试功能，比如向NAND Flash中写入新的数据，这可用于开发过程中的内核烧写、升级等。
 
@@ -146,6 +146,12 @@ Linux内核被装载后，就开始进行内核初始化的过程。
 
 
 
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_system_start.png)
+
+
+
+
+
 ## CPU(Central Processing Unit)
 
 CPU(中央处理器)是计算机的大脑，它主要和内存进行交互，从内存中提取指令并执行它。它是一块超大规模的集成电路(Integrated Circuit)，是信息处理、程序运行的最终执行单元。其功能主要是解释计算机指令以及处理计算机软件中的数据。由于访问内存获取执行或数据要比执行指令花费的时间长，因此所有的 CPU 内部都会包含一些寄存器来保存关键变量和临时结果。因此，在指令集中通常会有一些指令用于把关键字从内存中加载到寄存器中，以及把关键字从寄存器存入到内存中。从功能方面来看，CPU的内部主要由寄存器，控制器，运算器构成，各部分之间由电流信号相互连通。其中运算器负责算术运算和逻辑运算，控制器负责计算指令的解析，产生各种控制指令，寄存器组用来临时存放参加运算的数据和计算的中间结果。CPU计算结果最终需要写到内存中，内存的存取速度远低于CPU，为提升数据交换速率，CPU内部一般还集成了高速缓存（CACHE）,其中缓存分为一级缓存和二级缓存，一级缓存和CPU速率相当，二级缓存次之。
diff --git "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md" "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
index 3f5369e6..8dd5f952 100644
--- "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
+++ "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
@@ -324,7 +324,11 @@ Linux为进程间通信和同步提供了各种机制。这里只是几种。
 
 应用程序通过调用操作系统提供的库与操作系统进行交互，这些库合起来构成Android框架（Android framework）。这些库中有一些可以在进程内部执行其工作，但是许多库需要与其他进程执行进程间通信，作者通常是在system_server进程中提供服务的。
 
+### ServiceManager
 
+Android Binder的管理服务。
+
+对于Binder驱动而言，**ServiceManager是一个守护进程，更是Android系统各个服务的管理者**。Android系统中的各个服务，都是添加到ServiceManager中进行管理的，而且每个服务都对应一个服务名。当Client获取某个服务时，则通过服务名来从ServiceManager中获取相应的服务。
 
 ### Zygote
 
diff --git "a/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md" "b/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md"
index 7263e837..2f089353 100644
--- "a/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md"
+++ "b/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md"
@@ -1,26 +1,52 @@
 # 1.Android进程间通信
 
+
+
 ## Binder简介
 
 Binder，英文的意思是别针、回形针。我们经常用别针把两张纸”别“在一起，而在Android中，Binder用于完成进程间通信（IPC），即把多个进程”别“在一起。比如，普通应用程序可以调用音乐播放服务提供的播放、暂停、停止等功能。Binder工作在Linux层面，属于一个驱动，只是这个驱动不需要硬件，或者说其操作的硬件是基于一小段内存。从线程的角度来讲，Binder驱动代码运行在内核态，客户端程序调用Binder是通过系统调用完成的。
 
 
 
-## Linux进程间通信
+## 进程间通信
 
 无论是Android系统，还是各种Linux衍生系统，各个组件、模块往往运行在各种不同的进程和线程内，这里就必然涉及进程/线程之间的通信。对于IPC(Inter-Process Communication,  进程间通信)，Linux目前有一下这些IPC机制: 
 
--  管道：在创建时分配一个page大小的内存，缓存区大小比较有限；
-- 消息队列：信息会复制两次，会有额外的CPU消耗；不合适频繁或信息量大的通信；
-- 共享内存：无须复制，共享缓冲区直接附加到进程虚拟地址空间，速度快；但进程间的同步问题操作系统无法实现，必须各进程利用同步工具解决；
-- 套接字：作为更通用的接口，传输效率低，主要用于不同机器或跨网络的通信；
-- 信号量：常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。
-- 信号: 不适用于信息交换，更适用于进程中断控制，比如非法内存访问，杀死某个进程等；
+- 管道(Pipe)
+
+    管道是由内核管理的一个缓冲区，相当于我们放入内存中的一个纸条。管道的一端连接一个进程的输出。这个进程会向管道中放入信息。管道的另一端连接一个进程的输入，这个进程取出被放入管道的信息。
+
+    - 管道是半双工的，数据只能向一个方向流动。需要双方通信时，需要建立起两个管道。
+    - 只能用于父子进程或兄弟进程之间(具有亲缘关系的进程)。比如fork或exec创建的新进程，在使用exec创建新进程时，需要将管道的文件描述符作为参数传递给exec创建的新进程。当父进程与使用fork创建的子进程直接通信时，发送数据的进程关闭读端，接受数据的进程关闭写端。
+    - 管道只能在本地计算机中使用，而不可用于网络间的通信。
+
+-  命名管道（FIFO）
+
+    命名管道是一种特殊类型的文件，它在系统中以文件形式存在。这样克服了管道的弊端，他可以允许没有亲缘关系的进程间通信。
+
+- 共享内存（Share Memory）
+
+    共享内存是多个进程之间共享内存区域的一种进程间的通信方式，由IPC为进程创建一个特殊地址范围，它将出现在该进程的地址空间中。其他进程可以将同一段共享内存连接到自己的地址空间中。所有进程都可以访问共享内存的地址，如果一个进程向共享内存中写入数据，所做的改动将立刻被其他进程看到。
+
+    - 共享内存是IPC最快捷的方式，共享内存方式直接将某段内存段进行映射，多个进程间的共享内存是同一块的物理空间，仅仅映射到各进程的地址不同而已，因此不需要进行复制，可以直接使用此段空间。
+    - 共享内存本身并没有同步机制，需要程序员自己控制。
+
+-  内存映射（Memory Map)
+
+    内存映射是由一个文件到一块内存的映射，在此之后进程操作文件，就像操作进程空间里的内存地址一样。
+
+-  套接字（Soket）
+
+    套接字机制不但可以在单机的不同进程间通信，而且可以在跨网机器间进程通信。
+
+    套接字的创建和使用与管道是有区别的，套接字明确的将客户端与服务器区分开来，可以实现多个客户端连到同一个服务器。
 
 Android额外还有Binder  IPC机制，Android OS中的Zygote进程的IPC采用的是Socket机制，在上层system server、media  server以及上层App之间更多的是采用Binder。 IPC方式来完成跨进程间的通信。对于Android上层架构中，很多时候是在同一个进程的线程之间需要相互通信，例如同一个进程的主线程与工作线程之间的通信，往往采用的Handler消息机制。所以对于Android最上层架构而言，最常用的通信方式是: 
 
 - Binder
 
+    Android中最常用的跨进程通信方式。
+
 - Socket
 
     Socket通信方式也是C/S架构，比Binder简单很多。在Android系统中采用Socket通信方式的主要有：
@@ -32,11 +58,62 @@ Android额外还有Binder  IPC机制，Android OS中的Zygote进程的IPC采用
     - logcatd:这个不用说，用于服务logcat；
     - vold：即volume Daemon，是存储类的守护进程，用于负责如USB、Sdcard等存储设备的事件处理。
 
-    等等还有很多，这里不一一列举，Socket方式更多的用于Android framework层与native层之间的通信。Socket通信方式相对于binder比较简单，这里省略。
+    等等还有很多，这里不一一列举，Socket方式更多的用于Android framework层与native层之间的通信。
 
 - Handler
 
-    
+    主要用于线程之间的通信。
+
+
+
+### 进程隔离
+
+进程隔离是操作系统为了保护进程之间不相互干扰而设计的，避免进程A写入进程B的情况发生，其实现就是使用虚拟地址空间，两个进程虚拟地址不同，这样就可以防止A进程写入数据到B进程。也就是说，操作系统的不同进程之间，数据不共享，在每个进程看来，自己都独享了整个系统空间，完全不知道其他进程的存在，因此一个进程想要与另一个进程通信，需要某种系统机制才能完成。
+
+
+
+### 用户空间/内核空间
+
+Linux Kernel是操作系统的核心，独立于普通的应用程序，可以访问受保护的内存空间，也有访问底层硬件设备的所有权限。
+
+对于Kernel这中高安全级别的功能，显然是不允许其它应用程序随便调用或访问的，所以需要对Kernel提供一定的保护机制，这个保护机制用来告诉那些应用程序，你只可以访问某些许可的资源，不许可的资源是不能访问的，于是操作系统就把kernel和上层的应用程序抽象的隔离开，分别称之为kenel space和user space，即内核空间和用户空间。
+
+
+
+### 系统调用 内核态/用户态
+
+虽然从逻辑上抽离出用户空间和内核空间，但是不可避免的是，总有那么一些用户空间需要访问内核的资源：比如应用程序访问文件、网络这种，那么这种情况下该怎么处理？
+
+用户空间访问内核空间的唯一方式就是系统调用，通过这个统一入口，所有的资源访问都是在内核的控制下执行，以免导致用户程序对系统资源的越权访问，从而保障了系统的安全和稳定。
+
+Linux 使用两级保护机制：0 级供系统内核使用，3 级供用户程序使用。
+
+当一个任务（进程）执行系统调用而陷入内核代码中执行时，称进程处于内核运行态（内核态）。此时处理器处于特权级最高的（0级）内核代码中执行。当进程处于内核态时，执行的内核代码会使用当前进程的内核栈。每个进程都有自己的内核栈。
+
+当进程在执行用户自己的代码的时候，我们称其处于用户运行态（用户态）。此时处理器在特权级最低的（3级）用户代码中运行。
+
+系统调用主要通过如下两个函数来实现：
+
+```
+copy_from_user() //将数据从用户空间拷贝到内核空间
+copy_to_user() //将数据从内核空间拷贝到用户空间
+```
+
+
+
+### 内核模块/驱动
+
+通过系统调用，用户空间可以访问内核空间，那么如果一个用户空间想与另外一个用户空间进行通信该怎么处理？
+
+那就是让操作系统内核添加支持，传统的linux通信机制，比如socket、管道等都是内核的一部分，因此通过内核支持来实现进程间通信自然是没有问题的，但是binder并不是linux系统内核的一部分，那它是怎么做到访问内核空间的呢？这就得益于 Linux 的**动态内核可加载模块**（Loadable Kernel  Module，LKM）的机制；模块是具有独立功能的程序，它可以被单独编译，但是不能独立运行。它在运行时被链接到内核作为内核的一部分运行。这样，Android 系统就可以通过动态添加一个内核模块运行在内核空间，用户进程之间通过这个内核模块作为桥梁来实现通信。
+
+>  在 Android 系统中，这个运行在内核空间，负责各个用户进程通过 Binder 实现通信的内核模块就叫  **Binder 驱动**（Binder Dirver）（尽管名叫‘驱动’，实际上和硬件设备没有任何关系，只是实现方式和设备驱动程序是一样的）。
+
+
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/binder_qudong.png)
+
+
 
 ## Android为什么要使用Binder
 
@@ -44,61 +121,83 @@ Binder作为Android系统提供的一种IPC机制。首先一个问题就是为
 
 **接下来正面回答这个问题，从5个角度来展开对Binder的分析：**
 
-**（1）从性能的角度** ：数据拷贝次数，Binder数据拷贝只需要一次，而管道、消息队列、Socket都需要2次，但共享内存方式一次内存拷贝都不需要；从性能角度看，Binder性能仅次于共享内存。
+- **从性能的角度** ：
 
-**（2）从稳定性的角度**
-Binder是基于C/S架构的，简单解释下C/S架构，是指客户端(Client)和服务端(Server)组成的架构，Client端有什么需求，直接发送给Server端去完成，架构清晰明朗，Server端与Client端相对独立，稳定性较好；而共享内存实现方式复杂，没有客户与服务端之别， 需要充分考虑到访问临界资源的并发同步问题，否则可能会出现死锁等问题；从这稳定性角度看，Binder架构优越于共享内存。
+    对比与Linux的通信机制，socket是一个通用接口，导致其传输效率低、开销大。管道和消息队列因为采用存储转发的方式，所以至少需要拷贝2次数据，效率低。而共享内存虽然在传输时没有拷贝数据，但其控制机制复杂（比如跨进程通信时，需获取对方进程的pid，需要多种机制协同操作）。如果在APP级别，多拷贝一次或许没什么问题，但是如果上升到系统级别，系统内部通信频次是极高的，如果效率不够，用户体验会很差。
 
-仅仅从以上两点，各有优劣，还不足以支撑google去采用binder的IPC机制，那么更重要的原因是：
+    
+
+    具体原因如下，我们先来看看传统的 IPC 方式中，进程之间是如何实现通信的。
+
+    通常的做法是消息发送方将要发送的数据存放在内存缓存区中，通过系统调用进入内核态。然后内核程序在内核空间分配内存，开辟一块内核缓存区，调用 copy*from*user() 函数将数据从用户空间的内存缓存区拷贝到内核空间的内核缓存区中。同样的，接收方进程在接收数据时在自己的用户空间开辟一块内存缓存区，然后内核程序调用 copy*to*user() 函数将数据从内核缓存区拷贝到接收进程的内存缓存区。这样数据发送方进程和数据接收方进程就完成了一次数据传输，我们称完成了一次进程间通信。
+
+    这种传统的 IPC 通信方式有两个问题：
 
-**（3）从安全的角度**
-传统Linux IPC的接收方无法获得对方进程可靠的UID/PID，从而无法鉴别对方身份；而Android作为一个开放的开源体系，拥有非常多的开发平台，App来源甚广，因此手机的安全显得额外重要；对于普通用户，绝不希望从App商店下载偷窥隐私数据、后台造成手机耗电等等问题，传统Linux IPC无任何保护措施，完全由上层协议来确保。 
+    - 性能低下，一次数据传递需要经历：内存缓存区 --> 内核缓存区 --> 内存缓存区，需要 2 次数据拷贝；
+    - 接收数据的缓存区由数据接收进程提供，但是接收进程并不知道需要多大的空间来存放将要传递过来的数据，因此只能开辟尽可能大的内存空间或者先调用 API 接收消息头来获取消息体的大小，这两种做法不是浪费空间就是浪费时间。
 
-Android为每个安装好的应用程序分配了自己的UID，故进程的UID是鉴别进程身份的重要标志，前面提到C/S架构，**Android系统中对外只暴露Client端，Client端将任务发送给Server端，Server端会根据权限控制策略，判断UID/PID是否满足访问权限，目前权限控制很多时候是通过弹出权限询问对话框，让用户选择是否运行**。Android 6.0，也称为Android M，在6.0之前的系统是在App第一次安装时，会将整个App所涉及的所有权限一次询问，只要留意看会发现很多App根本用不上通信录和短信，但在这一次性权限权限时会包含进去，让用户拒绝不得，因为拒绝后App无法正常使用，而一旦授权后，应用便可以胡作非为。
+    
+
+    那Binder是怎么操作的呢？这就不得不通道 Linux 下的另一个概念：**内存映射**。
+
+    Binder IPC 机制中涉及到的内存映射通过 mmap() 来实现，mmap()  是操作系统中一种内存映射的方法。内存映射简单的讲就是将用户空间的一块内存区域映射到内核空间。映射关系建立后，用户对这块内存区域的修改可以直接反应到内核空间；反之内核空间对这段区域的修改也能直接反应到用户空间。
+
+    内存映射能减少数据拷贝次数，实现用户空间和内核空间的高效互动。两个空间各自的修改能直接反映在映射的内存区域，从而被对方空间及时感知。也正因为如此，内存映射能够提供对进程间通信的支持。
 
-针对这个问题，google在Android M做了调整，不再是安装时一并询问所有权限，而是在App运行过程中，需要哪个权限再弹框询问用户是否给相应的权限，对权限做了更细地控制，让用户有了更多的可控性，但同时也带来了另一个用户诟病的地方，那也就是权限询问的弹框的次数大幅度增多。对于Android M平台上，有些App开发者可能会写出让手机异常频繁弹框的App，企图直到用户授权为止，这对用户来说是不能忍的，用户最后吐槽的可不光是App，还有Android系统以及手机厂商，有些用户可能就跳果粉了，这还需要广大Android开发者以及手机厂商共同努力，共同打造安全与体验俱佳的Android手机。
+    一次完整的 Binder IPC 通信过程通常是这样：
 
-Android中权限控制策略有SELinux等多方面手段。传统IPC只能由用户在数据包里填入UID/PID；另外，可靠的身份标记只有由IPC机制本身在内核中添加。其次传统IPC访问接入点是开放的，无法建立私有通道。从安全角度，Binder的安全性更高。
+    1. 首先 Binder 驱动在内核空间创建一个数据接收缓存区；
 
-**（4）从语言层面的角度**
-大家多知道Linux是基于C语言(面向过程的语言)，而Android是基于Java语言(面向对象的语句)，而对于Binder恰恰也符合面向对象的思想，将进程间通信转化为通过对某个Binder对象的引用调用该对象的方法，而其独特之处在于Binder对象是一个可以跨进程引用的对象，它的实体位于一个进程中，而它的引用却遍布于系统的各个进程之中。可以从一个进程传给其它进程，让大家都能访问同一Server，就像将一个对象或引用赋值给另一个引用一样。Binder模糊了进程边界，淡化了进程间通信过程，整个系统仿佛运行于同一个面向对象的程序之中。从语言层面，Binder更适合基于面向对象语言的Android系统，对于Linux系统可能会有点“水土不服”。
+    2. 接着在内核空间开辟一块内核缓存区，建立**内核缓存区**和**内核中数据接收缓存区**之间的映射关系，以及**内核中数据接收缓存区**和**接收进程用户空间地址**的映射关系；
 
-**另外，Binder是为Android这类系统而生，而并非Linux社区没有想到Binder IPC机制的存在，对于Linux社区的广大开发人员，我还是表示深深佩服，让世界有了如此精湛而美妙的开源系统。**也并非Linux现有的IPC机制不够好，相反地，经过这么多优秀工程师的不断打磨，依然非常优秀，每种Linux的IPC机制都有存在的价值，同时在Android系统中也依然采用了大量Linux现有的IPC机制，根据每类IPC的原理特性，因时制宜，不同场景特性往往会采用其下最适宜的。比如在**Android OS中的Zygote进程的IPC采用的是Socket（套接字）机制**，Android中的**Kill Process采用的signal（信号）机制**等等。而**Binder更多则用在system_server进程与上层App层的IPC交互**。
+    3. 发送方进程通过系统调用 copy*from*user() 将数据 copy 到内核中的**内核缓存区**，由于内核缓存区和接收进程的用户空间存在内存映射，因此也就相当于把数据发送到了接收进程的用户空间，这样便完成了一次进程间的通信。用户地址空间(服务端-数据接收端)和内核地址空间都映射到同一块物理地址空间。
 
-**(5) 从公司战略的角度**
+        Client(数据发送端)先从自己的用户进程空间把IPC数据通过copy_from_user()拷贝到内核空间。而Server端（数据接收端）与内核共享数据(mmap到同一块物理内存)，不再需要拷贝数据，而是通过内存地址空间的偏移量，即可获悉内存地址，整个过程只发生一次内存拷贝。
+
+- **从稳定性的角度**
+    Binder是基于C/S架构的，简单解释下C/S架构，是指客户端(Client)和服务端(Server)组成的架构，Client端有什么需求，直接发送给Server端去完成，架构清晰明朗，Server端与Client端相对独立，稳定性较好；而共享内存实现方式复杂，没有客户与服务端之别， 需要充分考虑到访问临界资源的并发同步问题，否则可能会出现死锁等问题；从这稳定性角度看，Binder架构优越于共享内存。
+
+仅仅从以上两点，各有优劣，还不足以支撑google去采用binder的IPC机制，那么更重要的原因是：
 
-总所周知，Linux内核是开源的系统，所开放源代码许可协议GPL保护，该协议具有“病毒式感染”的能力，怎么理解这句话呢？受GPL保护的Linux Kernel是运行在内核空间，对于上层的任何类库、服务、应用等运行在用户空间，一旦进行SysCall（系统调用），调用到底层Kernel，那么也必须遵循GPL协议。 
+- **从安全的角度**
+    Linux的IPC机制在本身的实现中，并没有安全措施，得依赖上层协议来进行安全控制。而Android作为一个开放的开源体系，拥有非常多的开发平台，App来源甚广，因此手机的安全显得额外重要；对于普通用户，绝不希望从App商店下载偷窥隐私数据、后台造成手机耗电等等问题。Android为每个安装好的应用程序分配了自己的UID，故进程的UID是鉴别进程身份的重要标志，前面提到C/S架构，**Android系统中对外只暴露Client端，Client端将任务发送给Server端，Server端会根据权限控制策略，判断UID/PID是否满足访问权限，目前权限控制很多时候是通过弹出权限询问对话框，让用户选择是否运行**。Android 6.0，也称为Android M，在6.0之前的系统是在App第一次安装时，会将整个App所涉及的所有权限一次询问，只要留意看会发现很多App根本用不上通信录和短信，但在这一次性权限权限时会包含进去，让用户拒绝不得，因为拒绝后App无法正常使用，而一旦授权后，应用便可以胡作非为。
 
-而Android 之父 Andy Rubin对于GPL显然是不能接受的，为此，Google巧妙地将GPL协议控制在内核空间，将用户空间的协议采用Apache-2.0协议（允许基于Android的开发商不向社区反馈源码），同时在GPL协议与Apache-2.0之间的Lib库中采用BSD证授权方法，有效隔断了GPL的传染性，仍有较大争议，但至少目前缓解Android，让GPL止步于内核空间，这是Google在GPL Linux下开源与商业化共存的一个成功典范。
+    针对这个问题，google在Android M做了调整，不再是安装时一并询问所有权限，而是在App运行过程中，需要哪个权限再弹框询问用户是否给相应的权限，对权限做了更细地控制，让用户有了更多的可控性，但同时也带来了另一个用户诟病的地方，那也就是权限询问的弹框的次数大幅度增多。对于Android M平台上，有些App开发者可能会写出让手机异常频繁弹框的App，企图直到用户授权为止，这对用户来说是不能忍的，用户最后吐槽的可不光是App，还有Android系统以及手机厂商，有些用户可能就跳果粉了，这还需要广大Android开发者以及手机厂商共同努力，共同打造安全与体验俱佳的Android手机。
 
-**有了这些铺垫，我们再说说Binder的今世前缘**
+    Android中权限控制策略有SELinux等多方面手段。传统IPC只能由用户在数据包里填入UID/PID；另外，可靠的身份标记只有由IPC机制本身在内核中添加。其次传统IPC访问接入点是开放的，无法建立私有通道。从安全角度，Binder的安全性更高。
 
-Binder是基于开源的[OpenBinder](https://link.zhihu.com/?target=http%3A//www.angryredplanet.com/~hackbod/openbinder/docs/html/BinderIPCMechanism.html)实现的，OpenBinder是一个开源的系统IPC机制,最初是由 [Be Inc.](https://link.zhihu.com/?target=https%3A//en.wikipedia.org/wiki/Be_Inc.) 开发，接着由[Palm, Inc.](https://link.zhihu.com/?target=https%3A//en.wikipedia.org/wiki/Palm%2C_Inc.)公司负责开发，现在OpenBinder的作者在Google工作，既然作者在Google公司，在用户空间采用Binder 作为核心的IPC机制，再用Apache-2.0协议保护，自然而然是没什么问题，减少法律风险，以及对开发成本也大有裨益的，那么从公司战略角度，Binder也是不错的选择。
+- **从语言层面的角度**
+    大家多知道Linux是基于C语言(面向过程的语言)，而Android是基于Java语言(面向对象的语句)，而对于Binder恰恰也符合面向对象的思想，将进程间通信转化为通过对某个Binder对象的引用调用该对象的方法，而其独特之处在于Binder对象是一个可以跨进程引用的对象，它的实体位于一个进程中，而它的引用却遍布于系统的各个进程之中。可以从一个进程传给其它进程，让大家都能访问同一Server，就像将一个对象或引用赋值给另一个引用一样。Binder模糊了进程边界，淡化了进程间通信过程，整个系统仿佛运行于同一个面向对象的程序之中。从语言层面，Binder更适合基于面向对象语言的Android系统，对于Linux系统可能会有点“水土不服”。
 
-另外，再说一点关于OpenBinder，在2015年OpenBinder以及合入到Linux Kernel主线 3.19版本，这也算是Google对Linux的一点回馈吧。
+- **从公司战略的角度**
 
-**综合上述5点，可知Binder是Android系统上层进程间通信的不二选择。**
+    总所周知，Linux内核是开源的系统，所开放源代码许可协议GPL保护，该协议具有“病毒式感染”的能力，怎么理解这句话呢？受GPL保护的Linux Kernel是运行在内核空间，对于上层的任何类库、服务、应用等运行在用户空间，一旦进行SysCall（系统调用），调用到底层Kernel，那么也必须遵循GPL协议。 
 
+    而Android 之父 Andy Rubin对于GPL显然是不能接受的，为此，Google巧妙地将GPL协议控制在内核空间，将用户空间的协议采用Apache-2.0协议（允许基于Android的开发商不向社区反馈源码），同时在GPL协议与Apache-2.0之间的Lib库中采用BSD证授权方法，有效隔断了GPL的传染性，仍有较大争议，但至少目前缓解Android，让GPL止步于内核空间，这是Google在GPL Linux下开源与商业化共存的一个成功典范。
 
+综合上述5点，可知Binder是Android系统上层进程间通信的不二选择。
 
-**最后，简单讲讲Android Binder架构**
 
-Binder在Android系统中江湖地位非常之高。在Zygote孵化出system_server进程后，在system_server进程中出初始化支持整个Android framework的各种各样的Service，而这些Service从大的方向来划分，分为Java层Framework和Native Framework层(C++)的Service，几乎都是基于BInder IPC机制： 
 
-1. Java framework：作为Server端继承(或间接继承)于Binder类，Client端继承(或间接继承)于BinderProxy类。例如 ActivityManagerService(用于控制Activity、Service、进程等) 这个服务作为Server端，间接继承Binder类，而相应的ActivityManager作为Client端，间接继承于BinderProxy类。 当然还有PackageManagerService、WindowManagerService等等很多系统服务都是采用C/S架构；
-2. Native Framework层：这是C++层，作为Server端继承(或间接继承)于BBinder类，Client端继承(或间接继承)于BpBinder。例如MediaPlayService(用于多媒体相关)作为Server端，继承于BBinder类，而相应的MediaPlay作为Client端，间接继承于BpBinder类。
+### 疑问
 
+到这里又迷糊了，你上面说了这么多Binder这么好，那为啥Android里面还有地方用Socket？SystemServer和Zygote之间的通信为啥不用Binder？
 
+SystemServer和Zygote之间通信不使用Socket的原因是为了要解决fork的问题。UNIX上C++程序设计守则3中规定：多线程程序里不准使用fork。
 
-**总之，一句话"无Binder不Android"。**
+而Binder通讯是需要多线程操作的，代理对象对Binder的调用是在Binder线程，需要再通过Handler调用主线程来操作。比如AMS与应用进程通讯，AMS的本地代理IApplicationThread通过调用ScheduleLaunchActivity，调用到的应用进程ApplicationThread的ScheduleLaunchActivity是在Binder线程，需要再把参数封装为一个ActivityClientRecord，sendMessage发送给H类（主线程Handler，ActivityThread内部类）。主要原因是害怕父进程binder线程有锁，然后子进程的主线程一直在等待其子线程（从父进程拷贝过来的子进程）的资源，但是其实父进程的子进程并没有被拷贝过来，造成死锁。
 
+所以fork不允许存在多线程。而非常巧的是Binder通讯偏偏就是多线程，所以干脆父进程（Zygote）这个时候就不使用Binder线程了。
 
 
-前面人都说了Binder的优点，我来讲故事
+
+所以也并非Linux现有的IPC机制不够好，相反地，经过这么多优秀工程师的不断打磨，依然非常优秀，每种Linux的IPC机制都有存在的价值，同时在Android系统中也依然采用了大量Linux现有的IPC机制，根据每类IPC的原理特性，因时制宜，不同场景特性往往会采用其下最适宜的。比如在Android OS中的Zygote进程的IPC采用的是Socket（套接字）机制，Android中的Kill Process采用的signal（信号）机制等等。而Binder更多则用在system_server进程与上层App层的IPC交互。
+
+### 讲故事
 
 1. 当年Andy Rubin有个公司Palm做掌上设备的就是当年那种PDA有个系统叫PalmOS后来palm被收购了以后 Andy Rubin创立了Android
 
-2. Palm收购过一个公司叫Be里面有个移动系统叫BeOS，进程通信自己写了个实现叫Binder由一个叫Dianne Hackbod的人开发并维护后来Binder也被用到了PalmOS里
+2. Palm收购过一个公司叫Be里面有个移动系统叫BeOS，进程通信自己写了个实现叫OpenBinder由一个叫Dianne Hackbod的人开发并维护后来Binder也被用到了PalmOS里
 
 3. Android创立了以后Andy从Palm带走了一大批人，其中就有Dianne。Dianne成为安卓系统总架构师。
 
@@ -114,73 +213,149 @@ Binder在Android系统中江湖地位非常之高。在Zygote孵化出system_ser
 
 
 
+
+
 ## Binder框架
 
-Binder是一种架构，这种架构提供了服务端接口、Binder驱动、客户端接口三个模块。
+在Android系统的Binder机制中，由一系统组件组成，分别是Client、Server、Service Manager和Binder驱动程序，其中Client、Server和Service  Manager运行在用户空间，Binder驱动程序运行内核空间。其中Service  Manager和Binder驱动由系统提供，而Client、Server由应用程序来实现。其中，核心组件便是Binder驱动程序了，Service Manager提供了辅助管理的功能，Client和Server正是在Binder驱动和Service  Manager提供的基础设施上，进行Client-Server之间的通信。Client、Server 和  ServiceManager 均是通过系统调用 open、mmap 和 ioctl 来访问设备文件 /dev/binder，从而实现与Binder驱动的交互来间接的实现跨进程通信。
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/binder_framework.png)
 
-- 服务端
+- Server
 
     一个Binder服务端实际上就是一个Binder类的对象，该对象一旦创建，内部就启动一个隐藏线程。该线程接下来会接收Binder驱动发送的消息，收到消息后，会执行到Binder对象中的onTransact()函数，并按照该函数的参数执行不同的服务代码。因此，要实现一个Binder服务就必须重载onTransact()方法。
 
     可以想象，重载onTransact()函数的主要内容是把onTransact()函数的参数转换为服务函数的参数，而onTransact()函数的参数来源是客户端调用transact()函数时传入的，因此，如果transact()有固定格式的输入，那么onTransact()就会有固定格式的输出。
 
+    ##### Binder线程池
+
+    每个Server进程在启动时会创建一个binder线程池，并向其中注册一个Binder线程；之后Server进程也可以向binder线程池注册新的线程，或者Binder驱动在探测到没有空闲binder线程时会主动向Server进程注册新的的binder线程。对于一个Server进程有一个最大Binder线程数限制，默认为16个binder线程，例如Android的system_server进程就存在16个线程。对于所有Client端进程的binder请求都是交由Server端进程的binder线程来处理的。
+
 - Binder驱动
 
+    和路由器一样，Binder驱动虽然默默无闻，却是通信的核心。尽管名叫‘驱动’，实际上和硬件设备没有任何关系，只是实现方式和设备驱动程序是一样的：它工作于内核态，提供open()，mmap()，poll()，ioctl()等标准文件操作，以字符驱动设备中的misc设备注册在设备目录/dev下，用户通过/dev/binder访问该它。驱动负责进程之间Binder通信的建立，Binder在进程之间的传递，Binder引用计数管理，数据包在进程之间的传递和交互等一系列底层支持。驱动和应用程序之间定义了一套接口协议，主要功能由ioctl()接口实现，不提供read()，write()接口，因为ioctl()灵活方便，且能够一次调用实现先写后读以满足同步交互，而不必分别调用write()和read()。Binder驱动的代码位于linux目录的drivers/misc/binder.c中。
+
+    
+
     任何一个服务端Binder对象被创建时，同时会在Binder驱动中创建一个mRemote对象，该对象的类型也是Binder类。客户端要访问远程服务时，都是通过mRemote对象。
 
     ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/binder_archi.png)
 
-- 应用程序客户端
+    在Binder驱动层，每个接收端进程都有一个todo队列，用于保存发送端进程发送过来的binder请求，这类请求可以由接收端进程的任意一个空闲的binder线程处理；接收端进程存在一个或多个binder线程，在每个binder线程里都有一个todo队列，也是用于保存发送端进程发送过来的binder请求，这类请求只能由当前binder线程来处理。binder线程在空闲时进入可中断的休眠状态，当自己的todo队列或所属进程的todo队列有新的请求到来时便会唤醒，如果是由所需进程唤醒的，那么进程会让其中一个线程处理响应的请求，其他线程再次进入休眠状态。
 
-    客户端想要访问远程服务，必须获取远程服务在Binder对象中对应的mRemote引用，获得该mRemote对象后，就可以调用其transact()方法，调用该方法后，客户端线程进入Binder驱动，Binder驱动就会挂起当前线程，并向远程服务发送一个消息，消息中包含了客户端传进来的包裹。服务端拿到包裹后，会对包裹进行拆解，然后执行指定的服务函数，执行完毕后，再把执行结果放入客户端提供的reply包裹中。然后服务端向Binder驱动发送一个notify的消息，从而使得客户端线程从Binder驱动的代码区返回到客户端代码区。transact()的最后一个参数的含义是执行IPC调用的模式，分为两种：一种是双向，用常量0表示，其含义是服务端执行完指定的服务后返回一定的数据。另一种是单向，用常量1表示，其含义是不返回任何数据。最后，客户端就可以从reply中解析返回的数据了，同样，返回包裹中包含的数据也必须是有序的，而且这个顺序也必须是服务端和客户端事先约定好的。
 
+
+- Client
+
+    Server向ServiceManager注册了Binder实体及其名字后，Client就可以通过名字获得该Binder的引用了。Client也利用保留的0号引用向ServiceManager请求访问某个Binder：我申请获得名字叫张三的Binder的引用。ServiceManager收到这个连接请求，从请求数据包里获得Binder的名字，在查找表里找到该名字对应的条目，从条目中取出Binder的引用，将该引用作为回复发送给发起请求的Client。从面向对象的角度，这个Binder对象现在有了两个引用：一个位于ServiceManager中，一个位于发起请求的Client中。如果接下来有更多的Client请求该Binder，系统中就会有更多的引用指向该Binder，就象java里一个对象存在多个引用一样。而且类似的这些指向Binder的引用是强类型，从而确保只要有引用Binder实体就不会被释放掉。通过以上过程可以看出，ServiceManager象个火车票代售点，收集了所有火车的车票，可以通过它购买到乘坐各趟火车的票-得到某个Binder的引用。
+
+    ##### 匿名 Binder
+    
+    并不是所有Binder都需要注册给ServiceManager广而告之的。Server端可以通过已经建立的Binder连接将创建的Binder实体传给Client，当然这条已经建立的Binder连接必须是通过实名Binder实现。由于这个Binder没有向ServiceManager注册名字，所以是个匿名Binder。Client将会收到这个匿名Binder的引用，通过这个引用向位于Server中的实体发送请求。匿名Binder为通信双方建立一条私密通道，只要Server没有把匿名Binder发给别的进程，别的进程就无法通过穷举或猜测等任何方式获得该Binder的引用，向该Binder发送请求。
+    
+    
+    
+    客户端想要访问远程服务，必须获取远程服务在Binder对象中对应的mRemote引用，获得该mRemote对象后，就可以调用其transact()方法，调用该方法后，客户端线程进入Binder驱动，Binder驱动就会挂起当前线程，并向远程服务发送一个消息，消息中包含了客户端传进来的包裹。服务端拿到包裹后，会对包裹进行拆解，然后执行指定的服务函数，执行完毕后，再把执行结果放入客户端提供的reply包裹中。然后服务端向Binder驱动发送一个notify的消息，从而使得客户端线程从Binder驱动的代码区返回到客户端代码区。transact()的最后一个参数的含义是执行IPC调用的模式，分为两种：一种是双向，用常量0表示，其含义是服务端执行完指定的服务后返回一定的数据。另一种是单向，用常量1表示，其含义是不返回任何数据。最后，客户端就可以从reply中解析返回的数据了，同样，返回包裹中包含的数据也必须是有序的，而且这个顺序也必须是服务端和客户端事先约定好的。
+    
     从这里可以看出，对应用程序开发员来说，客户端似乎是直接调用远程服务对应的Binder，而事实上则是通过Binder驱动进行了中转。即存在两个Binder对象，一个是服务端的Binder对象，另一个则是Binder驱动中的Binder对象，所不同的是Binder驱动中的对象不会再额外产生一个线程。
 
+- ServiceManager
+
+    ServiceManager本身的工作很简单：注册服务、查询服务、列出所有服务，启动一个死循环来解析Binder驱动读写动作，进行事务处理。ServiceManager用于管理系统中的各种服务。架构图如下所示：
+
+    ![ServiceManager](http://gityuan.com/images/binder/prepare/IPC-Binder.jpg)
+
+    可以看出无论是注册服务和获取服务的过程都需要ServiceManager(与DNS类似)，需要注意的是此处的Service  Manager是指Native层的ServiceManager（C++），并非指framework层的ServiceManager(Java)。ServiceManager是整个Binder通信机制的大管家，是Android进程间通信机制Binder的守护进程。Binder机制使用的是代理模式，在Server端的对象是实际对象，其他各个进程端所持有的都是Server端对象的Proxy代理对象，ServiceManager中会有一个类似map的结构，会存储Server端的信息，当Server端进程初始化时，会向ServiceManager中注册自己的信息。当client端想要访问时，也需要先向ServiceManager进行查询，当进行通信时，数据会流经内核空间中的binder驱动，此时驱动会对要传递的数据做转换。
+
+    和DNS类似，ServiceManager的作用是将字符形式的Binder名字转化成Client中对该Binder的引用，使得Client能够通过Binder名字获得对Server中Binder实体的引用。注册了名字的Binder叫实名Binder，就象每个网站除了有IP地址外还有自己的网址。Server创建了Binder实体，为其取一个字符形式，可读易记的名字，将这个Binder连同名字以数据包的形式通过Binder驱动发送给ServiceManager，通知ServiceManager注册一个名叫张三的Binder，它位于某个Server中。驱动为这个穿过进程边界的Binder创建位于内核中的实体节点以及ServiceManager对实体的引用，将名字及新建的引用打包传递给ServiceManager。ServiceManager收数据包后，从中取出名字和引用填入一张查找表中。
+
+    细心的读者可能会发现其中的蹊跷：ServiceManager是一个进程，Server是另一个进程，Server向ServiceManager注册Binder必然会涉及进程间通信。当前实现的是进程间通信却又要用到进程间通信，这就好象蛋可以孵出鸡前提却是要找只鸡来孵蛋。Binder的实现比较巧妙：预先创造一只鸡来孵蛋：ServiceManager和其它进程同样采用Binder通信，ServiceManager是Server端，有自己的Binder对象（实体），其它进程都是Client，需要通过这个Binder的引用来实现Binder的注册，查询和获取。ServiceManager提供的Binder比较特殊，它没有名字也不需要注册，当一个进程使用BINDER_SET_CONTEXT_MGR命令将自己注册成ServiceManager时Binder驱动会自动为它创建Binder实体（这就是那只预先造好的鸡）。其次这个Binder的引用在所有Client中都固定为0(handle=0)而无须通过其它手段获得。也就是说，一个Server若要向ServiceManager注册自己Binder就必须通过0这个引用号和ServiceManager的Binder通信。类比网络通信，0号引用就好比域名服务器的地址，你必须预先手工或动态配置好。要注意这里说的Client是相对ServiceManager而言的，一个应用程序可能是个提供服务的Server，但对ServiceManager来说它仍然是个Client。
+
+    图中的Client,Server,Service Manager之间交互都是虚线表示，是由于它们彼此之间不是直接交互的，而是都通过与[Binder驱动](http://gityuan.com/2015/11/01/binder-driver/)进行交互的。
+
+    ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/binder_client_server.png)
+
+    
+
+    
+
 
 
-## Binder IPC原理
+## Binder 通信过程
 
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/binder_communication.jpg)
 
 
-每个Android的进程，只能运行在自己进程所拥有的虚拟地址空间。对应一个4GB的虚拟地址空间，其中3GB是用户空间，1GB是内核空间，当然内核空间的大小是可以通过参数配置调整的。对于用户空间，不同进程之间彼此是不能共享的，而内核空间却是可共享的。Client进程向Server进程通信，恰恰是利用进程间可共享的内核内存空间来完成底层通信工作的，Client端与Server端进程往往采用ioctl(设备驱动程序中设备控制接口函数，进程与内核通信的一种方法)等方法跟内核空间的驱动进行交互。
 
+- 首先，一个进程使用 BINDER*SET*CONTEXT_MGR 命令通过 Binder 驱动将自己注册成为 ServiceManager；
 
+- Server通过驱动向ServiceManager中进行服务注册，表明可以对外提供服务。ServiceManager有一个全局的service列表svcinfo，用来缓存所有服务的handler和name。驱动为这个Binder创建位于内核中的实体节点以及 ServiceManager 对实体的引用，将名字以及新建的引用打包传给  ServiceManager，ServiceManger 将其填入查找表。
 
-Binder通信采用C/S架构，从组件视角来说，包含Client、Server、ServiceManager以及binder驱动，其中ServiceManager用于管理系统中的各种服务。架构图如下所示：
+- 客户端与服务端通信，需要拿到服务端的对象，由于进程隔离，客户端拿到的其实是服务端的代理，也可以理解为引用。客户端通过Client 通过名字，在 Binder 驱动的帮助下从ServiceManager的svcinfo中查找服务，ServiceManager返回服务的代理。
 
-![ServiceManager](http://gityuan.com/images/binder/prepare/IPC-Binder.jpg)
+- Server进程启动之后，会进入中断等待状态，等待Client的请求。
 
-可以看出无论是注册服务和获取服务的过程都需要ServiceManager，需要注意的是此处的Service  Manager是指Native层的ServiceManager（C++），并非指framework层的ServiceManager(Java)。ServiceManager是整个Binder通信机制的大管家，是Android进程间通信机制Binder的守护进程。
+- 当Client需要和Server通信时，会通过BinderProxy将我们的请求参数发送给 内核，通过共享内存的方式使用内核方法 copy_from_user() 将我们的参数先拷贝到内核空间，这时我们的客户端进入等待状态。
 
-图中Client/Server/ServiceManage之间的相互通信都是基于Binder机制。既然基于Binder机制通信，那么同样也是C/S架构，则图中的3大步骤都有相应的Client端与Server端。
+- Binder驱动收到请求之后，会唤醒Server进程，Binder驱动向服务端的 todo 队列里面插入一条事务，执行完之后把执行结果通过 copy_to_user()  将内核的结果拷贝到用户空间。
+- Server进程解析出请求内容，并将回复内容发送给Binder驱动。
+- 接着，Binder驱动收到回复之后，唤醒Client进程。Binder驱动还会反馈信息给Client，告诉Client：它发送给Binder驱动的请求，Binder驱动已经完成。
+- 接着，Binder驱动还会反馈信息给Server，告诉Server：它发送给Binder驱动的回复，Binder驱动已经收到。
+- Server将回复发送成功之后，再次进入等待状态，等待Client的请求。
+- 最后，Binder驱动将回复转发给Client。
 
-1. **[注册服务(addService)](http://gityuan.com/2015/11/14/binder-add-service/)**：Server进程要先注册Service到ServiceManager。该过程：Server是客户端，ServiceManager是服务端。
-2. **[获取服务(getService)](http://gityuan.com/2015/11/15/binder-get-service/)**：Client进程使用某个Service前，须先向ServiceManager中获取相应的Service。该过程：Client是客户端，ServiceManager是服务端。
-3. **使用服务**：Client根据得到的Service信息建立与Service所在的Server进程通信的通路，然后就可以直接与Service交互。该过程：client是客户端，server是服务端。
 
-图中的Client,Server,Service Manager之间交互都是虚线表示，是由于它们彼此之间不是直接交互的，而是都通过与[Binder驱动](http://gityuan.com/2015/11/01/binder-driver/)进行交互的，从而实现IPC通信方式。其中Binder驱动位于内核空间，Client,Server,Service Manager位于用户空间。Binder驱动和Service  Manager可以看做是Android平台的基础架构，而Client和Server是Android的应用层，开发人员只需自定义实现client、Server端，借助Android的基本平台架构便可以直接进行IPC通信。
 
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/binder_all_process.jpg)
 
 
 
+## Binder的内存管理
 
+ServiceManager启动后，会通过系统调用mmap向内核空间申请128K的内存，用户进程会通过mmap向内核申请(1M-8K)的内存空间。
 
+这里用户空间mmap (1M-8K)的空间，为什么要减去8K，而不是直接用1M?
 
-### 2.3 C/S模式
+Android的git commit记录：
 
-BpBinder(客户端)和BBinder(服务端)都是Android中Binder通信相关的代表，它们都从IBinder类中派生而来，关系图如下：
+>  Modify the binder to request 1M - 2 pages instead of 1M. The  backing store in the kernel requires a guard page, so 1M allocations  fragment memory very badly. Subtracting a couple of pages so that they  fit in a power of two allows the kernel to make more efficient use of  its virtual address space.
 
-![Binder关系图](http://gityuan.com/images/binder/prepare/Ibinder_classes.jpg)
+大致的意思是：kernel的“backing store”需要一个保护页，这使得1M用来分配碎片内存时变得很差，所以这里减去两页来提高效率，因为减去一页就变成了奇数。
 
-- client端：BpBinder.transact()来发送事务请求；
-- server端：BBinder.onTransact()会接收到相应事务。
+​    
 
+**系统定义：**BINDER_VM_SIZE ((1 * 1024 * 1024) - sysconf(_SC_PAGE_SIZE) * 2)  = （1M- sysconf(_SC_PAGE_SIZE) * 2）  
 
+**这里的8K，其实就是两个PAGE的SIZE, 物理内存的划分是按PAGE(页)来划分的，一般情况下，一个Page的大小为4K。**
+
+**内核会增加一个guard page，再加上内核本身的guard page，正好是两个page的大小，减去后，就是用户空间可用的大小。**     
+
+在内存分配这块，还要分为32位和64位，32位的系统很好区分，虚拟内存为4G，用户空间从低地址开始占用3G，内核空间占用剩余的1G。
+
+ARM32内存占用分配：
+
+![img](https://img-blog.csdnimg.cn/20200329164623413.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lpcmFuZmVuZw==,size_16,color_FFFFFF,t_70)
+
+但随着现在的硬件发展越来越迅速，应用程序的运算也越来越复杂，占用空间越来越大，原有的4G虚拟内存已经不能满足用户的需求，因此，现在的Android基本都是用64位的内存机制。
+
+理论上讲，64位的地址总线可以支持高达16EB（2^64）的内存。AMD64架构支持52位（4PB）的地址总线和48位（256TB）的虚拟地址空间。在linux  arm64中，如果页的大小为4KB，使用3级页表转换或者4级页表转换，用户空间和内核空间都支持有39bit（512GB）或者48bit（256TB）大小的虚拟地址空间。
+
+2^64 次方太大了，Linux 内核只采用了 64 bits 的一部分（开启 CONFIG_ARM64_64K_PAGES 时使用 42 bits，页大小是 4K 时使用 39 bits），该文假设使用的页大小是 4K（VA_BITS = 39）
+
+ARM64 有足够的虚拟地址，用户空间和内核空间可以有各自的 2^39 = 512GB 的虚拟地址。
+
+ARM64内存占用分配：
+
+![img](https://img-blog.csdnimg.cn/20200329164637770.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lpcmFuZmVuZw==,size_16,color_FFFFFF,t_70)
+
+用户地址空间(服务端-数据接收端)和内核地址空间都映射到同一块物理地址空间。
 
 
 
 参考: https://www.zhihu.com/question/39440766/answer/93550572
 
+[https://zhuanlan.zhihu.com/p/35519585](https://zhuanlan.zhihu.com/p/35519585)
+
 
 
 ---
diff --git "a/OperatingSystem/AndroidKernal/3.Android Framework\346\241\206\346\236\266.md" "b/OperatingSystem/AndroidKernal/3.Android Framework\346\241\206\346\236\266.md"
index f550d1ee..0e052371 100644
--- "a/OperatingSystem/AndroidKernal/3.Android Framework\346\241\206\346\236\266.md"	
+++ "b/OperatingSystem/AndroidKernal/3.Android Framework\346\241\206\346\236\266.md"	
@@ -29,13 +29,28 @@ AmS的作用是管理所有应用程序中的Activity。
 
 客户端主要包括以下重要类：   
 
-- ActivityThread类：该类为应用程序的主线程类，所有的APK程序都有且仅有一个ActivityThread类，程序的入口为该类中的static main()函数。
+- ActivityThread类：该类为应用程序的主线程类，所有的APK程序都有且仅有一个ActivityThread类，程序的入口为该类中的static main()函数。ActivityThread是Android Framework中一个非常重要的类，它代表一个应用进程的主线程，其职责就是调度及执行在该线程中运行的四大组件。 
+
+    注意到此处的ActivityThread创建于SystemServer进程中。 
+
+    由于SystemServer中也运行着一些系统APK，例如framework-res.apk、SettingsProvider.apk等，因此也可以认为SystemServer是一个特殊的应用进程。
+
+    AMS负责管理和调度进程，因此AMS需要通过Binder机制和应用进程通信。 
+
+    为此，Android提供了一个IApplicationThread接口，该接口定义了AMS和应用进程之间的交互函数。
+
 - Activity类：该类为APK程序中的一个最小运行单元，一个APK程序中可以包含多个Activity对象，ActivityThread类会根据用户操作选择运行哪个Activity对象。
+
 - PhoneWindow类：该类继承于Window类，同时，PhoneWindow类内部包含了一个DecorView对象。简而言之，PhoneWindow是把一个FrameLayout进行了一定的包装，并提供了一组通用的窗口操作接口。
+
 - Window类：该类提供了一组通用的窗口（Window)操作API，这里的窗口仅仅是程序层面上的，WmS所管理的窗口并不是Window类，而是一个View或者ViewGroup类，一般就是指DecorView类，即一个DecorView就是WmS所管理的一个窗口。Window是一个abstract类型。
+
 - DecorView类：该类是一个FrameLayout的子类，并且是PhoneWindow中的一个内部类。Decor的英文是Decoration，即”装饰“的意思，DecorView就是对普通的FrameLayout进行了一定的装饰，比如添加一个通用的Titlebar，并响应特定的按键消息等。
+
 - ViewRoot类：WmS管理客户端窗口时，需要通知客户端进行某种操作，这些都是通过异步消息完成的，实现的方式就是使用Handler，ViewRoot类就是继承于Handler，其作用主要是接收WmS的通知。
+
 - W类：该类继承于Binder，并且是ViewRoot的一个内部类。
+
 - WindowManager类：客户端要申请创建一个窗口，而具体创建窗口的任务是由WmS完成的，WindowManager类就像是一个部门经理，谁有什么需求就告诉它，由它和WmS进行交互，客户端不能直接和WmS进行交互。
 
 
diff --git "a/VideoDevelopment/\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
similarity index 97%
rename from "VideoDevelopment/\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
rename to "VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
index a6e48d63..7af53a77 100644
--- "a/VideoDevelopment/\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
+++ "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
@@ -36,7 +36,7 @@
 
     比特率恒定，图像内容复杂的片段质量不稳定，图像内容简单的片段质量较好。
 
-- ***帧率***:帧/秒(`frames per second`)的缩写帧率即每秒显示帧数，帧率表示图形处理器处理场时每秒钟能够更新的次数。高的帧率可以得到更流畅、更逼真的动画。一般来说`30fps`就是可以接受的，但是将性能提升至`60fps`则可以明显提升交互感和逼真感，但是一般来说超过`75fps`一般就不容易察觉到有明显的流畅度提升了。如果帧率超过屏幕刷新率只会浪费图形处理的能力，因为监视器不能以这么快的速度更新，这样超过新率的帧率就浪费掉了。
+- ***帧率(Frame Rate)***:帧/秒(`frames per second`)的缩写帧率即每秒显示帧数，帧率表示图形处理器处理场时每秒钟能够更新的次数。高的帧率可以得到更流畅、更逼真的动画。一般来说`30fps`就是可以接受的，但是将性能提升至`60fps`则可以明显提升交互感和逼真感，但是一般来说超过`75fps`一般就不容易察觉到有明显的流畅度提升了。如果帧率超过屏幕刷新率只会浪费图形处理的能力，因为监视器不能以这么快的速度更新，这样超过新率的帧率就浪费掉了。
   ![image](https://github.com/CharonChui/Pictures/blob/master/fps.gif?raw=true)
 
 - ***关键帧***:相当于二维动画中的原画，指角色或者物体运动或变化中的关键动作所处的那一帧，它包含了图像的所有信息，后来帧仅包含了改变了的信息。如果你没有足够的关键帧，你的影片品质可能比较差，因为所有的帧从别的帧处产生。对于一般的用途，一个比较好的原则是每5秒设一个关键键。但如果时那种实时传输的流文件，那么要考虑传输网络的可靠度，所以要1到2秒增加一个关键帧。

From 1750ce75d3e7d0f0e09b3123f1bd239cc0376fa6 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 31 Dec 2020 14:13:11 +0800
Subject: [PATCH 042/213] udpate

---
 .../3.\345\206\205\345\255\230\347\256\241\347\220\206.md"      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git "a/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md" "b/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
index fa5e3048..33824b74 100644
--- "a/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
+++ "b/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
@@ -243,7 +243,7 @@ Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自
 
 Android包含了标准Linux内核中内存管理设施的许多扩展，具体如下: 
 
-- ASHMem：这个功能提供匿名共享内存，它将内存抽象为文件描述符。文件描述符可以传递给另一个进程以共享内存。
+- ASHMem(Anonymous Shared Memory)：这个功能提供匿名共享内存，它将内存抽象为文件描述符。文件描述符可以传递给另一个进程以共享内存。
 
 - Pmen：这个功能分配虚拟内存，使的它在物理上是连续的，因此对于那些不支持虚拟内存的设备非常实用。
 

From 3d5dc96ccef71bfe1313139381c88778f72c3e83 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 11 Jan 2021 15:13:08 +0800
Subject: [PATCH 043/213] update

---
 ...73\347\273\237\347\256\200\344\273\213.md" | 158 ++++++++++--
 ...13\344\270\216\347\272\277\347\250\213.md" | 237 ++++++++++++++++--
 ...05\345\255\230\347\256\241\347\220\206.md" |  63 ++++-
 OperatingSystem/5.I:O.md                      |  71 ++++++
 ...07\344\273\266\347\256\241\347\220\206.md" |  74 ++++++
 ...13\351\227\264\351\200\232\344\277\241.md" |  54 +++-
 ...72\347\241\200\347\237\245\350\257\206.md" | 146 +++++++----
 ...255\346\224\276\345\231\250MediaPlayer.md" |  30 +++
 8 files changed, 737 insertions(+), 96 deletions(-)
 create mode 100644 "VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/2.\347\263\273\347\273\237\346\222\255\346\224\276\345\231\250MediaPlayer.md"

diff --git "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md" "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
index 82ba0f2a..0b4d80e4 100644
--- "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
+++ "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
@@ -10,6 +10,15 @@
 
 
 
+操作系统也是一种软件，但是操作系统是一种非常复杂的软件。操作系统提供了几种抽象模型
+
+- 文件：对 I/O 设备的抽象
+- 虚拟内存：对程序存储器的抽象
+- 进程：对一个正在运行程序的抽象
+- 虚拟机：对整个操作系统的抽象
+
+
+
 ### 以现代标准而言，一个标准PC的操作系统应该提供以下功能
 
 
@@ -76,7 +85,7 @@
 
 计算机由处理器、存储器和输入/输出部件组成，每类部件都有一个或多个模块。这些部件以某种方式互连，以实现计算机执行程序的主要功能。因此，计算机有4个主要的结构化部件: 
 
-- 处理器(Processor)：控制计算机的操作，执行数据处理功能。只有一个处理器时，它通常指中央处理器(CPU)
+- 处理器(Processor)：控制计算机的操作，执行数据处理功能。只有一个处理器时，它通常指中央处理器(CPU).
 - 内存（Main memory):存储数据和程序。此类存储器通常是易失性的，即当计算机关机时，存储器的内容会丢失。相对于此的是磁盘存储器，当计算机关机时，它的内容不会丢失。内存通常也称为实存储器(real memory)或主存储器(primary memory)。
 - 输入/输出模块(I/O modules):在计算机和外部环境之间移动数据。外部环境由各种外部设备组成，包括辅助存储器设备(如硬盘)、通信设备和终端。
 - 系统总线(System bus):在处理器、内存和输入/输出模块间提供通信的设施。 
@@ -148,9 +157,32 @@ Linux内核被装载后，就开始进行内核初始化的过程。
 
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_system_start.png)
 
+- Boot ROM: 当手机处于关机状态时，长按Power键开机，引导芯片开始从固化在`ROM`里的预设代码开始执行，然后加载引导程序到`RAM`；
+- Boot Loader：这是启动Android系统之前的引导程序，主要是检查RAM，初始化硬件参数等功能。
 
+Android平台的基础是Linux内核，比如ART虚拟机最终调用底层Linux内核来执行功能。Linux内核的安全机制为Android提供相应的保障，也允许设备制造商为内核开发硬件驱动程序。
 
+- 启动Kernel的swapper进程(pid=0)：该进程又称为idle进程, 系统初始化过程Kernel由无到有开创的第一个进程, 用于初始化进程管理、内存管理，加载Display,Camera Driver，Binder Driver等相关工作；
+- 启动kthreadd进程（pid=2）：是Linux系统的内核进程，会创建内核工作线程kworkder，软中断线程ksoftirqd，thermal等内核守护进程。`kthreadd进程是所有内核进程的鼻祖`。
 
+这里的Native系统库主要包括init孵化来的用户空间的守护进程、HAL层以及开机动画等。启动init进程(pid=1),是Linux系统的用户进程，`init进程是所有用户进程的鼻祖`。
+
+- init进程会孵化出ueventd、logd、healthd、installd、adbd、lmkd等用户守护进程；
+- init进程还启动`servicemanager`(binder服务管家)、`bootanim`(开机动画)等重要服务
+- init进程孵化出Zygote进程，Zygote进程是Android系统的第一个Java进程(即虚拟机进程)，`Zygote是所有Java进程的父进程`，Zygote进程本身是由init进程孵化而来的。
+
+- Zygote进程，是由init进程通过解析init.rc文件后fork生成的，Zygote进程主要包含：
+    - 加载ZygoteInit类，注册Zygote Socket服务端套接字
+    - 加载虚拟机
+    - 提前加载类preloadClasses
+    - 提前加载资源preloadResouces
+- System Server进程，是由Zygote进程fork而来，`System Server是Zygote孵化的第一个进程`，System Server负责启动和管理整个Java framework，包含ActivityManager，WindowManager，PackageManager，PowerManager等服务。
+- Media Server进程，是由init进程fork而来，负责启动和管理整个C++ framework，包含AudioFlinger，Camera Service等服务。
+- Zygote进程孵化出的第一个App进程是Launcher，这是用户看到的桌面App；
+- Zygote进程还会创建Browser，Phone，Email等App进程，每个App至少运行在一个进程上。
+- 所有的App进程都是由Zygote进程fork生成的。
+
+ 
 
 ## CPU(Central Processing Unit)
 
@@ -158,25 +190,35 @@ CPU(中央处理器)是计算机的大脑，它主要和内存进行交互，从
 
 
 
-**程序是把寄存器作为对象来描述的**
+CPU 主要由两部分构成：`控制单元` 和 `算术逻辑单元（ALU）`
 
-使用高级语言编写的程序会在编译后转化成机器语言，然后通过CPU内部的寄存器来处理。不同类型的CPU，其内部寄存器的数量，种类以及寄存器存储的数值范围都是不同的。根据功能的不同，我们可以将寄存器大致划分为八类: 
+- 控制单元：从内存中提取指令并解码执行
+- 算数逻辑单元（ALU）：处理算数和逻辑运算
 
-- ***累加寄存器简称累加器(Accumulator， AC)***：是一个通用寄存器。存储临时的执行运算的数据和运算后的数据。
+CPU 是计算机的心脏和大脑，它和内存都是由许多晶体管组成的电子部件。它接收数据输入，执行指令并处理信息。它与输入/输出（I / O）设备进行通信，这些设备向 CPU 发送数据和从 CPU 接收数据。
 
-- ***标志寄存器***：存储运算处理后的CPU的状态。
+CPU 的内部由**寄存器、控制器、运算器和时钟**四部分组成，各部分之间通过电信号连通。
 
-- ***程序计数器(Program Counter, PC)***：存储下一条指令所在内存的地址。
+- `寄存器`是中央处理器内的组成部分。它们可以用来暂存指令、数据和地址。可以将其看作是内存的一种。根据种类的不同，一个 CPU 内部会有 20 - 100个寄存器。
+- `控制器`负责把内存上的指令、数据读入寄存器，并根据指令的结果控制计算机
+- `运算器`负责运算从内存中读入寄存器的数据
+- `时钟` 负责发出 CPU 开始计时的时钟信号
 
-- ***基址寄存器***：存储数据内存的起始地址。
 
-- ***变址寄存器***：存储基址寄存器的相对地址。
 
-- ***通用寄存器***：存储任意数据。
+**程序是把寄存器作为对象来描述的**
 
-- ***指令寄存器(Instruction Register, IR)***：存储指令，CPU取到的指令存放在处理器的一个寄存器中，这个寄存器就是指令寄存器。CPU内部使用，程序员无法通过程序对该寄存器进行读写操作。
+使用高级语言编写的程序会在编译后转化成机器语言，然后通过CPU内部的寄存器来处理。不同类型的CPU，其内部寄存器的数量，种类以及寄存器存储的数值范围都是不同的。根据功能的不同，我们可以将寄存器大致划分为八类: 
 
-- ***栈寄存器***：存储栈区域的起始地址。
+- ***累加寄存器简称累加器(Accumulator， AC)***：是一个通用寄存器。存储临时的执行运算的数据和运算后的数据。
+- ***标志寄存器***：存储运算处理后的CPU的状态。
+- ***程序计数器(Program Counter, PC)***：记录将要取出的指令的地址。存储下一条指令所在内存的地址。
+- ***基址寄存器***：存储数据内存的起始地址。
+- ***变址寄存器***：存储基址寄存器的相对地址。
+- ***通用寄存器***：存储任意数据。
+- ***指令寄存器(Instruction Register, IR)***：记录最近取出的指令。存储指令，CPU取到的指令存放在处理器的一个寄存器中，这个寄存器就是指令寄存器。CPU内部使用，程序员无法通过程序对该寄存器进行读写操作。
+- ***堆栈寄存器(stack pointer)***：目的是跟踪调用堆栈，存储栈区域的起始地址。指向内存中当前栈的顶端。堆栈指针会包含输入过程中的有关参数、局部变量以及没有保存在寄存器中的临时变量。
+- **程序状态字寄存器(PSW(Program Status Word))**：这个寄存器是由操作系统维护的8个字节(64位) long 类型的数据集合。它会跟踪当前系统的状态。除非发生系统结束，否则我们可以忽略 PSW 。用户程序通常可以读取整个PSW，但通常只能写入其某些字段。PSW 在系统调用和 I / O 中起着重要作用。
 
 其中，程序计数器，累加寄存器，标志寄存器，指令寄存器和栈寄存器都只有一个，其他的寄存器一般有多个。
 
@@ -230,11 +272,25 @@ CPU(中央处理器)是计算机的大脑，它主要和内存进行交互，从
 
 
 
-### 中断
+#### 操作系统的两种CPU状态
+
+- 内核态(Kernel Mode):运行操作系统程序
+- 用户态(User Mode):运行用户程序
+
+操作系统只需要这两种状态，同时这两种状态由对应的两种指令: 
 
+- 特权(privilege)指令:只能由操作系统使用、用户程序不能使用的指令
+- 非特权指令:用户程序可以使用的指令
 
+用户态 -> 内核态的唯一途径是通过中断/异常/陷入机制。
 
+内核态 -> 用户态是通过设置程序状态字PSW。
 
+一旦 CPU 决定去实施中断后，程序计数器和 PSW 就会被压入到当前堆栈中并且 CPU 会切换到内核态。设备编号可以作为内存的一个引用，用来寻找该设备中断处理程序的地址。这部分内存称作`中断向量(interrupt vector)`。一旦中断处理程序（中断设备的设备驱动程序的一部分）开始后，它会移除栈中的程序计数器和 PSW 寄存器，并把它们进行保存，然后查询设备的状态。在中断处理程序全部完成后，它会返回到先前用户程序尚未执行的第一条指令。
+
+### 中断/异常
+
+可以说操作系统是由“中断驱动”或者“时间驱动”的。中断/异常是CPU对系统发生的某个事件作出的一种反应。
 
 所有计算机都提供了允许其他模块（I/O、存储器)中断处理器正常处理过程的机制。中断最初是用于提高处理器效率的一种手段。例如，多数I/O设备都要远慢于处理器，处理器必须暂停并保持空闲，直到打印机完成工作。暂停的时间长度可能相当于成百上千个不涉及存储器的指令周期，显然，这对于处理器的使用来说是非常浪费的。这种只有一个单独程序的情况，称为单道程序设计。在单道程序设计中处理器话费一定的运行时间进行计算，直到遇到一个I/O指令，这时它必须等到该I/O指令结束后才能继续执行。这种问题是可以避免的，就是存储器可以保存多个程序，在一个程序等待时通过切换去执行其他的程序，这种处理称为多道程序设计或多任务处理。它是现代操作系统的主要方案。多道程序设计的目的是为了让处理器和I/O设备（包括存储设备）同时保持忙状态，以实现最大的效率。
 
@@ -250,12 +306,38 @@ CPU(中央处理器)是计算机的大脑，它主要和内存进行交互，从
 
 
 
-### 中断处理
+### 举个栗子
+
+- 中断
+
+    有一天我正在看书的时候，来电话了，这时候我需要执行中断，我会把当前看到的书的进度用书签标记，然后去接电话，等电话接完后，再返回从书签的位置继续读书。
+
+- 异常
+
+    同样我在读书，但是由于新买的书纸张太硬，一不小心把手划破流血了，那这个时候就是异常，我同样需要把当前看到的书的进度用书签标记，然后去用创可贴来处理伤口，等处理完后再返回书签的位置继续读书。
 
 
 
 
 
+### 中断/异常机制工作原理
+
+硬件和软件相互配合而使计算机系统得以充分发挥能力。
+
+- 硬件的作用 -- 中断/异常响应
+
+    捕获中断源发出的中断/异常请求，以一定方式响应，将处理器控制权交给特定的处理程序。发现中断、接受中断都是由硬件来完成。
+
+- 软件的作用 -- 中断/异常处理程序
+
+    识别中断/异常类型并完成相应的处理。
+
+
+
+
+
+### 中断处理
+
 当I/O设备完成一次I/O操作时，发生以下硬件事件:  
 
 1. 设备给处理器发送一个中断信号。
@@ -270,6 +352,21 @@ CPU(中央处理器)是计算机的大脑，它主要和内存进行交互，从
 
 
 
+与每一 I/O 类相关联的是一个称作 `中断向量(interrupt vector)` 的位置（靠近内存底部的固定区域）。它包含中断服务程序的入口地址。假设当一个磁盘中断发生时，用户进程 3 正在运行，则中断硬件将程序计数器、程序状态字、有时还有一个或多个寄存器压入堆栈，计算机随即跳转到中断向量所指示的地址。这就是硬件所做的事情。然后软件就随即接管一切剩余的工作。
+
+当中断结束后，操作系统会调用一个 C 程序来处理中断剩下的工作。在完成剩下的工作后，会使某些进程就绪，接着调用调度程序，决定随后运行哪个进程。然后将控制权转移给一段汇编语言代码，为当前的进程装入寄存器值以及内存映射并启动该进程运行，下面显示了中断处理和调度的过程。
+
+1. 硬件压入堆栈程序计数器等
+2. 硬件从中断向量装入新的程序计数器
+3. 汇编语言过程保存寄存器的值
+4. 汇编语言过程设置新的堆栈
+5. C 中断服务器运行（典型的读和缓存写入）
+6. 调度器决定下面哪个程序先运行
+7. C 过程返回至汇编代码
+8. 汇编语言过程开始运行新的当前进程
+
+一个进程在执行过程中可能被中断数千次，但关键每次中断后，被中断的进程都返回到与中断发生前完全相同的状态。
+
 
 
 ## 存储器
@@ -377,10 +474,6 @@ CPU(中央处理器)是计算机的大脑，它主要和内存进行交互，从
 
 
 
-![](https://raw.githubusercontent.com/CharonChui/Pictures/master/![](https://raw.githubusercontent.com/CharonChui/Pictures/master/rtsp_rtp_rtcp.jpeg))
-
-
-
 - 应用和框架：应用开发者最关心这一层及访问低层服务的API。
 - Binder IPC：Binder进程间通信机制允许应用框架打破进程的界限来访问Android系统服务代码，从而允许系统的高层框架API与Android的系统服务进行交互。
 - Android系统服务：框架中大部分能够调用系统服务的接口都向开发者开放，以便开发者能够使用底层的硬件和内核功能。Android系统服务分为两部分：媒体服务处理播放和录制媒体文件，系统服务处理应用所需要的系统功能。
@@ -403,17 +496,44 @@ Android在Linux内核中增加了两个提升电源管理能力的新功能： 
 
 
 
+## 一个程序的执行过程
 
+```c
+#include <stdio.h>
+int main(int argc, char *argv[]) {
+    puts("hello world");
+    return 0;
+}
+```
 
-----
 
-- [下一篇:2.进程与线程](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/2.%E8%BF%9B%E7%A8%8B%E4%B8%8E%E7%BA%BF%E7%A8%8B.md)
+
+1. 用户通过命令或者图标点击等通知操作系统执行hello world程序。
+2. 操作系统会去找到hello world程序的相关信息，检查其类型是否是可执行文件，并通过程序的首部信息，确定代码和数据在可执行文件中的位置并计算出对应的磁盘块地址。
+3. 操作系统创建一个新的进程，并将hello world程序的执行文件映射到该进程结构，表示由该进程执行该hello world程序。
+4. 操作系统为hello world程序设置cpu上下文环境并跳到程序开始处。
+5. 执行hello world程序的第一条指令，这时候会发生缺页异常(内存中没有该程序)
+6. 操作系统开始分配一页物理内存，并将前面计算出的磁盘块地址将代码从磁盘读入内存，然后继续执行hello world程序。
+7. hello world程序执行puts函数(系统调用)，想要在显示器上写入字符串。
+8. 操作系统找到要将字符串送往的显示设备，通常设备是由一个进程控制的，所以，操作系统将要写的字符串送给该进程。
+9. 控制设备的进程告诉设备的窗口系统它要显示字符串。窗口系统确定这是一个合法的操作，然后将字符串转换成像素，将像素写入设备的存储影响区。
+10. 视频硬件将像素转换成显示器可接收的一组控制/数据信号。
+11. 显示器解释信号，激发液晶屏。
+12. 这样我们就能在屏幕上看到了"hello world"。
+
 
 
 
 
 
 
+----
+
+- [下一篇:2.进程与线程](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/2.%E8%BF%9B%E7%A8%8B%E4%B8%8E%E7%BA%BF%E7%A8%8B.md)
+
+
+
+
 
 
 ---
diff --git "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md" "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
index 8dd5f952..c96b8f66 100644
--- "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
+++ "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
@@ -1,14 +1,18 @@
 # 2.进程与线程
 
+### 为什么要引入进程的概念？
 
+我们知道I/O操作是耗时的，CPU在执行的一个程序的时候这个程序可能会有一些耗时的操作，而CPU的执行是非常快的，那如果这种情况下，CPU一直等待这个程序执行完耗时的操作再继续执行，就会导致CPU的使用率大大降低，为了提高CPU的使用率，就引入了多道程序设计，也就是说有多个程序执行，当执行到一个程序时如果遇到耗时的操作，那CPU就切换到另一个程序继续执行，等第一个程序的耗时操作执行完后再切换到第一个程序执行，这个切换过程不能只切换PC的指针，还需要记录一些其他的程序的信息，所以为了描述这种程序的信息，引入了进程的概念。
 
-狭义定义：进程是正在运行的程序的实例（an instance of a computer program that is being executed）。
 
-广义定义：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是[操作系统](https://baike.baidu.com/item/操作系统/192)动态执行的[基本单元](https://baike.baidu.com/item/基本单元)，在传统的[操作系统](https://baike.baidu.com/item/操作系统)中，进程既是基本的[分配单元](https://baike.baidu.com/item/分配单元)，也是基本的执行单元。
 
-进程的概念主要有两点：第一，进程是一个实体。每一个进程都有它自己的地址空间，一般情况下，包括[文本](https://baike.baidu.com/item/文本)区域（text region）、数据区域（data region）和[堆栈](https://baike.baidu.com/item/堆栈)（stack region）。文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分配的内存；堆栈区域存储着活动过程调用的指令和本地变量。第二，进程是一个“执行中的程序”。程序是一个没有生命的实体，只有[处理](https://baike.baidu.com/item/处理)器赋予程序生命时（操作系统执行之），它才能成为一个活动的实体，我们称其为[进程](https://baike.baidu.com/item/进程)。
+## 进程概念
 
+狭义定义：进程是正在运行的程序的实例（an instance of a computer program that is being executed）。
 
+广义定义：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是[操作系统](https://baike.baidu.com/item/操作系统/192)动态执行的[基本单元](https://baike.baidu.com/item/基本单元)，在传统的[操作系统](https://baike.baidu.com/item/操作系统)中，进程既是基本的[分配单元](https://baike.baidu.com/item/分配单元)，也是基本的执行单元。
+
+进程的概念主要有两点：第一，进程是一个实体。每一个进程都有它自己的地址空间，一般情况下，包括[文本](https://baike.baidu.com/item/文本)区域（text region）、数据区域（data region）和[堆栈](https://baike.baidu.com/item/堆栈)（stack region）。文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分配的内存；堆栈区域存储着活动过程调用的指令和本地变量。第二，进程是一个“执行中的程序”。程序是一个没有生命的实体，只有[处理](https://baike.baidu.com/item/处理)器赋予程序生命时（操作系统执行之），它才能成为一个活动的实体，我们称其为[进程](https://baike.baidu.com/item/进程)。可以简单的理解为：进程 = 资源 + 指令执行序列。
 
 进程是60年代初首先由[麻省理工学院](https://baike.baidu.com/item/麻省理工学院)的[MULTICS系统](https://baike.baidu.com/item/MULTICS系统)和IBM公司的[CTSS](https://baike.baidu.com/item/CTSS)/360系统引入的。
 
@@ -62,7 +66,7 @@
 
 
 
-## 进程的状态
+## 进程的状态(五状态进程模型)
 
 
 
@@ -88,7 +92,9 @@
 - 数据段：对应程序执行时所需要的数据部分，包括数据，堆栈和工作区。
 - 进程控制块(Process Control Block, PCB) ：描述进程的基本信息和运行状态，记录了进程运行时所需要的全部信息，它是进程存在的唯一标识，与进程一一对应。所谓的创建进程和撤销进程，都是指对PCB的操作。
 
-#### 进程控制块
+#### 进程控制块(PCB)
+
+又称进程描述符、进程属性，是操作系统用于管理进程的一个专门数据结构。PCB是操作系统感知进程存在的唯一标志。进程和PCB是一一对应的。
 
 进程执行的任意时刻，都可由如下元素来表征:  
 
@@ -105,6 +111,8 @@
 
 
 
+进程表: 所有进程的PCB集合。
+
 ## 进程创建
 
 操作系统决定创建一个新进程时，会按如下步骤操作:  
@@ -119,8 +127,24 @@
 
 ## 进程切换
 
+
+
+### 进程表(Process Table)
+
 操作系统为了执行进程间的切换，会维护着一张表格，这张表就是进程表(process table)。每个进程占用一个进程表项。该表项包含了进程状态的重要信息，包括程序计数器、堆栈指针、内存分配状况、所打开文件的状态、账号和调度信息，以及其他在进程由运行态转换到就绪态或阻塞态时所必须保存的信息，从而保证该进程随后能再次启动，就像从未被中断过一样。
 
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/process_table.png?raw=true)  
+
+上面是典型的进程表表项中的一些字段:  
+
+第一列内容与进程管理有关，第二列内容与存储管理有关，第三列内容与文件管理有关。
+
+
+
+
+
+
+
 **操作系统最底层的就是调度程序**，在它上面有许多进程。所有关于中断处理、启动进程和停止进程的具体细节都隐藏在调度程序中。事实上，调度程序只是一段非常小的程序。
 
 表面上看，进程切换很简单。在某个时刻，操作系统中断一个正在运行的进程，将另一个进程置于运行模式，并把控制权交给后者。然而，这会引发若干个问题。首先，什么事件触发了进程的切换？ 其次，必须认识到模式切换和进程切换键的区别。
@@ -171,31 +195,61 @@
 
 
 
-进程间的信息交换，具体内容分为：控制信息交换和数据交换，控制信息的交换为低级通信，数据的交换为高级通信。
+以Linux为例，进程间的信息交换，具体内容分为：控制信息交换和数据交换，控制信息的交换为低级通信，数据的交换为高级通信。
 
-- 信号
+- Socket套接字
+
+    socket 提供端到端的双相通信。一个套接字可以与一个或多个进程关联。就像管道有命令管道和未命名管道一样，套接字也有两种模式，套接字一般用于两个进程之间的网络通信，网络套接字需要来自诸如TCP（传输控制协议）或较低级别UDP（用户数据报协议）等基础协议的支持。
+
+- Signals信号/信号量
+
+    两个或多个进程可以通过简单的信号进行合作，可以强迫一个进程在某个位置停止，直到它接收到一个特定的信号。信号量是一个特殊的变量。用于进程间传递信息的一个整数值。
+
+    信号是 UNIX 系统最先开始使用的进程间通信机制，因为 Linux 是继承于 UNIX 的，所以 Linux 也支持信号机制，通过向一个或多个进程发送`异步事件信号`来实现，信号可以从键盘或者访问不存在的位置等地方产生；信号通过 shell 将任务发送给子进程。
+
+    你可以在 Linux 系统上输入 `kill -l` 来列出系统使用的信号。
+
+    进程可以选择忽略发送过来的信号，但是有两个是不能忽略的：`SIGSTOP` 和 `SIGKILL` 信号。SIGSTOP 信号会通知当前正在运行的进程执行关闭操作，SIGKILL 信号会通知当前进程应该被杀死。除此之外，进程可以选择它想要处理的信号，进程也可以选择阻止信号，如果不阻止，可以选择自行处理，也可以选择进行内核处理。如果选择交给内核进行处理，那么就执行默认处理。
+
+    操作系统会中断目标程序的进程来向其发送信号、在任何非原子指令中，执行都可以中断，如果进程已经注册了新号处理程序，那么就执行进程，如果没有注册，将采用默认处理的方式。
 
-    两个或多个进程可以通过简单的信号进行合作，可以强迫一个进程在某个位置停止，直到它接收到一个特定的信号。
+- Shared Memory共享内存
 
-- 共享存储系统
+    多台服务器访问同一个存储设备的同一分区。
 
-    多台服务器访问同一个存储设备的同一分区
+    两个进程之间还可以通过共享内存进行进程间通信，其中两个或者多个进程可以访问公共内存空间。两个进程的共享工作是通过共享内存完成的，一个进程所作的修改可以对另一个进程可见(很像线程间的通信)。
 
-- 消息传递系统
+- Message Queue消息传递系统/消息队列
 
     进程与其它的进程进行通信而不必借助共享数据，通过互相发送和接收消息，建立一条通信链路。
 
-- 管道通信
+    一听到消息队列这个名词你可能不知道是什么意思，消息队列是用来描述内核寻址空间内的内部链接列表。可以按几种不同的方式将消息按顺序发送到队列并从队列中检索消息。每个消息队列由 IPC 标识符唯一标识。消息队列有两种模式，一种是`严格模式`， 严格模式就像是 FIFO 先入先出队列似的，消息顺序发送，顺序读取。还有一种模式是 `非严格模式`，消息的顺序性不是非常重要。
 
-    发送进程以字符流形式将大量数据送入管道，接收进程可从管道接收数据，二者利用管道进行通信，管道是单向的、先进先出的，它把一个进程的输出和另一个进程的输入连接在一起。一个进程（写进程）在管道的尾部写入数据，另一个进程（读进程）从管道的头部读出数据。每次只有一个进程能够真正地进入管道，其他的只能等待。
+- Pipe管道通信
+
+    在两个进程之间，可以建立一个通道，一个进程向这个通道里写入字节流，另一个进程从这个管道中读取字节流。管道是同步的，当进程尝试从空管道读取数据时，该进程会被阻塞，直到有可用数据为止。shell 中的`管线 pipelines` 就是用管道实现的，当 shell 发现输出
 
+    发送进程以字符流形式将大量数据送入管道，接收进程可从管道接收数据，二者利用管道进行通信，管道是单向的、先进先出的，它把一个进程的输出和另一个进程的输入连接在一起。一个进程（写进程）在管道的尾部写入数据，另一个进程（读进程）从管道的头部读出数据。每次只有一个进程能够真正地进入管道，其他的只能等待。
+    
+    
+    
     管道分为无名管道和命名管道，前者用于父子进程通信，后者用于任意进程通信。
+    
+    入先出队列 FIFO 通常被称为 `命名管道(Named Pipes)`，命名管道的工作方式与常规管道非常相似，但是确实有一些明显的区别。未命名的管道没有备份文件：操作系统负责维护内存中的缓冲区，用来将字节从写入器传输到读取器。一旦写入或者输出终止的话，缓冲区将被回收，传输的数据会丢失。相比之下，命名管道具有支持文件和独特 API ，命名管道在文件系统中作为设备的专用文件存在。当所有的进程通信完成后，命名管道将保留在文件系统中以备后用。命名管道具有严格的 FIFO 行为，写入的第一个字节是读取的第一个字节，写入的第二个字节是读取的第二个字节，依此类推。
+    
+    
+    
+    
+    
+    
+    
+    
 
 
 
 ## 进程调度
 
-进程调度就是处理器调度(上下文切换)
+当一个计算机是多道程序设计系统时，会频繁的有很多进程或者线程来同时竞争 CPU 时间片。当两个或两个以上的进程/线程处于就绪状态时，就会发生这种情况。如果只有一个 CPU 可用，那么必须选择接下来哪个进程/线程可以运行。操作系统中有一个叫做调度程序(scheduler) 的角色存在，它就是做这件事儿的，该程序使用的算法叫做调度算法(scheduling algorithm) 。进程调度就是处理器调度(上下文切换)。
 
 ### 调度级别
 
@@ -223,18 +277,56 @@
 
 ### 调度算法
 
-- 先进先出
+- 先来先服务(first-come,first-serverd)
 
     按照进入就绪队列的进程顺序，不加其他条件干涉
 
-- 短进程优先
+- 最短作业优先(Shortest Job First)
 
     优先选出就绪队列中CPU执行时间最短的进程，例如：就绪队列有4个进程P1，P2，P3，P4，执行时间为：16,12,4,3 按照短进程优先，则周转时间(从进程提交到进程完成的时间间隔)分别为：35,19,7,3
-    平均周转时间：16，平均周转时间越小，调度性能越好
+    平均周转时间：16，平均周转时间越小，调度性能越好。
+
+    在所有的进程都可以运行的情况下，最短作业优先的算法才是最优的。
+
+- 最短剩余时间优先(Shortest Remaining Time Next)
+
+    使用这个算法，调度程序总是选择剩余运行时间最短的那个进程运行。
 
 - 轮转法
-    - 简单轮转： 就绪进程按FIFO排队，按照一定时间间隔让处理机分配给队列中的进程，就绪队列中**所有队列均可获得一个时间片的处理器运行**
-    - 多级队列： 让系统中所有进程分成若干类，每类一级
+    
+    一种最古老、最简单、最公平并且最广泛使用的算法就是轮询算法(round-robin)。每个进程都会被分配一个时间段，称为时间片(quantum)，在这个时间片内允许进程运行。如果时间片结束时进程还在运行的话，则抢占一个 CPU 并将其分配给另一个进程。如果进程在时间片结束前阻塞或结束，则 CPU 立即进行切换。轮询算法比较容易实现。调度程序所做的就是维护一个可运行进程的列表，就像下图中的 a，当一个进程用完时间片后就被移到队列的末尾。
+    
+    - 简单轮转： 就绪进程按FIFO排队，按照一定时间间隔让处理机分配给队列中的进程，就绪队列中所有队列均可获得一个时间片的处理器运行。
+    - 多级队列： 让系统中所有进程分成若干类，每类一级。
+    
+- 优先级调度
+
+    每个进程都被赋予一个优先级，优先级高的进程优先运行。
+
+
+
+
+
+## 内核栈与用户栈的区别
+
+每个进程一般会有两个栈，一个用户栈，一个内核栈，存在于内核空间。
+
+当进程在用户空间运行时，cpu堆栈指针寄存器里面的内容时用户堆栈的地址，使用的是用户栈。
+
+当进程在内核空间时，cpu堆栈指针寄存器里的内容是内核栈空间的地址，使用内核栈。
+
+内核栈是**内存**中属于操作系统空间的一块区域，主要用途为：
+
+- 保护中断现场
+- 保护操作系统子程序间相互调用的参数、返回值、返回点以及子程序函数的局部变量
+
+用户栈是用户进程空间中的一块区域，用于保存用户进程的子程序间相互作用的参数、返回值以及相关局部变量
+
+**当进程因为中断或者系统调用而陷入内核态，进程所使用的堆栈也要从用户栈转到内核栈**。进程陷入内核态后，先把用户态堆栈的地址保存在内核栈中，然后设置堆栈指针寄存器的内容为内核栈的地址，这样就完成了用户栈到内核栈的转换。**当进程从内核态回复为用户态时，在内核态之后的最后将保存在内核栈里面的用户栈地址恢复到堆栈指针寄存器即可**。这样就实现了内核栈和用户栈的互转。
+
+注意：**每次进程从用户态陷入内核的时候得到的内核栈都是空的，所以在进程陷入内核的时候，直接把内核栈的栈顶地址给堆栈指针寄存器即可。**
+
+
 
 ## 死锁
 
@@ -453,6 +545,111 @@ Android使用的进程有些不同。活动管理器是Android负责正在运行
 
 多线程技术是指把执行一个应用程序的进程划分为可以同时运行的多个线程。
 
+为什么要有线程呢？ 
+
+在传统的操作系统中，每个进程都有一个地址空间和一个控制线程。事实上，这是大部分进程的定义。不过，在许多情况下，经常存在同一地址空间中运行多个控制线程的情形，这些线程就像是分离的进程。
+
+上面说到进程 = 资源 + 指令执行序列。那能不能将资源和指令执行分开，组合成一个资源 + 多个指令执行序列的方式？ 这种不切换资源，只切换执行指令的方式就是线程。线程保留了并发的优点，避免了进程切换的代价。
+
+
+
+线程不像是进程那样具备较强的独立性。同一个进程中的所有线程都会有完全一样的地址空间，这意味着它们也共享同样的全局变量。由于每个线程都可以访问进程地址空间内每个内存地址，**「因此一个线程可以读取、写入甚至擦除另一个线程的堆栈」**。线程之间除了共享同一内存空间外，还具有如下不同的内容
+
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/process_thread_compare.png?raw=true)  
+
+上图左边的是同一个进程中`每个线程共享`的内容，上图右边是`每个线程`中的内容。也就是说左边的列表是进程的属性，右边的列表是线程的属性。
+
+**「线程之间的状态转换和进程之间的状态转换是一样的」**。
+
+每个线程都会有自己的堆栈，如下图所示
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/thread_heap.png?raw=true)  
+
+#### 线程系统调用
+
+进程通常会从当前的某个单线程开始，然后这个线程通过调用一个库函数（比如 `thread_create`）创建新的线程。线程创建的函数会要求指定新创建线程的名称。创建的线程通常都返回一个线程标识符，该标识符就是新线程的名字。
+
+当一个线程完成工作后，可以通过调用一个函数（比如 `thread_exit`）来退出。紧接着线程消失，状态变为终止，不能再进行调度。在某些线程的运行过程中，可以通过调用函数例如 `thread_join` ，表示一个线程可以等待另一个线程退出。这个过程阻塞调用线程直到等待特定的线程退出。在这种情况下，线程的创建和终止非常类似于进程的创建和终止。
+
+另一个常见的线程是调用 `thread_yield`，它允许线程自动放弃 CPU 从而让另一个线程运行。这样一个调用还是很重要的，因为不同于进程，线程是无法利用时钟中断强制让线程让出 CPU 的。
+
+
+
+### 线程实现
+
+主要有三种实现方式
+
+- 在用户空间中实现线程；
+- 在内核空间中实现线程；
+- 在用户和内核空间中混合实现线程。
+
+下面我们分开讨论一下
+
+#### 在用户空间中实现线程
+
+第一种方法是把整个线程包放在用户空间中，内核对线程一无所知，它不知道线程的存在。所有的这类实现都有同样的通用结构
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/thread_user.png?raw=true)  
+
+> `运行时系统(Runtime System)` 也叫做运行时环境，该运行时系统提供了程序在其中运行的环境。此环境可能会解决许多问题，包括应用程序内存的布局，程序如何访问变量，在过程之间传递参数的机制，与操作系统的接口等等。编译器根据特定的运行时系统进行假设以生成正确的代码。通常，运行时系统将负责设置和管理堆栈，并且会包含诸如垃圾收集，线程或语言内置的其他动态的功能。
+
+在用户空间管理线程时，每个进程需要有其专用的`线程表(thread table)`，用来跟踪该进程中的线程。这些表和内核中的进程表类似，不过它仅仅记录各个线程的属性，如每个线程的程序计数器、堆栈指针、寄存器和状态。该线程表由运行时系统统一管理。当一个线程转换到就绪状态或阻塞状态时，在该线程表中存放重新启动该线程的所有信息，与内核在进程表中存放的信息完全一样。
+
+
+
+在用户空间中实现线程要比在内核空间中实现线程具有这些方面的优势：考虑如果在线程完成时或者是在调用 `pthread_yield` 时，必要时会进程线程切换，然后线程的信息会被保存在运行时环境所提供的线程表中，然后，线程调度程序来选择另外一个需要运行的线程。保存线程的状态和调度程序都是`本地过程`，**所以启动他们比进行内核调用效率更高。因而不需要切换到内核，也就不需要上下文切换，也不需要对内存高速缓存进行刷新，因为线程调度非常便捷，因此效率比较高**。
+
+在用户空间实现线程还有一个优势就是**它允许每个进程有自己定制的调度算法**。例如在某些应用程序中，那些具有垃圾收集线程的应用程序（知道是谁了吧）就不用担心自己线程会不会在不合适的时候停止，这是一个优势。用户线程还具有较好的可扩展性，因为内核空间中的内核线程需要一些表空间和堆栈空间，如果内核线程数量比较大，容易造成问题。
+
+
+
+尽管在用户空间实现线程会具有一定的性能优势，但是劣势还是很明显的，你如何实现`阻塞系统调用`呢？假设在还没有任何键盘输入之前，一个线程读取键盘，让线程进行系统调用是不可能的，因为这会停止所有的线程。所以，**使用线程的一个目标是能够让线程进行阻塞调用，并且要避免被阻塞的线程影响其他线程**。
+
+与阻塞调用类似的问题是`缺页中断`问题，实际上，计算机并不会把所有的程序都一次性的放入内存中，如果某个程序发生函数调用或者跳转指令到了一条不在内存的指令上，就会发生页面故障，而操作系统将到磁盘上取回这个丢失的指令，这就称为`缺页故障`。而在对所需的指令进行读入和执行时，相关的进程就会被阻塞。如果只有一个线程引起页面故障，内核由于甚至不知道有线程存在，通常会把整个进程阻塞直到磁盘 I/O 完成为止，尽管其他的线程是可以运行的。
+
+另外一个问题是，如果一个线程开始运行，该线程所在进程中的其他线程都不能运行，除非第一个线程自愿的放弃 CPU，在一个单进程内部，没有时钟中断，所以不可能使用轮转调度的方式调度线程。除非其他线程能够以自己的意愿进入运行时环境，否则调度程序没有可以调度线程的机会。
+
+### 在内核中实现线程
+
+现在我们考虑使用内核来实现线程的情况，此时不再需要运行时环境了。另外，每个进程中也没有线程表。相反，在内核中会有用来记录系统中所有线程的线程表。当某个线程希望创建一个新线程或撤销一个已有线程时，它会进行一个系统调用，这个系统调用通过对线程表的更新来完成线程创建或销毁工作。
+
+当某个线程希望创建一个新线程或撤销一个已有线程时，它会进行一个系统调用，这个系统调用通过对线程表的更新来完成线程创建或销毁工作。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/thread_kernel.png?raw=true)  
+
+内核中的线程表持有每个线程的寄存器、状态和其他信息。这些信息和用户空间中的线程信息相同，但是位置却被放在了内核中而不是用户空间中。另外，内核还维护了一张进程表用来跟踪系统状态。
+
+所有能够阻塞的调用都会通过系统调用的方式来实现，当一个线程阻塞时，内核可以进行选择，是运行在同一个进程中的另一个线程（如果有就绪线程的话）还是运行一个另一个进程中的线程。但是在用户实现中，运行时系统始终运行自己的线程，直到内核剥夺它的 CPU 时间片（或者没有可运行的线程存在了）为止。
+
+
+
+由于在内核中创建或者销毁线程的开销比较大，所以某些系统会采用可循环利用的方式来回收线程。当某个线程被销毁时，就把它标志为不可运行的状态，但是其内部结构没有受到影响。稍后，在必须创建一个新线程时，就会重新启用旧线程，把它标志为可用状态。
+
+如果某个进程中的线程造成缺页故障后，内核很容易的就能检查出来是否有其他可运行的线程，如果有的话，在等待所需要的页面从磁盘读入时，就选择一个可运行的线程运行。这样做的缺点是系统调用的代价比较大，所以如果线程的操作（创建、终止）比较多，就会带来很大的开销。
+
+
+
+## 在用户和内核空间中混合实现线程
+
+结合用户空间和内核空间的优点，设计人员采用了一种`内核级线程`的方式，然后将用户级线程与某些或者全部内核线程多路复用起来
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/user_kernel_thread_os.png?raw=true)  
+
+在这种模型中，编程人员可以自由控制用户线程和内核线程的数量，具有很大的灵活度。采用这种方法，内核只识别内核级线程，并对其进行调度。其中一些内核级线程会被多个用户级线程多路复用。
+
+
+
+**导致系统出现死锁的情况**
+
+死锁的出现需要同时满足下面四个条件
+
+> - 互斥(Mutual Exclusion)：一次只能有一个进程使用资源。如果另一个进程请求该资源，则必须延迟请求进程，直到释放该资源为止。
+> - 保持并等待(Hold and Wait)：必须存在一个进程，该进程至少持有一个资源，并且正在等待获取其他进程当前所持有的资源。
+> - 无抢占(No Preemption)：资源不能被抢占，也就是说，在进程完成其任务之后，只能由拥有它的进程自动释放资源。
+> - 循环等待(Circular Wait) ：必须存在一组 {p0，p1，..... pn} 的等待进程，使 p0 等待 p1 持有的资源，p1 等待由 p2 持有的资源， pn-1 正在等待由 pn 持有的资源，而 pn 正在等待由 p0 持有的资源。
+
 
 
 ### 进程和线程的区别
@@ -467,7 +664,7 @@ Android使用的进程有些不同。活动管理器是Android负责正在运行
 - 线程（thread）：可分派的工作单元。它包括处理器上下文环境（包含程序计数器和栈指针）和栈中自身的数据区域。线程顺序执行且可以中断，因此处理器可以转到另一个线程。
 - 进程（process)：一个或多个线程和相关系统资源（如包含程序和代码的存储空间、打开的文件和设备）的集合。它严格对应于一个正在执行的程序的概念。通过把一个应用程序分解成多个线程，程序员可以很大程度上控制应用程序的模块性及相关事件的时间安排。
 
-线程比进程更轻量级，所以它们比进程更容易（更快）创建，也更容易撤销。在许多系统中，创建一个线程比创建一个进程要快10~100倍。
+线程比进程更轻量级，所以它们比进程更容易（更快）创建，也更容易撤销。在许多系统中，创建一个线程比创建一个进程要快10~100倍。线程会共享它所在进程的地址空间和其他资源。
 
 
 
diff --git "a/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md" "b/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
index 33824b74..31ab0e09 100644
--- "a/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
+++ "b/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
@@ -34,6 +34,21 @@
 
 上述几种内存区域中数据段、BSS和堆通常是被连续存储的——内存位置上是连续的，而代码段和栈往往会被独立存放。有趣的是，堆和栈两个区域关系很“暧昧”，他们一个向下“长”（i386体系结构中栈向下、堆向上），一个向上“长”，相对而生。但你不必担心他们会碰头，因为他们之间间隔很大（到底大到多少，你可以从下面的例子程序计算一下），绝少有机会能碰到一起。
 
+## 地址空间
+
+如果要使多个应用程序同时运行在内存中，必须要解决两个问题：`保护`和 `重定位`。第一种解决方式是用`保护密钥标记内存块`，并将执行过程的密钥与提取的每个存储字的密钥进行比较。这种方式只能解决第一种问题（破坏操作系统），但是不能解决多进程在内存中同时运行的问题。
+
+还有一种更好的方式是创造一个存储器抽象：`地址空间(the address space)`。就像进程的概念创建了一种抽象的 CPU 来运行程序，地址空间也创建了一种抽象内存供程序使用。
+
+#### 基址寄存器和变址寄存器
+
+最简单的办法是使用`动态重定位(dynamic relocation)`技术，它就是通过一种简单的方式将每个进程的地址空间映射到物理内存的不同区域。还有一种方式是使用基址寄存器和变址寄存器。
+
+- 基址寄存器：存储数据内存的起始位置
+- 变址寄存器：存储应用程序的长度。
+
+每当进程引用内存以获取指令或读取、写入数据时，CPU 都会自动将`基址值`添加到进程生成的地址中，然后再将其发送到内存总线上。同时，它检查程序提供的地址是否大于或等于`变址寄存器` 中的值。如果程序提供的地址要超过变址寄存器的范围，那么会产生错误并中止访问。
+
 
 
 ## 内存的演变
@@ -90,7 +105,17 @@ Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自
 
 ### 伙伴系统
 
-固定分区和动态分区方案都有缺陷。固定分区方案限制了活动进程数量，且如果可用分区的大小与进程大小很不匹配，那么内存空间的利用率会非常低。动态分区的维护特别复杂，并且会引入进行压缩的额外开销。更有吸引力的一种折中方案是伙伴系统。 
+固定分区和动态分区方案都有缺陷。固定分区方案限制了活动进程数量，且如果可用分区的大小与进程大小很不匹配，那么内存空间的利用率会非常低。动态分区的维护特别复杂，并且会引入进行压缩的额外开销。更有吸引力的一种折中方案是伙伴系统。 它是一种经典的内存分配方案，是一种特殊的“分离适配”算法。主要思想是将内存按2的幂进行划分，组成若干空闲块链表，查找该链表找到能满足进程需求的最佳匹配块。
+
+算法: 
+
+- 首先将整个可用空间看做一块：2的幂，这里假设一共有1M的内存。
+- 假设进程申请的空间大小为s，这里假设为100k，如果满足2的u-1次幂 < s <= 2的u次幂，则分配整个块，否则，将块划分为两个大小相等的伙伴，大小为2的u-1次幂，那这两个大小相等的伙伴就是伙伴关系。等内存回收后，具有伙伴关系的两块还可以合并到一起，组成一个更大的内存块。
+    - 1M内存分为两块。
+    - 512k、512k仍然大于100k，将第一块再分为两块。
+    - 256k、256k、512k，而第一块256k仍然大于100k，第一块256k再分配。
+    - 128k、128k、256k、512k。这个时候64k < 100k < 128k，所以把第一个128k分配给当前申请100k内存的进程。
+    - 等该进程的内存回收后，前两个128k的内存具有伙伴关系，还可以合并成256k。合并后和后面的256k又是一个伙伴，又合并成512k，发现和后面的512k又是一个伙伴，就又合并成了1M的内存块。
 
 
 
@@ -101,11 +126,13 @@ Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自
 在大小相等的分区中一个进程在其声明周期中可能占据不同的分区。首次创建一个进程映像时，它被装入内存中的某个分区。以后该进程可能被换出，当它再次被换入时，可能被指定到与上一次不同的分区中。动态分区也存在同样的情况，压缩后内存中的进程也可能发生移动。因此，进程访问（指令和数据单元）的位置不是固定的。进程被换入或在内存中移动时，指令和数据单元的位置也发生变化。为了解决这个问题，需要区分几种地址类型： 
 
 - 逻辑地址（logical address）是指与当前数据在内存中的物理分配地址无关的访问地址，在执行对内存的访问之前必须把它转换为物理地址。
-- 相对地址（relative address）是逻辑地址的一个特例，他是相对于某些已知点（通常是程序的开始处）的存储单元。
+- 相对地址（relative address）是逻辑地址的一个特例，他是相对于某些已知点（通常是程序的开始处）的存储单元。用户程序经过编译、汇编后形成目标代码，目标代码通常采用相对地址的形式，其首地址为0，其余地址相对于首地址而编址。
 - 物理地址（physical address）或绝对地址是数据在内存中的实际位置。
 
 系统采用运行时动态加载的方式把使用相对地址的程序加载到内存。通常情况下，被加载进程中所有内存访问都相对于程序的开始点。因此，在执行包括这类访问的指令时，需要有把相对地址转换为物理内存地址的硬件机制。这类地址转换就需要一个特殊的处理器寄存器（基址寄存器），其内容是程序在内存中的起始地址。还有一个界限寄存器指明程序的终止位置。
 
+将逻辑地址转换为物理地址的操作就叫做重定位。而把地址进行转换的功能部件就叫做内存管理单元(MMU， Memory Management Unit)。
+
 
 
 ### 分页
@@ -126,7 +153,7 @@ Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自
 
 ### 分段
 
-细分用户程序的另一种可选方案是分段。采用分段技术，可以把程序和与其相关的数据划分到几个段（fragment）中。尽管段有最大长度限制，但并不要求所有程序的所有段的长度都相等。和分页一样，采用分段技术时的逻辑地址也是由两部分组成：段号和偏移量。 
+细分用户程序的另一种可选方案是分段。采用分段技术，可以把用户进程地址空间按程序的自身的逻辑关系和与其相关的数据划分到几个段（fragment）中。尽管段有最大长度限制，但并不要求所有程序的所有段的长度都相等。同样内存空间也会被动态的划分为若干长度不相同的取悦，称为物理段，每个物理段由起始地址和长度确定。和分页一样，采用分段技术时的逻辑地址也是由两部分组成：段号和偏移量。 以段为单位进行分配，每段在内存中占据连续空间，但各段之间可以不相邻。
 
 由于使用大小不等的段，分段类似于动态分区。在未采用覆盖方案或使用虚存的情况下，为执行一个程序，需要把它的所有段都装入内存。与动态分区不同的是，在分段方案中，一个程序可以占据多个分区，并且这些分区不要求是连续的。分段消除了内部碎片，但是和动态分区一样，他会产生外部碎片。不过由于进程被分成多个小块，因此外部碎片也会很小。
 
@@ -154,12 +181,22 @@ Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自
 
 
 
+### 段页式存储管理方案
+
+综合页式、段式方案的优点，客服两者的缺点。用户进程先按段划分，每一段再按页面划分。内存分配还是以页为单位进行分配。
+
+
+
+
+
 
 
 ## 虚拟内存
 
 面对越来越大的程序,常常产生程序>内存的问题,为解决这种问题,虚拟内存的概念得到普及.
 
+虚拟内存是一种内存分配方案，是一项可以用来辅助内存分配的机制。我们知道，应用程序是按页装载进内存中的。但并不是所有的页都会装载到内存中，计算机中的硬件和软件会将数据从 RAM 临时传输到磁盘中来弥补内存的不足。如果没有虚拟内存的话，一旦你将计算机内存填满后，计算机会对你说呃，不，对不起，您无法再加载任何应用程序，请关闭另一个应用程序以加载新的应用程序。对于虚拟内存，计算机可以执行操作是查看内存中最近未使用过的区域，然后将其复制到硬盘上。虚拟内存通过复制技术实现了 妹子，你快来看哥哥能装这么多程序 的资本。复制是自动进行的，你无法感知到它的存在。
+
 要有效的使用处理器和I/O设备，就需要在内存中保留尽可能多的进程。此外，还需要解除程序在开发时对程序使用内存大小的限制。解决这两个问题的途径就是虚拟内存技术。采用虚拟内存技术时，所有的地址访问都是逻辑访问，并在运行时转换为实地址。
 
 虚拟内存机制使得期望运行大于物理内存的程序成为可能。其方法是将程序放在磁盘上，而将主存作为一种缓存，用来保存最频繁使用的部分程序。这种机制需要快速的映像内存地址，以便把程序生成的地址转换为有关字节在RAM中的物理地址。这种映像由CPU中的一个称为存储器管理单元（Memory Management Unit，MMU）的部件来完成。
@@ -211,7 +248,17 @@ Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自
 
 以便处理在必须读取一个新页时，应该置换内存中的哪一页。当内存中的所有页框都被占据，且需要读取一个新页以处理一次缺页中断时，置换策略决定置换当前内存中的哪一页。所有策略的目标都是移出最近最不能访问的页。
 
+- `最优算法`在当前页面中置换最后要访问的页面。不幸的是，没有办法来判定哪个页面是最后一个要访问的，`因此实际上该算法不能使用`。然而，它可以作为衡量其他算法的标准。
+- `NRU` 算法根据 R 位和 M 位的状态将页面氛围四类。从编号最小的类别中随机选择一个页面。NRU 算法易于实现，但是性能不是很好。存在更好的算法。
+- `FIFO` 会跟踪页面加载进入内存中的顺序，并把页面放入一个链表中。有可能删除存在时间最长但是还在使用的页面，因此这个算法也不是一个很好的选择。
+- `第二次机会`算法是对 FIFO 的一个修改，它会在删除页面之前检查这个页面是否仍在使用。如果页面正在使用，就会进行保留。这个改进大大提高了性能。
+- `时钟` 算法是第二次机会算法的另外一种实现形式，时钟算法和第二次算法的性能差不多，但是会花费更少的时间来执行算法。
+- `LRU` 算法是一个非常优秀的算法，但是没有`特殊的硬件(TLB)`很难实现。如果没有硬件，就不能使用 LRU 算法。
+- `NFU` 算法是一种近似于 LRU 的算法，它的性能不是非常好。
+- `老化` 算法是一种更接近 LRU 算法的实现，并且可以更好的实现，因此是一个很好的选择
+- 最后两种算法都使用了工作集算法。工作集算法提供了合理的性能开销，但是它的实现比较复杂。`WSClock` 是另外一种变体，它不仅能够提供良好的性能，而且可以高效地实现。
 
+总之，**「最好的算法是老化算法和WSClock算法」**。他们分别是基于 LRU 和工作集算法。他们都具有良好的性能并且能够被有效的实现。还存在其他一些好的算法，但实际上这两个可能是最重要的。
 
 #### 4. 驻留集管理
 
@@ -237,6 +284,16 @@ Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自
 
 
 
+## 内存映射
+
+进程通过一个系统调用(mmap)将一个文件（或部分）映射到其虚拟地址空间的一部分，访问这个文件就像访问内存中的一个大数组，而不是对文件进行读写。
+
+在多数实现中，在映射共享的页面时不会实际读入页面的内容，而是在访问页面时，页面才会被每次一页的读入(虚拟内存的缺页处理)，磁盘文件则被当做后备存储。
+
+当进程退出或显式地解除文件映射时，所有被修改页面会写回文件。
+
+
+
 
 
 ## Android内存管理
diff --git a/OperatingSystem/5.I:O.md b/OperatingSystem/5.I:O.md
index 35535833..87a8fe44 100644
--- a/OperatingSystem/5.I:O.md
+++ b/OperatingSystem/5.I:O.md
@@ -29,6 +29,25 @@
 
 
 
+## I/O进程
+
+I/O进程是专门处理系统中的I/O请求和I/O中断工作的。是系统进程，一般赋予最高优先级。一旦被唤醒，它可以很快抢占处理机投入运行。当I/O进程开始运行后，首先关闭中断，然后用receive去接收消息。如果没有消息，则开中断将自己堵塞，如果有消息，就去判断消息的类型是I/O请求还是I/O中断，然后再分别处理。
+
+- I/O请求的进入
+
+    - 用户程序:调用send将I/O请求发送给I/O进程。调用block将自己堵塞，直到I/O任务完成后被唤醒。
+    - 系统:利用wakeup唤醒I/O进程，完成用户所要求的I/O处理。
+
+- I/O中断的进入
+
+    当I/O中断发生时，内核中的中断处理程序发送一条消息给I/O进程，由I/O进程负责判断并处理中断。
+    
+    ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/io_intercept_os.png?raw=true)  
+    
+    当一个 I/O 设备完成它的工作后，它就会产生一个中断（默认操作系统已经开启中断），它通过在总线上声明已分配的信号来实现此目的。主板上的中断控制器芯片会检测到这个信号，然后执行中断操作。
+
+​    
+
 ### 磁盘高速缓存
 
 
@@ -46,6 +65,58 @@
 
 
 
+
+
+
+
+
+
+每个设备控制器都会有一个应用程序与之对应，设备控制器通过应用程序的接口通过中断与操作系统进行通信。设备控制器是硬件，而设备驱动程序是软件。
+
+### 内存映射 I/O
+
+每个控制器都会有几个寄存器用来和 CPU 进行通信。通过写入这些寄存器，操作系统可以命令设备发送数据，接收数据、开启或者关闭设备等。通过从这些寄存器中读取信息，操作系统能够知道设备的状态，是否准备接受一个新命令等。
+
+为了控制`寄存器`，许多设备都会有`数据缓冲区(data buffer)`，来供系统进行读写。
+
+那么问题来了，CPU 如何与设备寄存器和设备数据缓冲区进行通信呢？存在两个可选的方式。第一种方法是，每个控制寄存器都被分配一个 `I/O 端口(I/O port)`号，这是一个 8 位或 16 位的整数。所有 I/O 端口的集合形成了受保护的 I/O 端口空间，以便普通用户程序无法访问它（只有操作系统可以访问）。使用特殊的 I/O 指令像是
+
+- 
+
+```
+IN REG,PORT
+```
+
+CPU 可以读取控制寄存器 PORT 的内容并将结果放在 CPU 寄存器 REG 中。类似的，使用
+
+- 
+
+```
+OUT PORT,REG
+```
+
+CPU 可以将 REG 的内容写到控制寄存器中。大多数早期计算机，包括几乎所有大型主机，如 IBM 360 及其所有后续机型，都是以这种方式工作的。
+
+第二个方法是 PDP-11 引入的，它将**「所有控制寄存器映射到内存空间」**中。
+
+### 直接内存访问
+
+无论一个 CPU 是否具有内存映射 I/O，它都需要寻址设备控制器以便与它们交换数据。CPU 可以从 I/O 控制器每次请求一个字节的数据，但是这么做会浪费 CPU 时间，所以经常会用到一种称为直接内存访问(Direct Memory Access) 的方案。它意味着 CPU 授予 I/O 模块权限在不涉及 CPU 的情况下读取或写入内存。也就是 DMA 可以不需要 CPU 的参与。这个过程由称为 DMA 控制器（DMAC）的芯片管理。由于 DMA 设备可以直接在内存之间传输数据，而不是使用 CPU 作为中介，因此可以缓解总线上的拥塞。DMA 通过允许 CPU 执行任务，同时 DMA 系统通过系统和内存总线传输数据来提高系统并发性。为了简化，我们假设 CPU 通过单一的系统总线访问所有的设备和内存，该总线连接 CPU 、内存和 I/O 设备，如下图所示
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/bus_os.png?raw=true)  
+
+#### DMA 工作原理
+
+首先 CPU 通过设置 DMA 控制器的寄存器对它进行编程，所以 DMA 控制器知道将什么数据传送到什么地方。DMA 控制器还要向磁盘控制器发出一个命令，通知它从磁盘读数据到其内部的缓冲区并检验校验和。当有效数据位于磁盘控制器的缓冲区中时，DMA 就可以开始了。
+
+DMA 控制器通过在总线上发出一个`读请求`到磁盘控制器而发起 DMA 传送，这是第二步。这个读请求就像其他读请求一样，磁盘控制器并不知道或者并不关心它是来自 CPU 还是来自 DMA 控制器。通常情况下，要写的内存地址在总线的地址线上，所以当磁盘控制器去匹配下一个字时，它知道将该字写到什么地方。写到内存就是另外一个总线循环了，这是第三步。当写操作完成时，磁盘控制器在总线上发出一个应答信号到 DMA 控制器，这是第四步。
+
+然后，DMA 控制器会增加内存地址并减少字节数量。如果字节数量仍然大于 0 ，就会循环步骤 2 - 步骤 4 ，直到字节计数变为 0 。此时，DMA 控制器会打断 CPU 并告诉它传输已经完成了。
+
+
+
+
+
 ---
 
 
diff --git "a/OperatingSystem/6.\346\226\207\344\273\266\347\256\241\347\220\206.md" "b/OperatingSystem/6.\346\226\207\344\273\266\347\256\241\347\220\206.md"
index 4940fb5d..e6908122 100644
--- "a/OperatingSystem/6.\346\226\207\344\273\266\347\256\241\347\220\206.md"
+++ "b/OperatingSystem/6.\346\226\207\344\273\266\347\256\241\347\220\206.md"
@@ -1,6 +1,8 @@
 # 6.文件管理
 
+文件是对磁盘的抽象。
 
+所谓未见是指一组带标识（标识即为文件名）的、在逻辑上有完整意义的信息项的序列。
 
 文件管理系统是一组系统软件，它为使用文件的用户和应用程序提供服务，包括文件访问、目录维护和访问控制。文件管理系统通常被视为一个由操作系统提供服务的系统服务，而不是操作系统的一部分，但是在任何系统中，至少有一部分文件管理功能是由操作系统执行的。
 
@@ -54,6 +56,78 @@ Android文件系统目录的顶层部分：
 
 
 
+### 文件系统布局
+
+文件系统存储在`磁盘`中。大部分的磁盘能够划分出一到多个分区，叫做`磁盘分区(disk partitioning)` 或者是`磁盘分片(disk slicing)`。每个分区都有独立的文件系统，每块分区的文件系统可以不同。磁盘的 0 号分区称为 `主引导记录(Master Boot Record, MBR)`，用来`引导(boot)` 计算机。在 MBR 的结尾是`分区表(partition table)`。每个分区表给出每个分区由开始到结束的地址。
+
+当计算机开始引 boot 时，BIOS 读入并执行 MBR。
+
+#### 引导块
+
+MBR 做的第一件事就是`确定活动分区`，读入它的第一个块，称为`引导块(boot block)` 并执行。引导块中的程序将加载分区中的操作系统。为了一致性，每个分区都会从引导块开始，即使引导块不包含操作系统。引导块占据文件系统的前 4096 个字节，从磁盘上的字节偏移量 0 开始。引导块可用于启动操作系统。
+
+除了从引导块开始之外，磁盘分区的布局是随着文件系统的不同而变化的。通常文件系统会包含一些属性，如下
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/file_system_os.png?raw=true)  
+
+#### 超级块
+
+紧跟在引导块后面的是 `超级块(Superblock)`，超级块 的大小为 4096 字节，从磁盘上的字节偏移 4096 开始。超级块包含文件系统的所有关键参数
+
+- 文件系统的大小
+- 文件系统中的数据块数
+- 指示文件系统状态的标志
+- 分配组大小
+
+在计算机启动或者文件系统首次使用时，超级块会被读入内存。
+
+#### 空闲空间块
+
+接着是文件系统中`空闲块`的信息，例如，可以用位图或者指针列表的形式给出。
+
+#### 碎片
+
+这里不得不提一个叫做`碎片(fragment)`的概念，也称为片段。一般零散的单个数据通常称为片段。磁盘块可以进一步分为固定大小的分配单元，片段只是在驱动器上彼此不相邻的文件片段。
+
+#### inode
+
+然后在后面是一个 `inode(index node)`，也称作索引节点。它是一个数组的结构，每个文件有一个 inode，inode 非常重要，它说明了文件的方方面面。每个索引节点都存储对象数据的属性和磁盘块位置。
+
+inode 节点主要包括了以下信息
+
+- 模式/权限（保护）
+- 所有者 ID
+- 组 ID
+- 文件大小
+- 文件的硬链接数
+- 上次访问时间
+- 最后修改时间
+- inode 上次修改时间
+
+文件分为两部分，索引节点和块。一旦创建后，每种类型的块数是固定的。你不能增加分区上 inode 的数量，也不能增加磁盘块的数量。
+
+紧跟在 inode 后面的是根目录，它存放的是文件系统目录树的根部。最后，磁盘的其他部分存放了其他所有的目录和文件。
+
+### 文件的实现
+
+最重要的问题是记录各个文件分别用到了哪些磁盘块。不同的系统采用了不同的方法。下面我们会探讨一下这些方式。分配背后的主要思想是`有效利用文件空间`和`快速访问文件` ，主要有三种分配方案
+
+- 连续分配
+- 链表分配
+- 索引分配
+
+
+
+
+
+
+
+
+
+- [参考: ](https://mp.weixin.qq.com/s/oLvTFWibCH53Fv5lj4mTnQ)
+
+
+
 ---
 
 
diff --git "a/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md" "b/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md"
index 2f089353..11a00bf6 100644
--- "a/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md"
+++ "b/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md"
@@ -108,6 +108,8 @@ copy_to_user() //将数据从内核空间拷贝到用户空间
 那就是让操作系统内核添加支持，传统的linux通信机制，比如socket、管道等都是内核的一部分，因此通过内核支持来实现进程间通信自然是没有问题的，但是binder并不是linux系统内核的一部分，那它是怎么做到访问内核空间的呢？这就得益于 Linux 的**动态内核可加载模块**（Loadable Kernel  Module，LKM）的机制；模块是具有独立功能的程序，它可以被单独编译，但是不能独立运行。它在运行时被链接到内核作为内核的一部分运行。这样，Android 系统就可以通过动态添加一个内核模块运行在内核空间，用户进程之间通过这个内核模块作为桥梁来实现通信。
 
 >  在 Android 系统中，这个运行在内核空间，负责各个用户进程通过 Binder 实现通信的内核模块就叫  **Binder 驱动**（Binder Dirver）（尽管名叫‘驱动’，实际上和硬件设备没有任何关系，只是实现方式和设备驱动程序是一样的）。
+>
+>  从进程角度来看IPC机制，每个Android的进程，只能运行在自己进程所拥有的虚拟地址空间。对应一个4GB的虚拟地址空间，其中3GB是用户空间，1GB是内核空间，当然内核空间的大小是可以通过参数配置调整的。对于用户空间，不同进程之间彼此是不能共享的，而内核空间却是可共享的。Client进程向Server进程通信，恰恰是利用进程间可共享的内核内存空间来完成底层通信工作的，Client端与Server端进程往往采用ioctl等方法跟内核空间的驱动进行交互。
 
 
 
@@ -261,6 +263,8 @@ SystemServer和Zygote之间通信不使用Socket的原因是为了要解决fork
 
 - ServiceManager
 
+    ServiceManager是Binder IPC通信过程中的守护进程，本身也是一个Binder服务，但并没有采用libbinder中的多线程模型来与Binder驱动通信，而是自行编写了binder.c直接和Binder驱动来通信，并且只有一个循环binder_loop来进行读取和处理事务，这样的好处是简单而高效。ServiceManager是由init进程通过解析init.rc文件而创建的。
+
     ServiceManager本身的工作很简单：注册服务、查询服务、列出所有服务，启动一个死循环来解析Binder驱动读写动作，进行事务处理。ServiceManager用于管理系统中的各种服务。架构图如下所示：
 
     ![ServiceManager](http://gityuan.com/images/binder/prepare/IPC-Binder.jpg)
@@ -276,10 +280,24 @@ SystemServer和Zygote之间通信不使用Socket的原因是为了要解决fork
     ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/binder_client_server.png)
 
     
-
     
+    
+
+ServiceManger集中管理系统内的所有服务，通过权限控制进程是否有权注册服务,通过字符串名称来查找对应的Service; 由于ServiceManger进程建立跟所有向其注册服务的死亡通知, 那么当服务所在进程死亡后, 会只需告知ServiceManager. 每个Client通过查询ServiceManager可获取Server进程的情况，降低所有Client进程直接检测会导致负载过重。
 
+**ServiceManager启动流程：**
 
+1. 打开binder驱动，并调用mmap()方法分配128k的内存映射空间：binder_open();
+2. 通知binder驱动使其成为守护进程：binder_become_context_manager()；
+3. 验证selinux权限，判断进程是否有权注册或查看指定服务；
+4. 进入循环状态，等待Client端的请求：binder_loop()。
+5. 注册服务的过程，根据服务名称，但同一个服务已注册，重新注册前会先移除之前的注册信息；
+6. 死亡通知: 当binder所在进程死亡后,会调用binder_release方法,然后调用binder_node_release.这个过程便会发出死亡通知的回调.
+
+ServiceManager最核心的两个功能为查询和注册服务：
+
+- 注册服务：记录服务名和handle信息，保存到svclist列表；
+- 查询服务：根据服务名查询相应的的handle信息。
 
 ## Binder 通信过程
 
@@ -348,7 +366,39 @@ ARM64内存占用分配：
 
 ![img](https://img-blog.csdnimg.cn/20200329164637770.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lpcmFuZmVuZw==,size_16,color_FFFFFF,t_70)
 
-用户地址空间(服务端-数据接收端)和内核地址空间都映射到同一块物理地址空间。
+用户地址空间(服务端-数据接收端)和内核地址空间都映射到同一块物理地址空间，这也是Binder进程间通信效率高的核心机制所在。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/binder_physical_memory.jpg?raw=true)  
+
+虚拟进程地址空间(vm_area_struct)和虚拟内核地址空间(vm_struct)都映射到同一块物理内存空间。当Client端与Server端发送数据时，Client（作为数据发送端）先从自己的进程空间把IPC通信数据`copy_from_user`拷贝到内核空间，而Server端（作为数据接收端）与内核共享数据，不再需要拷贝数据，而是通过内存地址空间的偏移量，即可获悉内存地址，整个过程只发生一次内存拷贝。一般地做法，需要Client端进程空间拷贝到内核空间，再由内核空间拷贝到Server进程空间，会发生两次拷贝。
+
+对于进程和内核虚拟地址映射到同一个物理内存的操作是发生在数据接收端，而数据发送端还是需要将用户态的数据复制到内核态。到此，可能有读者会好奇，为何不直接让发送端和接收端直接映射到同一个物理空间，那样就连一次复制的操作都不需要了，0次复制操作那就与Linux标准内核的共享内存的IPC机制没有区别了，对于共享内存虽然效率高，但是对于多进程的同步问题比较复杂，而管道/消息队列等IPC需要复制2两次，效率较低。这里就不先展开讨论Linux现有的各种IPC机制跟Binder的详细对比，总之Android选择Binder的基于速度和安全性的考虑。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/binder_memory_map.jpg?raw=true)  
+
+
+
+### Binder驱动
+
+Binder驱动是Android专用的，但底层的驱动架构与Linux驱动一样。binder驱动在以misc设备进行注册，作为虚拟字符设备，没有直接操作硬件，只是对设备内存的处理。主要是驱动设备的初始化(binder_init)，打开 (binder_open)，映射(binder_mmap)，数据操作(binder_ioctl)，binder_ioctl()函数负责在两个进程间收发IPC数据和IPC reply数据。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/binder_driver.png?raw=true)  
+
+### 系统调用
+
+用户态的程序调用Kernel层驱动是需要陷入内核态，进行系统调用(`syscall`)，比如打开Binder驱动方法的调用链为： open-> __open() -> binder_open()。 open()为用户空间的方法，__open()便是系统调用中相应的处理方法，通过查找，对应调用到内核binder驱动的binder_open()方法，至于其他的从用户态陷入内核态的流程也基本一致。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/binder_syscall.png?raw=true)  
+
+简单说，当用户空间调用open()方法，最终会调用binder驱动的binder_open()方法；mmap()/ioctl()方法也是同理，在BInder系列的后续文章从用户态进入内核态，都依赖于系统调用过程。
+
+
+
+
+
+在Android系统开机过程中，Zygote启动时会有一个[虚拟机注册过程](http://gityuan.com/2016/02/13/android-zygote/#jnistartreg)，该过程调用AndroidRuntime::`startReg`方法来完成jni方法的注册。
+
+
 
 
 
diff --git "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
index 7af53a77..4e733af8 100644
--- "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
+++ "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
@@ -5,86 +5,81 @@
 基本概念
 ---
 
-- ***媒体***：是表示，传输，存储信息的载体，常人们见到的文字、声音、图像、图形等都是表示信息的媒体。
+- 媒体
 
-- ***多媒体***：是声音、动画、文字、图像和录像等各种媒体的组合，以图文并茂，生动活泼的动态形式表现出来，给人以很强的视觉冲击力，留下深刻印象.
+    是表示，传输，存储信息的载体，常人们见到的文字、声音、图像、图形等都是表示信息的媒体。
 
-- ***多媒体技术***：是将文字、声音、图形、静态图像、动态图像与计算集成在一起的技术。它要解决的问题是计算机进一步帮助人类按最自然的和最习惯的方式接受和处理信息。
+- 多媒体
 
-- ***流媒体***：流媒体是指采用流式传输的方式在`Internet`播放的连续时基媒体格式，实际指的是一种新的媒体传送方式，而不是一种新的媒体格式（在网络上传输音/视频等多媒体信息现在主要有下载和流式传输两种方式）流式传输分两种方法：实时流式传输方式(`Realtime Streaming`)和顺序流式传输方式(`Progressive Streaming`)。
+    是声音、动画、文字、图像和录像等各种媒体的组合，以图文并茂，生动活泼的动态形式表现出来，给人以很强的视觉冲击力，留下深刻印象.
 
-- ***多媒体文件***:是既包括视频又包括音频，甚至还带有脚本的一个集合，也可以叫容器。
+- 多媒体技术
 
-- ***媒体编码***:是文件当中的视频和音频所采用的压缩算法。也就是说一个`avi`的文件，当中的视频编码有可能是`A`，也可能是`B`，而其音频编码有可能是`1`，也有可能是`2`。
+    是将文字、声音、图形、静态图像、动态图像与计算集成在一起的技术。它要解决的问题是计算机进一步帮助人类按最自然的和最习惯的方式接受和处理信息。
 
-- ***转码***:指将一段多媒体包括音频、视频或者其他的内容从一种编码格式转换成为另外一种编码格式。
+- 流媒体
 
-- ***帧***:帧就是一段数据的组合，它是数据传输的基本单位。就是影像动画中最小单位的单幅影像画面，相当于电影胶片上的每一格镜头。一帧就是一副静止的画面，连续的帧就形成动画，如电视图像等。
+    流媒体是指采用流式传输的方式在`Internet`播放的连续时基媒体格式，实际指的是一种新的媒体传送方式，而不是一种新的媒体格式（在网络上传输音/视频等多媒体信息现在主要有下载和流式传输两种方式）流式传输分两种方法：实时流式传输方式(`Realtime Streaming`)和顺序流式传输方式(`Progressive Streaming`)。
 
-- ***视频***：连续的图象变化每秒超过24帧(`Frame`)画面以上时，根据视觉暂留原理，人眼无法辨别单幅的静态画面，看上去是平滑连续的视觉效果，这样连续的画面叫做视频.
+- 多媒体文件
 
-- ***音频***:人类能听到的声音都成为音频，但是一般我们所说到的音频时存储在计算机里的声音。
+    既包括视频又包括音频，甚至还带有脚本的一个集合，也可以叫容器。
 
-- ***比特率(码率)***:码率就是数据传输时单位时间传送的数据位数,一般我们用的单位是`kbps`即千位(bit)每秒，也就是每秒钟传送多少个千位的信息。 通俗一点的理解就是取样率，单位时间内取样率越大，精度就越高，处理出来的文件就越接近原始文件，但是文件体积与取样率是成正比的，所以几乎所有的编码格式重视的都是如何用最低的码率达到最少的失真。但是因为编码算法不一样，所以也不能用码率来统一衡量音质或者画质.小写的b表示bit(位)，大写的B表示byte(字节)，一个字节=8个位，即1B=8b；前面的k表示1024的意思，即1024个位(Kb)或者1024个字节(KB)，表示文件的大小单位，一般使用KB。1KB/s=8Kbps。码率(kbps)=文件大小(KB)*8/时间(秒)。     
-  - 动态码率(VBR: Variable Bit Rate)
+- 媒体编码
 
-     比特率可以随着图像复杂程度的不同而随之变化。图像内容简单的片段采用较小的码率，图像
+    是文件当中的视频和音频所采用的压缩算法。也就是说一个`avi`的文件，当中的视频编码有可能是`A`，也可能是`B`，而其音频编码有可能是`1`，也有可能是`2`。
 
-    内容复杂的片段采用较大的码率，这样既保证了播放质量，又兼顾了数据量的限制。例如RMVB视频文件，其中的VB就是指VBR，表示采用动态比特率编码方式，达到播放质量与体积兼得的效果。
+- 转码
 
-  - 静态比特率(CBR: Constant Bit Rate)
+    指将一段多媒体包括音频、视频或者其他的内容从一种编码格式转换成为另外一种编码格式。
 
-    比特率恒定，图像内容复杂的片段质量不稳定，图像内容简单的片段质量较好。
-
-- ***帧率(Frame Rate)***:帧/秒(`frames per second`)的缩写帧率即每秒显示帧数，帧率表示图形处理器处理场时每秒钟能够更新的次数。高的帧率可以得到更流畅、更逼真的动画。一般来说`30fps`就是可以接受的，但是将性能提升至`60fps`则可以明显提升交互感和逼真感，但是一般来说超过`75fps`一般就不容易察觉到有明显的流畅度提升了。如果帧率超过屏幕刷新率只会浪费图形处理的能力，因为监视器不能以这么快的速度更新，这样超过新率的帧率就浪费掉了。
-  ![image](https://github.com/CharonChui/Pictures/blob/master/fps.gif?raw=true)
+- 帧
 
-- ***关键帧***:相当于二维动画中的原画，指角色或者物体运动或变化中的关键动作所处的那一帧，它包含了图像的所有信息，后来帧仅包含了改变了的信息。如果你没有足够的关键帧，你的影片品质可能比较差，因为所有的帧从别的帧处产生。对于一般的用途，一个比较好的原则是每5秒设一个关键键。但如果时那种实时传输的流文件，那么要考虑传输网络的可靠度，所以要1到2秒增加一个关键帧。
+    帧就是一段数据的组合，它是数据传输的基本单位。就是影像动画中最小单位的单幅影像画面，相当于电影胶片上的每一格镜头。一帧就是一副静止的画面，连续的帧就形成动画，如电视图像等。
 
+- 视频
 
+    连续的图象变化每秒超过24帧(`Frame`)画面以上时，根据视觉暂留原理，人眼无法辨别单幅的静态画面，看上去是平滑连续的视觉效果，这样连续的画面叫做视频.
 
+- 音频
 
-视频格式(封装格式/容器)
----
-
+    人类能听到的声音都成为音频，但是一般我们所说到的音频时存储在计算机里的声音。
 
+- 比特率(码率)
+  
+码率就是数据传输时单位时间传送的数据位数,一般我们用的单位是`kbps`即千位(bit)每秒，也就是每秒钟传送多少个千位的信息。 通俗一点的理解就是取样率，单位时间内取样率越大，精度就越高，处理出来的文件就越接近原始文件，但是文件体积与取样率是成正比的，所以几乎所有的编码格式重视的都是如何用最低的码率达到最少的失真。但是因为编码算法不一样，所以也不能用码率来统一衡量音质或者画质.小写的b表示bit(位)，大写的B表示byte(字节)，一个字节=8个位，即1B=8b；前面的k表示1024的意思，即1024个位(Kb)或者1024个字节(KB)，表示文件的大小单位，一般使用KB。1KB/s=8Kbps。码率(kbps)=文件大小(KB)*8/时间(秒)。     
+  
+- 动态码率(VBR: Variable Bit Rate)
+  
+   比特率可以随着图像复杂程度的不同而随之变化。图像内容简单的片段采用较小的码率，图像
+  
+  内容复杂的片段采用较大的码率，这样既保证了播放质量，又兼顾了数据量的限制。例如RMVB视频文件，其中的VB就是指VBR，表示采用动态比特率编码方式，达到播放质量与体积兼得的效果。
+  
+- 静态比特率(CBR: Constant Bit Rate)
+  
+    比特率恒定，图像内容复杂的片段质量不稳定，图像内容简单的片段质量较好。
+  
+- 帧率(Frame Rate)
+  
+帧/秒(`frames per second`)的缩写帧率即每秒显示帧数，帧率表示图形处理器处理场时每秒钟能够更新的次数。高的帧率可以得到更流畅、更逼真的动画。一般来说`30fps`就是可以接受的，但是将性能提升至`60fps`则可以明显提升交互感和逼真感，但是一般来说超过`75fps`一般就不容易察觉到有明显的流畅度提升了。如果帧率超过屏幕刷新率只会浪费图形处理的能力，因为监视器不能以这么快的速度更新，这样超过新率的帧率就浪费掉了。
+  ![image](https://github.com/CharonChui/Pictures/blob/master/fps.gif?raw=true)
+  
+- 关键帧
 
-目前我们经常见的视频格式无非就是两大类： 
-
-1. 影像格式（Video）
-2. 流媒体格式（Stream Video）
-
-在影像格式中还可以根据出处划分为三大种:   
+    相当于二维动画中的原画，指角色或者物体运动或变化中的关键动作所处的那一帧，它包含了图像的所有信息，后来帧仅包含了改变了的信息。如果你没有足够的关键帧，你的影片品质可能比较差，因为所有的帧从别的帧处产生。对于一般的用途，一个比较好的原则是每5秒设一个关键键。但如果时那种实时传输的流文件，那么要考虑传输网络的可靠度，所以要1到2秒增加一个关键帧。
 
-1. `AVI`格式      
-    `AVI`英文全称为`Audio Video Interleaved`，即音频视频交错格式，是微软公司于1992年11月推出、作为其`Windows`视频软件一部分的一种多媒体容器格式。
-    `AVI`文件将音频（语音）和视频（影像）数据包含在一个文件容器中，允许音视频同步回放。类似`DVD`视频格式，`AVI`文件支持多个音视频流。`AVI`信息主要应用在多媒体光盘上，用来保存电视、电影等各种影像信息。    
-    其中数据块包含实际数据流，即图像和声音序列数据。这是文件的主体，也是决定文件容量的主要部分。视频文件的大小等于该文件的数据率乘以该视频播放的时间长度，
-    索引块包括数据块列表和它们在文件中的位置，以提供文件内数据随机存取能力。文件头包括文件的通用信息，定义数据格式，所用的压缩算法等参数。      
-    `AVI`没有`MPEG`这么复杂，从`Windows 3.1`时代，它就已经面世了。它最直接的优点就是兼容好、调用方便而且图象质量好，因此也常常与`DVD`相并称。
-    但它的缺点也是十分明显的：体积大。也是因为这一点，我们才看到了`MPEG-1`和`MPEG-4`的诞生。2小时影像的`AVI`文件的体积与`MPEG-2`相差无几，
-    不过这只是针对标准分辨率而言的：根据不同的应用要求，`AVI`的分辨率可以随意调。窗口越大，文件的数据量也就越大。降低分辨率可以大幅减低它的体积，
-    但图象质量就必然受损。与`MPEG-2`格式文件体积差不多的情况下，`AVI`格式的视频质量相对而言要差不少，但制作起来对电脑的配置要求不高，经常有人先录制好了`AVI`格式的视频，再转换为其他格式。
-2. `MOV`格式
-    `MOV`即`QuickTime`影片格式，它是`Apple`公司开发的一种音频、视频文件格式，用于存储常用数字媒体类型。当选择`QuickTime（*.mov）`作为“保存类型”时，动画将保存为`·mov`文件。`QuickTime`用于保存音频和视频信息，包括`Apple Mac OS，MicrosoftWindows95/98/NT/2003/XP/VISTA`，甚至`WINDOWS7`在内的所有主流电脑平台支持。`QuickTime`因具有跨平台、存储空间要求小等技术特点，而采用了有损压缩方式的`MOV`格式文件，画面效果较AVI格式要稍微好一些。到目前为止，它共有4个版本，其中以`4.0`版本的压缩率最好。这种编码支持16位图像深度的帧内压缩和帧间压缩，帧率每秒10帧以上。这种格式有些非编软件也可以对它实行处理，其中包括`ADOBE`公司的专业级多媒体视频处理软件`AFTEREFFECTS和PREMIERE`。
+- 刷新率
 
-3. `MPEG/MPG/DAT`:
-    这是由国际标准化组织`ISO(International Standards Organization)`与`IEC(International Electronic Committee)`联合开发的一种编码视频格式。`MPEG`是运动图像压缩算法的国际标准，现已被几乎所有的计算机平台共同支持。MPEG也是`Motion Picture Experts Group`的缩写。这类格式包括了`MPEG-1, MPEG-2`和`MPEG-4`在内的多种视频格式。`MPEG-1`相信是大家接触得最多的了，因为目前其正在被广泛地应用在`VCD`的制作和一些视频片段下载的网络应用上面，大部分的`VCD`都是用 `MPEG1`格式压缩的( 刻录软件自动将`MPEG1`转为`.DAT`格式)，使用`MPEG-1`的压缩算法，可以把一部120分钟长的电影压缩到1.2GB左右大小。`MPEG-2`则是应用在`DVD` 的制作，同时在一些`HDTV`（高清晰电视广播）和一些高要求视频编辑、处理上面也有相当多的应用。使用`MPEG-2`的压缩算法压缩一部120分钟长的电影可以压缩到5-8GB的大小（`MPEG2`的图像质量`MPEG-1`与其无法比拟的）。
+    刷新率是指屏幕每秒画面被刷新的次数，刷新率分为垂直刷新率和水平刷新率，一般提到的刷新率通常是指垂直刷新率。垂直刷新率表示屏幕上图像每秒重绘多少次，也就是每秒屏幕刷新的次数，以Hz（赫兹）为单位。刷新率越高，图像就越稳定，图像显示就越自然清晰，对眼镜的影响也越小。刷新率月底，图像闪烁和抖动的就越厉害，眼镜疲劳的越快。一般来说，如果能达到80Hz以上的刷新率，就可以完全消除图像闪烁和抖动感。
 
-在流媒体格式中同样还可以划分为三种:      
+- DTS
 
-1. `RM`格式
-    `Real Networks`公司所制定的音频/视频压缩规范`Real Media`中的一种，`Real Player`能做的就是利用`Internet`资源对这些符合`Real Media`技术规范的音频/视频进行实况转播。在`Real Media`规范中主要包括三类文件：`RealAudio`、`Real Video`和`Real Flash`（`Real Networks`公司与`Macromedia`公司合作推出的新一代高压缩比动画格式）。`REAL VIDEO`（RA、RAM）格式由一开始就是定位就是在视频流应用方面的，也可以说是视频流技术的始创者。它可以在用56K`MODEM`拨号上网的条件实现不间断的视频播放，从`RealVideo`的定位来看，就是牺牲画面质量来换取可连续观看性。其实`RealVideo`也可以实现不错的画面质量，由于`RealVideo`可以拥有非常高的压缩效率，很多人把`VCD`编码成`RealVideo`格式的，这样一来，一张光盘上可以存放好几部电影。`REAL VIDEO`存在颜色还原不准确的问题，`RealVideo`就不太适合专业的场合，但`RealVideo`出色的压缩效率和支持流式播放的特征，使得`RealVideo`在网络和娱乐场合占有不错的市场份额。
-2. `MOV/QT`格式
-    `MOV`也可以作为一种流文件格式。`QuickTime`能够通过`Internet`提供实时的数字化信息流、工作流与文件回放功能，为了适应这一网络多媒体应用，`QuickTime`为多种流行的浏览器软件提供了相应的`QuickTime Viewer`插件，能够在浏览器中实现多媒体数据的实时回放。
-3. `ASF`格式
-    `ASF`(`Advanced Streaming format`高级流格式)。`ASF`是`MICROSOFT`为了和现在的`Real player`竞争而发展出来的一种可以直接在网上观看视频节目的文件压缩格式。`ASF`使用了`MPEG4`的压缩算法，压缩率和图像的质量都很不错。因为`ASF`是以一个可以在网上即时观赏的视频“流”格式存在的，所以它的图像质量比`VCD`差一点点并不出奇，但比同是视频“流”格式的`RAM`格式要好。 `ASF`支持任意的压缩/解压缩编码方式，并可以使用任何一种底层网络传输协议，具有很大的灵活性。`ASF`流文件的数据速率可以在`28.8Kbps`到`3Mbps`之间变化。用户可以根据自己应用环境和网络条件选择一个合适的速率，实现`VOD`点播和直播。
+    Decode Time Stamp，主要用于标识读入内存中的比特流在什么时候开始送入解码器中进行解码。
 
-4. `FLV`格式`FLV`是`FLASH VIDEO`的简称，一种流媒体封装格式，`FLV`流媒体格式是随着`Flash MX`的推出发展而来的视频格式。由于它形成的文件极小、加载速度极快，使得网络观看视频文件成为可能，它的出现有效地解决了视频文件导入`Flash`后，使导出的`SWF`文件体积庞大，不能在网络上很好的使用等问题。因此`FLV`格式成为了当今主流视频格式
+- PTS
 
+    Presentation Time Stamp，主要用于度量解码后的视频帧什么时候被显示出来。
 
-叫做容器很好理解，mp4就是一个容器，里面有moov文件表示文件的信息等，还有音频、画面等信息，他们统一到
-一起，放到一个容器里面，就组成了视频。如果觉得难以理解，可以想象成一瓶番茄酱。最外层的瓶子好比这个容器封装（Container），瓶子上注明的原材料和加工厂地等信息好比元信息（Metadata），瓶盖打开（解封装）后，番茄酱本身好比经过压缩处理过后的编码内容，番茄和调料加工成番茄酱的过程就好比编码（Codec），而原材料番茄和调料则好比最原本的内容元素（Content）。
 
 
 音视频压缩编码标准
@@ -142,6 +137,53 @@
 - `MP3`:(`MPEG-1 or MPEG-2 Audio Layer III`)，是当曾经非常流行的一种数字音频编码和有损压缩格式，它被设计来大幅降低音频数据量。它是在1991 年，由位于德国埃尔朗根的研究组织`Fraunhofer-Gesellschaft`的一组工程师发明和标准化的。`MP3`的普及曾对音乐产业造成极大的冲击与影响。
 - `WMA`:(`Windows Media Audio`)由微软公司开发的一种数字音频压缩格式，本身包括有损和无损压缩格式。
 
+---
+
+
+
+
+视频格式(封装格式/容器)
+---
+
+把编码后的音视频数据以一定格式封装到一个容器。
+
+目前我们经常见的视频格式无非就是两大类： 
+
+1. 影像格式（Video）
+2. 流媒体格式（Stream Video）
+
+在影像格式中还可以根据出处划分为三大种:   
+
+1. `AVI`格式      
+    `AVI`英文全称为`Audio Video Interleaved`，即音频视频交错格式，是微软公司于1992年11月推出、作为其`Windows`视频软件一部分的一种多媒体容器格式。
+    `AVI`文件将音频（语音）和视频（影像）数据包含在一个文件容器中，允许音视频同步回放。类似`DVD`视频格式，`AVI`文件支持多个音视频流。`AVI`信息主要应用在多媒体光盘上，用来保存电视、电影等各种影像信息。    
+    其中数据块包含实际数据流，即图像和声音序列数据。这是文件的主体，也是决定文件容量的主要部分。视频文件的大小等于该文件的数据率乘以该视频播放的时间长度，
+    索引块包括数据块列表和它们在文件中的位置，以提供文件内数据随机存取能力。文件头包括文件的通用信息，定义数据格式，所用的压缩算法等参数。      
+    `AVI`没有`MPEG`这么复杂，从`Windows 3.1`时代，它就已经面世了。它最直接的优点就是兼容好、调用方便而且图象质量好，因此也常常与`DVD`相并称。
+    但它的缺点也是十分明显的：体积大。也是因为这一点，我们才看到了`MPEG-1`和`MPEG-4`的诞生。2小时影像的`AVI`文件的体积与`MPEG-2`相差无几，
+    不过这只是针对标准分辨率而言的：根据不同的应用要求，`AVI`的分辨率可以随意调。窗口越大，文件的数据量也就越大。降低分辨率可以大幅减低它的体积，
+    但图象质量就必然受损。与`MPEG-2`格式文件体积差不多的情况下，`AVI`格式的视频质量相对而言要差不少，但制作起来对电脑的配置要求不高，经常有人先录制好了`AVI`格式的视频，再转换为其他格式。
+2. `MOV`格式
+    `MOV`即`QuickTime`影片格式，它是`Apple`公司开发的一种音频、视频文件格式，用于存储常用数字媒体类型。当选择`QuickTime（*.mov）`作为“保存类型”时，动画将保存为`·mov`文件。`QuickTime`用于保存音频和视频信息，包括`Apple Mac OS，MicrosoftWindows95/98/NT/2003/XP/VISTA`，甚至`WINDOWS7`在内的所有主流电脑平台支持。`QuickTime`因具有跨平台、存储空间要求小等技术特点，而采用了有损压缩方式的`MOV`格式文件，画面效果较AVI格式要稍微好一些。到目前为止，它共有4个版本，其中以`4.0`版本的压缩率最好。这种编码支持16位图像深度的帧内压缩和帧间压缩，帧率每秒10帧以上。这种格式有些非编软件也可以对它实行处理，其中包括`ADOBE`公司的专业级多媒体视频处理软件`AFTEREFFECTS和PREMIERE`。
+
+3. `MPEG/MPG/DAT`:
+    这是由国际标准化组织`ISO(International Standards Organization)`与`IEC(International Electronic Committee)`联合开发的一种编码视频格式。`MPEG`是运动图像压缩算法的国际标准，现已被几乎所有的计算机平台共同支持。MPEG也是`Motion Picture Experts Group`的缩写。这类格式包括了`MPEG-1, MPEG-2`和`MPEG-4`在内的多种视频格式。`MPEG-1`相信是大家接触得最多的了，因为目前其正在被广泛地应用在`VCD`的制作和一些视频片段下载的网络应用上面，大部分的`VCD`都是用 `MPEG1`格式压缩的( 刻录软件自动将`MPEG1`转为`.DAT`格式)，使用`MPEG-1`的压缩算法，可以把一部120分钟长的电影压缩到1.2GB左右大小。`MPEG-2`则是应用在`DVD` 的制作，同时在一些`HDTV`（高清晰电视广播）和一些高要求视频编辑、处理上面也有相当多的应用。使用`MPEG-2`的压缩算法压缩一部120分钟长的电影可以压缩到5-8GB的大小（`MPEG2`的图像质量`MPEG-1`与其无法比拟的）。
+
+在流媒体格式中同样还可以划分为三种:      
+
+1. `RM`格式
+    `Real Networks`公司所制定的音频/视频压缩规范`Real Media`中的一种，`Real Player`能做的就是利用`Internet`资源对这些符合`Real Media`技术规范的音频/视频进行实况转播。在`Real Media`规范中主要包括三类文件：`RealAudio`、`Real Video`和`Real Flash`（`Real Networks`公司与`Macromedia`公司合作推出的新一代高压缩比动画格式）。`REAL VIDEO`（RA、RAM）格式由一开始就是定位就是在视频流应用方面的，也可以说是视频流技术的始创者。它可以在用56K`MODEM`拨号上网的条件实现不间断的视频播放，从`RealVideo`的定位来看，就是牺牲画面质量来换取可连续观看性。其实`RealVideo`也可以实现不错的画面质量，由于`RealVideo`可以拥有非常高的压缩效率，很多人把`VCD`编码成`RealVideo`格式的，这样一来，一张光盘上可以存放好几部电影。`REAL VIDEO`存在颜色还原不准确的问题，`RealVideo`就不太适合专业的场合，但`RealVideo`出色的压缩效率和支持流式播放的特征，使得`RealVideo`在网络和娱乐场合占有不错的市场份额。
+2. `MOV/QT`格式
+    `MOV`也可以作为一种流文件格式。`QuickTime`能够通过`Internet`提供实时的数字化信息流、工作流与文件回放功能，为了适应这一网络多媒体应用，`QuickTime`为多种流行的浏览器软件提供了相应的`QuickTime Viewer`插件，能够在浏览器中实现多媒体数据的实时回放。
+3. `ASF`格式
+    `ASF`(`Advanced Streaming format`高级流格式)。`ASF`是`MICROSOFT`为了和现在的`Real player`竞争而发展出来的一种可以直接在网上观看视频节目的文件压缩格式。`ASF`使用了`MPEG4`的压缩算法，压缩率和图像的质量都很不错。因为`ASF`是以一个可以在网上即时观赏的视频“流”格式存在的，所以它的图像质量比`VCD`差一点点并不出奇，但比同是视频“流”格式的`RAM`格式要好。 `ASF`支持任意的压缩/解压缩编码方式，并可以使用任何一种底层网络传输协议，具有很大的灵活性。`ASF`流文件的数据速率可以在`28.8Kbps`到`3Mbps`之间变化。用户可以根据自己应用环境和网络条件选择一个合适的速率，实现`VOD`点播和直播。
+
+4. `FLV`格式`FLV`是`FLASH VIDEO`的简称，一种流媒体封装格式，`FLV`流媒体格式是随着`Flash MX`的推出发展而来的视频格式。由于它形成的文件极小、加载速度极快，使得网络观看视频文件成为可能，它的出现有效地解决了视频文件导入`Flash`后，使导出的`SWF`文件体积庞大，不能在网络上很好的使用等问题。因此`FLV`格式成为了当今主流视频格式
+
+
+叫做容器很好理解，mp4就是一个容器，里面有moov文件表示文件的信息等，还有音频、画面等信息，他们统一到
+一起，放到一个容器里面，就组成了视频。如果觉得难以理解，可以想象成一瓶番茄酱。最外层的瓶子好比这个容器封装（Container），瓶子上注明的原材料和加工厂地等信息好比元信息（Metadata），瓶盖打开（解封装）后，番茄酱本身好比经过压缩处理过后的编码内容，番茄和调料加工成番茄酱的过程就好比编码（Codec），而原材料番茄和调料则好比最原本的内容元素（Content）。
+
 
 一些音视频的参数含义
 ---
diff --git "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/2.\347\263\273\347\273\237\346\222\255\346\224\276\345\231\250MediaPlayer.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/2.\347\263\273\347\273\237\346\222\255\346\224\276\345\231\250MediaPlayer.md"
new file mode 100644
index 00000000..405341cd
--- /dev/null
+++ "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/2.\347\263\273\347\273\237\346\222\255\346\224\276\345\231\250MediaPlayer.md"
@@ -0,0 +1,30 @@
+2.系统播放器MediaPlayer
+===
+
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/mediaplayer_state.png?raw=true)    
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+相关知识: 
+
+- [封装格式](https://en.wikipedia.org/wiki/Comparison_of_video_container_formats)
+- [视频编码方式](https://en.wikipedia.org/wiki/Comparison_of_video_codecs)
+- [音频编码方式](https://en.wikipedia.org/wiki/Comparison_of_audio_coding_formats)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file

From 02d97cc227dea999e4d81d7a44debf14a4c501c5 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 18 Feb 2021 15:39:35 +0800
Subject: [PATCH 044/213] update

---
 ...13\344\270\216\347\272\277\347\250\213.md" |  4 +-
 ...13\351\227\264\351\200\232\344\277\241.md" | 41 +++++++++++++++++
 ...30\345\210\266\345\237\272\347\241\200.md" | 44 +++++++++++++++++++
 ...ManagerService\347\256\200\344\273\213.md" |  4 ++
 ...57\345\212\250\350\277\207\347\250\213.md" | 10 ++++-
 5 files changed, 99 insertions(+), 4 deletions(-)

diff --git "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md" "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
index c96b8f66..9801b918 100644
--- "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
+++ "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
@@ -293,7 +293,7 @@
     使用这个算法，调度程序总是选择剩余运行时间最短的那个进程运行。
 
 - 轮转法
-    
+  
     一种最古老、最简单、最公平并且最广泛使用的算法就是轮询算法(round-robin)。每个进程都会被分配一个时间段，称为时间片(quantum)，在这个时间片内允许进程运行。如果时间片结束时进程还在运行的话，则抢占一个 CPU 并将其分配给另一个进程。如果进程在时间片结束前阻塞或结束，则 CPU 立即进行切换。轮询算法比较容易实现。调度程序所做的就是维护一个可运行进程的列表，就像下图中的 a，当一个进程用完时间片后就被移到队列的末尾。
     
     - 简单轮转： 就绪进程按FIFO排队，按照一定时间间隔让处理机分配给队列中的进程，就绪队列中所有队列均可获得一个时间片的处理器运行。
@@ -402,7 +402,7 @@ Linux为进程间通信和同步提供了各种机制。这里只是几种。
 
 ## Android进程结构
 
-如同传统的Linux系统一样，Android的第一个用户空间进程是init，它是所有其他进程的根。然而，Android的init启动的守护进程是不同的，这些守护进程更多的聚焦于底层细节（管理文件系统和硬件访问），而不是高层用户设施，例如调度定时任务。Android还有一层额外的进程，它们运行Dalvik的Java语言环境，负责执行系统中所有以Java实现的部分。
+如同传统的Linux系统一样，Android的第一个用户空间进程是init（init的PID值是0），它是所有其他进程的根。然而，Android的init启动的守护进程是不同的，这些守护进程更多的聚焦于底层细节（管理文件系统和硬件访问），而不是高层用户设施，例如调度定时任务。Android还有一层额外的进程，它们运行Dalvik的Java语言环境，负责执行系统中所有以Java实现的部分。
 
 
 
diff --git "a/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md" "b/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md"
index 11a00bf6..48a912cc 100644
--- "a/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md"
+++ "b/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md"
@@ -221,6 +221,47 @@ SystemServer和Zygote之间通信不使用Socket的原因是为了要解决fork
 
 在Android系统的Binder机制中，由一系统组件组成，分别是Client、Server、Service Manager和Binder驱动程序，其中Client、Server和Service  Manager运行在用户空间，Binder驱动程序运行内核空间。其中Service  Manager和Binder驱动由系统提供，而Client、Server由应用程序来实现。其中，核心组件便是Binder驱动程序了，Service Manager提供了辅助管理的功能，Client和Server正是在Binder驱动和Service  Manager提供的基础设施上，进行Client-Server之间的通信。Client、Server 和  ServiceManager 均是通过系统调用 open、mmap 和 ioctl 来访问设备文件 /dev/binder，从而实现与Binder驱动的交互来间接的实现跨进程通信。
 
+如果统观Binder中的各个组成元素，就会惊奇的发现它和TCP/IP网络有很多相似之处: 
+
+- Binder驱动 -> 路由器
+- Service Manager -> DNS
+- Binder Client -> 客户端
+- Binder Server -> 服务端
+
+TCP/IP中一个典型的服务连接过程（比如客户端通过浏览器方位Google主页）： 
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/binder_tcp_ip.png)
+
+在这个简化的流程图中共出现了四种角色，即Client、Server、DNS和Router。它们的目标是让Client和Server建立连接，主要分为如下几个步骤。 
+
+- Client向DNS查询Google.com的IP地址。
+
+    显然，Client一定要先知道DNS的IP地址，才有可能向它发起查询。DNS的IP设置是在客户端接入网络前就完成了的，否则Client将无法正常访问域名服务器。当然，如果Client已经知晓了Server的IP，那么完全可以跨越这一步而直接与Server连接。比如Windows操作系统就提供了一个hosts文件，用于查询常用网址域名与其IP地址的对应关系。当用户需要访问某个网址时，系统会先从这个文件中判断是否已经存在有这个域名的对应IP。如果有就不需要再大费周折地向DNS查询了，从而加快访问速度。
+
+- DNS将查询结果返回Client。
+
+    因为Client的IP地址对于DNS也必须是可知的，这些信息都会被封装在TCP/IP包中。
+
+- Client发起连接。
+
+- Client在得到Google.com的IP地址后，就可以据此来向Google服务器发起连接了。
+
+在这一些列流程中，我们并没有特别提及Router的作用。因为它所担负的责任是将数据包投递到用户设定的目标IP中，即Router是整个通信结构中的基础。
+
+从这个典型的TCP/IP通信中，我们还能得到什么提示呢？
+
+首先，在TCP/IP参考模型中，对于IP层及以上的用户来说，IP地址是他们彼此沟通的凭证，任何用户在整个互联网中的IP标志符都是唯一的。
+
+其次，Router是构建一个通信网络的基础，它可以根据用户填写的目标IP正确的把数据包发送到位。
+
+最后DNS角色并不是必需的，它的出现是为了帮助人们使复杂难记的IP地址与可读性更强的域名建立关联，并提供查询功能。而客户端能使用DNS的前提是它已经正确配置了DNS服务器的IP地址。
+
+Binder的本质目标用一句话来描述，就是进程1（客户端）希望与进程2（服务端）进行互访。但因为它们之间是跨进程（跨网络）的，所以必须借助于Binder驱动（路由器）来把请求正确投递到对方所在进程（网络）中。而参与通信的进程们需要持有Binder“颁发”的唯一标志（IP地址）。和TCP/IP网络类似，Binder中的DNS也并不是必需的，前提是客户端能记住它要访问的进程的Binder标志（IP地址）。而且要特别注意这个标志是动态IP，这就意味着即使客户端记住了本次通信过程中目标进程的唯一标志，下一次访问仍然需要重新获取，这无疑加大了客户端的难度。DNS的出现可以完美的解决这个问题，用于管理Binder标志与可读性更强的域名间的对应关系，并向用户提供查询功能。既然Service Manager是DNS，那么它的IP地址是什么呢？ Binder机制对此作了特别规定，Service Manager在Binder通信过程中的唯一标志永远都是0.
+
+
+
+
+
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/binder_framework.png)
 
 - Server
diff --git "a/OperatingSystem/AndroidKernal/6.\345\261\217\345\271\225\347\273\230\345\210\266\345\237\272\347\241\200.md" "b/OperatingSystem/AndroidKernal/6.\345\261\217\345\271\225\347\273\230\345\210\266\345\237\272\347\241\200.md"
index 95e4f084..620d6f10 100644
--- "a/OperatingSystem/AndroidKernal/6.\345\261\217\345\271\225\347\273\230\345\210\266\345\237\272\347\241\200.md"
+++ "b/OperatingSystem/AndroidKernal/6.\345\261\217\345\271\225\347\273\230\345\210\266\345\237\272\347\241\200.md"
@@ -39,6 +39,50 @@ Android的屏幕绘制架构如下图：
     - 每个具体的Drawable对象仅仅绘制某个特定的图案，SDK中包含的Drawable实现类有BitmapDrawable、NinePatchDrawable等。
 
 
+
+Linux内核提供了统一的framebuffer显示驱动。设备节点/dev/graphics/fb*或者/dev/fb*，其中fb0表示第一个Monitor，当前系统中只用到了一个显示屏。
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_surface_flinger.png)
+
+Android的HAL层提供了Gralloc，包括fb和gralloc两个设备。前者负责打开内核中的framebuffer、初始化配置，并提供了post、setSwapInterval等操作接口。后者则管理帧缓冲区的分配和释放。这就意味着上层元素只能通过Gralloc来间接访问帧缓冲区，从而保证了系统对framebuffer的有序使用和统一管理。
+
+另外，HAL层的另一重要模块是“Composer”，如其名所示，它为厂商自定制“UI合成”提供了接口。Composer的直接使用者是SurfaceFlinger中的HWComposer，后者除了管理Composer的HAL模块外，还负责VSync信号的产生和控制。VSync则是Project Butter工程中加入的一种同步机制，它既可以由硬件产生，也可以通过软件来moni（VsyncThread)。
+
+
+
+Framebuffer是系内核系统提供的图形硬件的抽象描述。之所以称为buffer，是因为它也占用了系统存储空间的一部分，是一块包含屏幕显示信息的缓冲区。由此可见，在一切都是文件的Linux系统中，Framebuffer被看成了终端显示设备的化身。
+
+另外，Framebuffer借助于Linux文件系统向上层应用提供了统一而高效的操作接口，从而让用户空间中运行的程序可以在不做太多修改的情况下去适配多种显示设备，无论它们属于哪家厂商、什么型号，都由Framebuffer内部来兼容。
+
+在Android系统的GUI设计理念中，提供了两种本地窗口： 
+
+- 面向管理者（SurfaceFlinger）
+
+    既然SurfaceFlinger扮演了系统中所有UI界面的管理者，那么它无可厚非需要直接或间接地持有“本地窗口。这个窗口就是FramebufferNativeWindow。
+
+- 面向应用程序
+
+    这类本地窗口是Surface。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 ---
 
diff --git "a/OperatingSystem/AndroidKernal/8.WindowManagerService\347\256\200\344\273\213.md" "b/OperatingSystem/AndroidKernal/8.WindowManagerService\347\256\200\344\273\213.md"
index cb3820e1..949eaffd 100644
--- "a/OperatingSystem/AndroidKernal/8.WindowManagerService\347\256\200\344\273\213.md"
+++ "b/OperatingSystem/AndroidKernal/8.WindowManagerService\347\256\200\344\273\213.md"
@@ -13,6 +13,10 @@ WmS是Android中图形用户接口的引擎，它管理着所有窗口，包括
 - 保持窗口的层次关系，以便SurfaceFlinger能够据此绘制屏幕
 - 把窗口信息传递给InputManager对象，以便InputDispatcher能够把输入消息派发给和屏幕上显示一致的窗口。
 
+
+
+打个比方，就像一出由N个演员参与的话剧：SurfaceFlinger是摄像机，WMS是导演，ViewRoot则是演员个体。摄像机（SurfaceFlinger）的作用是单一而规范的，它负责客观地捕获当前的画面，然后真是的呈现给观众。导演（WMS）则会考虑到话剧的舞台效果和视觉美感，如他需要根据实际情况来安排各个演员的排序站位，谁在前谁在后，都会影响到演出的”画面效果“与”剧情编排“，而各个演员的长相和标清（ViewRoot）则更多的取决于他们自身的条件与努力。正式通过这三者的”各司其职“，才能最终为观众呈现出异常美妙绝伦的”视觉盛宴“。
+
 Android采用层叠式布局，这种布局的特点在于允许多个窗口层叠显示。该布局一般都需要一个窗口管理服务端。从程序设计的角度看，有两种设计模式可以实现服务端: 
 
 - 独立进程方式
diff --git "a/SourceAnalysis/Activity\345\220\257\345\212\250\350\277\207\347\250\213.md" "b/SourceAnalysis/Activity\345\220\257\345\212\250\350\277\207\347\250\213.md"
index cc1cdbb3..5c0d5d6c 100644
--- "a/SourceAnalysis/Activity\345\220\257\345\212\250\350\277\207\347\250\213.md"
+++ "b/SourceAnalysis/Activity\345\220\257\345\212\250\350\277\207\347\250\213.md"
@@ -1496,9 +1496,15 @@ final void startActivityLocked(ActivityRecord r, boolean newTask,
 
  在Android应用程序框架层中，是由ActivityManagerService组件负责为Android应用程序创建新的进程的，它本来也是运行在一个独立的进程之中，不过这个进程是在系统启动的过程中创建的。
  ActivityManagerService组件一般会在什么情况下会为应用程序创建一个新的进程呢？当系统决定要在一个新的进程中启动一个Activity或者Service时，它就会创建一个新的进程了，
- 然后在这个新的进程中启动这个Activity或者Service
+ 然后在这个新的进程中启动这个Activity或者Service。
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/ams_start_activity.png)
+
+无论以什么方式发起一个Activity的启动流程，最终都会调用到AMS的startActivity的函数。而在AMS真正启动一个Activity之前，需要经过众多烦琐的判断和准备工作，这些工作在AMS内部都是由一些列以startActivity开头的函数来进行逐步处理的。
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/activity_start_binder.png)
+
 
-    
 ---
 
 - 邮箱 ：charon.chui@gmail.com  

From fead41f580ac363bd0004af47851c622ba5a5530 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 15 Mar 2021 14:42:49 +0800
Subject: [PATCH 045/213] update

---
 .../\345\205\263\351\224\256\345\270\247.md"  |  33 +++++-
 ...47\350\203\275\344\274\230\345\214\226.md" |  14 +++
 .../TS.md"                                    | 104 +++++++++++++++++-
 ...01\350\243\205\346\240\274\345\274\217.md" |   8 ++
 4 files changed, 152 insertions(+), 7 deletions(-)

diff --git "a/VideoDevelopment/\345\205\263\351\224\256\345\270\247.md" "b/VideoDevelopment/\345\205\263\351\224\256\345\270\247.md"
index da3274dc..5366ba8d 100644
--- "a/VideoDevelopment/\345\205\263\351\224\256\345\270\247.md"
+++ "b/VideoDevelopment/\345\205\263\351\224\256\345\270\247.md"
@@ -1,21 +1,42 @@
 关键帧
 ===
 
-**编码器将多张图像进行编码后生产成一段一段的 GOP ( Group of Pictures ) ， 解码器在播放时则是读取一段一段的 GOP 进行解码后读取画面再渲染显示。**GOP ( Group of Pictures) 是一组连续的画面，由一张 I 帧和数张 B / P  帧组成，是视频图像编码器和解码器存取的基本单位，它的排列顺序将会一直重复到影像结束。I  帧是内部编码帧（也称为关键帧），P帧是前向预测帧（前向参考帧），B 帧是双向内插帧（双向参考帧）。简单地讲，I 帧是一个完整的画面，而 P 帧和 B 帧记录的是相对于 I 帧的变化。如果没有 I 帧，P 帧和 B 帧就无法解码。
 
-在H.264压缩标准中I帧、P帧、B帧用于表示传输的视频画面。
+
+### I、P、B帧
+
+在H.264协议中定义了3中帧，完整编码的帧叫I帧、参考之前的I帧生成的只对差异部分进行编码的帧叫P帧、还有一种参考前后的帧进行编码的帧叫B帧。
 
 - I帧(Intra coded picture):帧内编码图像帧简称关键帧，这一帧画面的完整保留，解码时只需要本帧数据就可以完成.I帧通常是每个GOP(MPEG所使用的一种视频压缩技术)的第一个，GOP就是指两个I帧之间的距离。
 
     我们在做直播的时候，想要能达到秒开的效果，因为I帧是能不依赖其他帧独立完成解码的，这就意味着当播放器接收到I帧就能立马渲染出来，而接收到P、B帧则需要等待依赖的帧而不能立马完成解码和渲染，这个期间就会黑屏，所以可以在服务端通过缓存GOP，保证播放端在接入直播时能先获取到I帧马上渲染出画面，从而提高起播速度。在直播服务器中，支持设置一个cache，用于存放GOP，直播服务器缓存了当前的GOP序列，当播放端请求数据的时候，CDN会从I帧返回给客户端，从而保证客户端可以快速进行播放。当然由于缓存的是之前的视频信息，当音频数据到达播放端后，为了音视频同步播放器会进行视频的快进处理。
 
 - P帧(Predictive coded picture):预测编码图像帧简称差别帧，这一帧跟之前的一个关键帧或P帧的差别，解码时需要用之前缓存的画面叠加上本帧定义的差别，生成最终的画面。也就是说P帧没有完整的画面数据，只有与前一帧的画面差别的数据。 
+
 - B帧(Bidirectionally predicted picture):双向预测编码图像帧简称双向差别帧，也就是B帧记录的是本帧与前后帧的差别。也就是要解码B帧，不仅要取得之前的缓存画面，还要解码之后的画面，通过前后画面与本帧数据的叠加来获取最终的画面。B帧压缩率高，但是解码时会更耗CPU。
-- GOP(Group of Pictures)是一组连续的画面，由一张I帧和数张B/P帧组成，是视频图像编码器和解码器存取的基本单位，它的排列顺序将会一直重复到影像结束。
-  编码器将多张图像进行编码后生产成一段一段的 GOP ，解码器在播放时则是读取一段一段的GOP进行解码后读取画面再渲染显示。
+
+
+
+### GOP
+
+这3中帧用于表示传输的视频画面。在H.264中图像以序列为单位进行组织，一个序列是一段图像编码后的数据流，以I帧开始，到下一个I帧结束，中间部分也被称为一个GOP。     
+
+GOP(Group of Pictures)是一组连续的画面，由一张I帧和数张B/P帧组成，是视频图像编码器和解码器存取的基本单位，它的排列顺序将会一直重复到影像结束。
+编码器将多张图像进行编码后生产成一段一段的 GOP ，解码器在播放时则是读取一段一段的GOP进行解码后读取画面再渲染显示。
+
+**编码器将多张图像进行编码后生产成一段一段的 GOP ( Group of Pictures ) ， 解码器在播放时则是读取一段一段的 GOP 进行解码后读取画面再渲染显示。**GOP ( Group of Pictures) 是一组连续的画面，由一张 I 帧和数张 B / P  帧组成，是视频图像编码器和解码器存取的基本单位，它的排列顺序将会一直重复到影像结束。I  帧是内部编码帧（也称为关键帧），P帧是前向预测帧（前向参考帧），B 帧是双向内插帧（双向参考帧）。简单地讲，I 帧是一个完整的画面，而 P 帧和 B 帧记录的是相对于 I 帧的变化。如果没有 I 帧，P 帧和 B 帧就无法解码。
+
+### IDR
+
+一个序列(GOP)的第一个图像叫做IDR图像(立即刷新图像)，IDR图像都是I帧图像。H.264引入IDR图像是为了解码的重新同步，当解码器解码到IDR图像时，立即将参考帧队列清空，将已解码的数据全部输出或抛弃，重新查找下一个参考集，开始解码一个新的序列。这样，如果前一个序列出现重大错误，在这里可以获得重新同步的机会。IDR图像之后的图像永远不会使用IDR之前的图像数据来解码。一个序列就是一段内容差异不太大的图像编码后生成的一串数据流。当运动变化比较少时，一个序列可以很长，因为运动变化少就代表图像画面的内容变动很小，所以就可以是一个I帧，然后一直是P帧、B帧。当运动变化多时，一个序列可能会比较短，比如只包含一个I帧和几个P帧、B帧。
 
 - IDR（Instantaneous Decoding Refresh）--即时解码刷新。
      I帧:帧内编码帧是一种自带全部信息的独立帧，无需参考其它图像便可独立进行解码，视频序列中的第一个帧始终都是I帧。
+     
+     那么IDR帧与I帧的区别是什 么呢?因为H264采用了多帧预测，所以I帧之后的P帧有可能会参考I 帧之前的帧，这就使得在随机访问的时候不能以找到I帧作为参考条 件，因为即使找到I帧，I帧之后的帧还是有可能解析不出来，而IDR帧 就是一种特殊的I帧，即这一帧之后的所有参考帧只会参考到这个IDR 帧，而不会再参考前面的帧。在解码器中，一旦收到一个IDR帧，就会 立即清理参考帧缓冲区，并将IDR帧作为被参考的帧。
+     
+     
+     
      I和IDR帧都是使用帧内预测的。它们都是同一个东西而已,在编码和解码中为了方便，要首个I帧和其他I帧区别开，所以才把第一个首个I帧叫IDR，这样就方便控制编码和解码流程。 IDR帧的作用是立刻刷新,使错误不致传播,从IDR帧开始,重新算一个新的序列开始编码。而I帧不具有随机访问的能力，这个功能是由IDR承担。  IDR会导致DPB（DecodedPictureBuffer  参考帧列表——这是关键所在）清空，而I不会。IDR图像一定是I图像，但I图像不一定是IDR图像。一个序列中可以有很多的I图像，I图像之后的图像可以引用I图像之间的图像做运动参考。一个序列中可以有很多的I图像，I图像之后的图象可以引用I图像之间的图像做运动参考。
      对于IDR帧来说，在IDR帧之后的所有帧都不能引用任何IDR帧之前的帧的内容，与此相反，对于普通的I-帧来说，位于其之后的B-和P-帧可以引用位于普通I-帧之前的I-帧。从随机存取的视频流中，播放器永远可以从一个IDR帧播放，因为在它之后没有任何帧引用之前的帧。但是，不能在一个没有IDR帧的视频中从任意点开始播放，因为后面的帧总是会引用前面的帧 。
      收到 IDR 帧时，解码器另外需要做的工作就是：把所有的 PPS 和 SPS 参数进行更新。
@@ -36,11 +57,11 @@ P帧和B帧极大的节省了数据量，节省出来的空间可以用来多保
 
 
 
-
+### PTS和DTS
 
 【为什么会有PTS和DTS的概念】
 
-通过上面的描述可以看出：P帧需要参考前面的I帧或P帧才可以生成一张完整的图片，而B帧则需要参考前面I帧或P帧及其后面的一个P帧才可以生成一张完整的图片。这样就带来了一个问题：在视频流中，先到来的 B 帧无法立即解码，需要等待它依赖的后面的 I、P 帧先解码完成，这样一来播放时间与解码时间不一致了，顺序打乱了，那这些帧该如何播放呢？这时就引入了另外两个概念：DTS 和 PTS。
+通过上面的描述可以看出：P帧需要参考前面的I帧或P帧才可以生成一张完整的图片，而B帧则需要参考前面I帧或P帧及其后面的一个P帧才可以生成一张完整的图片。这样就带来了一个问题：在视频流中，先到来的 B 帧无法立即解码，需要等待它依赖的后面的 I、P 帧先解码完成，这样一来播放时间与解码时间不一致了，顺序打乱了，那这些帧该如何播放呢？这时就引入了另外两个概念：DTS 和 PTS。在没有B帧的情况下，DTS和PTS的输出顺序是一样的。因为B 帧打乱了解码和显示的顺序，所以一旦存在B帧，PTS与DTS势必就会 不同。
 
 【PTS和DTS】
 
diff --git "a/VideoDevelopment/\346\222\255\346\224\276\345\231\250\346\200\247\350\203\275\344\274\230\345\214\226.md" "b/VideoDevelopment/\346\222\255\346\224\276\345\231\250\346\200\247\350\203\275\344\274\230\345\214\226.md"
index d1c96ecb..aebda409 100644
--- "a/VideoDevelopment/\346\222\255\346\224\276\345\231\250\346\200\247\350\203\275\344\274\230\345\214\226.md"
+++ "b/VideoDevelopment/\346\222\255\346\224\276\345\231\250\346\200\247\350\203\275\344\274\230\345\214\226.md"
@@ -66,6 +66,20 @@
 
     空间换时间。双播放器方案原理比较简单，就是在当前视频起播之后，预准备下一个视频的播放器，两个播放器循环使用。下一个视频的播放器一旦准备好，加上视频流已加载到本地，则起播非常快，几乎是视频直出的效果。但由于播放器准备更耗时，用户滑到下一个视频时，并不能百分百保证此视频的播放器已准备好。
 
+### 预取策略
+
+1，修改AndroidVideoCache进行预加载
+ 2，线程池并发缓存并控制视频缓存优先级（线程池线程数为3，先加入的先缓存），一次预加载8个视频，item创建时开始预加载，item销毁时，取消预加载
+ 3，等待下页第一个视频预加载完成，才会进入下一页视频，保证滑到的视频都是可以立马观看的。（一页视频为8个）
+ 4，当前视频开始播放之后才会进行预加载
+ 5，区分快滑慢滑两种模式，快滑时取消当前所有预加载，慢滑不取消，因为快滑大概率滑到一个未预加载的视频，慢滑大概率滑到一个已经预加载的视频，保证滑到视频尽快播放。
+ 6，当视频播放后，根据滑动方向，会将取消的预加载进行恢复，正向滑动就恢复当前之后之后的预加载任务，反选滑动就恢复当前视频之前的预加载任务。
+ 7，限制网速，当时视频还没播放的时候，会限制预下载的网速（慢滑不会取消预加载），通过让下载线程sleep来限制网速。
+ 8，ijkplayer起播参数配置。
+ 9，视频压缩和处理（让视频参数都位于视频首部）。
+
+
+
 #### MOOV后置
 
 很多手机为了偷懒，录制完视频后才知道视频信息，所以把moov放到末尾。对于moov放到视频最后的情况下，就要多一次seek，当从头开始解析的时候如果发现未找到moov信息，需要将其seek到尾部再去寻找，这样会导致起播慢。 
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/TS.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/TS.md"
index c0a2daad..947ab46a 100644
--- "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/TS.md"
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/TS.md"
@@ -3,23 +3,125 @@ TS
 
 
 
-TODO 
+TS的全称为MPEG2-TS，TS即Transport Stream的缩写。它是分包发送的，每一个包长188字节（还有192和204字节的包）。包的结构为，包头4字节（第一个字节为0x47），负载为184字节。
 
+VD的音视频格式为MPEG2-PS，全称是Program Stream。而TS的全称则是Transport Stream。MPEG2-PS主要应用于存储的具有固定时长的节目，如DVD电影，而MPEG-TS则主要应用于实时传送的节目，比如实时广播的电视节目。这两种格式的主要区别是什么呢？简单地打个比喻说，你将DVD上的VOB文件的前面一截cut掉（或者干脆就是数据损坏），那么就会导致整个文件无法解码了，而电视节目是你任何时候打开电视机都能解码（收看）的。在TS流里可以填入很多类型的数据，如视频、音频、自定义信息等。所以，MPEG2-TS格式的特点就是要求从视频流的任一片段开始都是可以独立解码的。
 
+我们可以看出，TS格式是主要用于直播的码流结构，具有很好的容错能力。通常TS流的后缀是.ts、.mpg或者.mpeg，多数播放器直接支持这种格式的播放。TS流中不包含快速seek的机制，只能通过协议层实现seek。HLS协议基于TS流实现的。
 
 
 
+## TS格式详解
 
+TS文件（流）可以分为三层：TS层（Transport Stream）、PES层（Packet Elemental Stream）、ES层（Elementary Stream）。
 
+ES层就是音视频数据，PES层是在音视频数据上加了时间戳等对数据帧的说明信息，TS层是在PES层上加入了数据流识别和传输的必要信息。TS文件（码流）由多个TS Packet组成的。
 
 
 
+![image-20210309114928103](https://raw.githubusercontent.com/CharonChui/Pictures/master/ts_archi.png?raw=true)
 
 
 
+### TS层
 
+TS包大小固定为188字节，TS层分为三个部分：TS Header、Adaptation Field、Payload。
 
+TS Header固定4个字节；Adaptation Field可能存在也可能不存在，主要作用是给不足188字节的数据做填充；Payload是PES数据。
 
+#### 1. TS Header
+
+TS包的包头提供关于传输方面的信息。
+
+TS包的包头长度不固定，前4个字节是固定的，后面可能跟有自适应字段（适配域）。4个字节是最小包头。
+
+包头的结构体字段如下：
+
+- sync_byte（同步字节）：固定为0x47;该字节由解码器识别，使包头和有效负载可相互分离。
+- transport_error_indicator（传输错误标志）：‘1’表示在相关的传输包中至少有一个不可纠正的错误位。当被置1后，在错误被纠正之前不能重置为0。
+- payload_unit_start_indicator（负载起始标志）：为1时，表示当前TS包的有效载荷中包含PES或者PSI的起始位置；在前4个字节之后会有一个调整字节，其的数值为后面调整字段的长度length。因此有效载荷开始的位置应再偏移1+[length]个字节。
+- transport_priority（传输优先级标志）：‘1’表明当前TS包的优先级比其他具有相同PID， 但此位没有被置‘1’的TS包高。
+- PID：指示存储与分组有效负载中数据的类型。
+- transport_scrambling_control（加扰控制标志）：表示TS流分组有效负载的加密模式。空包为‘00’，如果传输包包头中包括调整字段，不应被加密。其他取值含义是用户自定义的。
+- adaptation_field_control（适配域控制标志）：表示包头是否有调整字段或有效负载。‘00’为ISO/IEC未来使用保留；‘01’仅含有效载荷，无调整字段；‘10’ 无有效载荷，仅含调整字段；‘11’ 调整字段后为有效载荷，调整字段中的前一个字节表示调整字段的长度length，有效载荷开始的位置应再偏移[length]个字节。空包应为‘10’。
+- continuity_counter（连续性计数器）：随着每一个具有相同PID的TS流分组而增加，当它达到最大值后又回复到0。范围为0~15。
+
+#### 2. TS Adaptation Field
+
+Adaptation Field的长度要包含传输错误指示符标识的一个字节。
+
+PCR是节目时钟参考，PCR、DTS、PTS都是对同一个系统时钟的采样值，PCR是递增的，因此可以将其设置为DTS值，音频数据不需要PCR。
+
+打包TS流时PAT和PMT表是没有Adaptation Field的，不够的长度直接补0xff即可。
+
+视频流和音频流都需要加adaptation field，通常加在一个帧的第一个ts包和最后一个ts包里，中间的ts包不加。
+
+#### 3. TS Payload
+
+TS包中Payload所传输的信息包括两种类型：视频、音频的PES包以及辅助数据；节目专用信息PSI。
+
+TS包也可以是空包。空包用来填充TS流，可能在重新进行多路复用时被插入或删除。
+
+视频、音频的ES流需进行打包形成视频、音频的 PES流。辅助数据（如图文电视信息）不需要打成PES包。
+
+### PES层 & ES 层
+
+#### PES层
+
+PES结构如图：
+
+![pes](https://raw.githubusercontent.com/CharonChui/Pictures/master/pes.png?raw=true)
+
+从上面的结构图可以看出，PES层是在每一个视频/音频帧上加入了时间戳等信息，PES包内容很多，下面我们说明一下最常用的字段：
+
+- pes start code：开始码，固定为0x000001。
+- stream id：音频取值（0xc0-0xdf），通常为0xc0；视频取值（0xe0-0xef），通常为0xe0。
+- pes packet length：后面pes数据的长度，0表示长度不限制，只有视频数据长度会超过0xffff。
+- pes data length：后面数据的长度，取值5或10。
+- pts：33bit值
+- dts：33bit值
+
+关于时间戳PTS和DTS的说明：
+
+1. PTS是显示时间戳、DTS是解码时间戳。
+2. 视频数据两种时间戳都需要，音频数据的PTS和DTS相同，所以只需要PTS。
+
+有PTS和DTS两种时间戳是B帧引起的，I帧和P帧的PTS等于DTS。如果一个视频没有B帧，则PTS永远和DTS相同。
+
+从文件中顺序读取视频帧，取出的帧顺序和DTS顺序相同。DTS算法比较简单，初始值 + 增量即可，PTS计算比较复杂，需要在DTS的基础上加偏移量。
+
+音频的PES中只有PTS（同DTS），视频的I、P帧两种时间戳都要有，视频B帧只要PTS（同DTS）。
+
+#### ES 层
+
+ES层指的就是音视频数据。
+
+一般的，视频为H.264视频，音频为AAC音频。
+
+
+
+
+
+## TS流生成及解析流程
+
+### TS 流生成流程
+
+- 将原始音视频数据压缩之后，压缩结果组成一个基本码流（ES）。
+- 对ES（基本码流）进行打包形成PES。
+- 在PES包中加入时间戳信息(PTS/DTS)。
+- 将PES包内容分配到一系列固定长度的传输包（TS Packet）中。
+- 在传输包中加入定时信息(PCR)。
+- 在传输包中加入节目专用信息(PSI) 。
+- 连续输出传输包形成具有恒定比特率的MPEG-TS流。
+
+### TS 流解析流程
+
+- 复用的MPEG-TS流中解析出TS包；
+- 从TS包中获取PAT及对应的PMT；
+- 从而获取特定节目的音视频PID；
+- 通过PID筛选出特定音视频相关的TS包，并解析出PES；
+- 从PES中读取到PTS/DTS，并从PES中解析出基本码流ES；
+- 将ES交给解码器，获得压缩前的原始音视频数据。
 
 
 
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217.md"
index 8899f1a8..a81d1123 100644
--- "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217.md"
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217.md"
@@ -8,6 +8,14 @@
 
 
 
+封装，也叫多路复用(mux)。封装的目的一般为了在一个文件（流）中能同时存储视频（video）、音频（audio）、字幕（subtitle）等内容——这也正是“复用”的含义所在（分时复用）。封装还有另一个作用是在网络环境下确保数据的可靠快速传输。
+
+编码的目的是为了压缩媒体数据。有别于通用文件数据的压缩，在图像或音频压缩的时候，可以借助图像特性（如前后关联、相邻图块关联）或声音特性（听觉模型）进行压缩，可以达到比通用压缩技术更高的压缩比。
+
+
+
+
+
 
 ## 音频编码格式
 

From c9f76c0a10c3270e2d36c8d9d1feee299bd7b326 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Tue, 16 Mar 2021 21:07:24 +0800
Subject: [PATCH 046/213] add notes

---
 ...01\350\231\232\345\274\225\347\224\250.md" |  15 +-
 ...20\347\240\201\345\210\206\346\236\220.md" | 792 ++++++++++++++++++
 ...20\347\240\201\350\257\246\350\247\243.md" |   6 +-
 .../\345\205\263\351\224\256\345\270\247.md"  |   2 +-
 4 files changed, 804 insertions(+), 11 deletions(-)
 create mode 100644 "SourceAnalysis/LeakCanary\346\272\220\347\240\201\345\210\206\346\236\220.md"

diff --git "a/JavaKnowledge/\345\274\272\345\274\225\347\224\250\343\200\201\350\275\257\345\274\225\347\224\250\343\200\201\345\274\261\345\274\225\347\224\250\343\200\201\350\231\232\345\274\225\347\224\250.md" "b/JavaKnowledge/\345\274\272\345\274\225\347\224\250\343\200\201\350\275\257\345\274\225\347\224\250\343\200\201\345\274\261\345\274\225\347\224\250\343\200\201\350\231\232\345\274\225\347\224\250.md"
index 1f4346c1..e5dba493 100644
--- "a/JavaKnowledge/\345\274\272\345\274\225\347\224\250\343\200\201\350\275\257\345\274\225\347\224\250\343\200\201\345\274\261\345\274\225\347\224\250\343\200\201\350\231\232\345\274\225\347\224\250.md"
+++ "b/JavaKnowledge/\345\274\272\345\274\225\347\224\250\343\200\201\350\275\257\345\274\225\347\224\250\343\200\201\345\274\261\345\274\225\347\224\250\343\200\201\350\231\232\345\274\225\347\224\250.md"
@@ -16,21 +16,22 @@
 
 
 - 强引用(Strong Reference)
-    
+  
 	你懂的，不要胡乱持有着不放，不然内存泄露、oom有你好看，就像是老板（OOM）的亲儿子一样，在公司可以什么事都不干，但是千万不要老是占用公司的资源为他自己做事，记得用完公司的妹子之后,要让她们去工作(资源要懂得释放) 不然公司很可能会垮掉的。   
 
     平时我们编程的时候例如：`Object object=new Object()`；那`object`就是一个强引用了。如果一个对象具有强引用，那就类似于必不可少的生活用品，垃圾回收器绝不会回收它。当JVM的内存空间不足时，宁愿抛出OutOfMemoryError使得程序异常终止也不愿意回收具有强引用的存活着的对象！记住是存活着，不可能是你new一个对象就永远不会被GC回收。
-    
+  
 - 软引用(SoftReference)
-    
+  
     描述一些还有用，但并非必需的对象。如果一个对象只具有软引用，那就类似于可有可物的生活用品。如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存，但是system.gc对其无效，有点像老板(OOM)的亲戚，在公司表现不好有可能会被开除，即使你投诉他（调用GC)上班看片，但是只要不被老板看到（被JVM检测到）就不会被开除（被虚拟机回收）。
     
+
 **软引用可用来实现内存敏感的高速缓存**。 软引用可以和一个引用队列`(ReferenceQueue)`联合使用，
     如果软引用所引用的对象被垃圾回收，`Java`虚拟机就会把这个软引用加入到与之关联的引用队列中。
     
 - 弱引用(WeakReference)
-    
-    同软引用，也用来描述非必须对象，但是它的强度比软引用更弱一些，被弱引用关联的对象只能生存到下一次垃圾收集发生之前。在对象没有其他引用的情况下，调用system.gc对象可被虚拟机回收，就是一个普通的员工，平常如果表现不佳会被开除（对象没有其他引用的情况下），遇到别人投诉（调用GC)上班看片,那开除是肯定了(被虚拟机回收)。
+  
+    同软引用，也用来描述非必须对象，但是它的强度比软引用更弱一些，被弱引用关联的对象只能生存到下一次垃圾收集发生之前。所以弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的声明周期。在对象没有其他引用的情况下，调用system.gc对象可被虚拟机回收，就是一个普通的员工，平常如果表现不佳会被开除（对象没有其他引用的情况下），遇到别人投诉（调用GC)上班看片,那开除是肯定了(被虚拟机回收)。
     
 	在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了***只具***有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。弱引用最常见的用途是实现规范映射(canonicalizing mappings，比如哈希表）。
 
@@ -60,12 +61,12 @@
     ```
     
 - 虚引用(PhantomReference)   
-    
+  
     "虚引用"顾名思义，就是形同虚设，也成为幽灵引用或幻影引用，它是最弱的一种引用关系。就只是一个标识，对象的生命周期不受期影响，这货估计就是个临时工把，遇到事情的时候想到了你，没有事情的时候，秒秒钟拿出去顶锅，开除。
     
     一个对象是否有虚引用的存在完全不会对其生存时间构成影响，也无法通过虚引用来取得一个对象实例。为一个对象设置虚引用关联的唯一的用处：能在对象被GC时收到系统通知，主要用于跟踪对象何时被回收，比如防止资源泄漏等。 
     
-    虚引用必须和引用队列 `(ReferenceQueue)`联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。 虚引用是每次垃圾回收的时候都会被回收，通过虚引用的get方法永远获取到的数据为null。
+    虚引用必须和引用队列 (ReferenceQueue)联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。 虚引用是每次垃圾回收的时候都会被回收，通过虚引用的get方法永远获取到的数据为null。
     
     
 
diff --git "a/SourceAnalysis/LeakCanary\346\272\220\347\240\201\345\210\206\346\236\220.md" "b/SourceAnalysis/LeakCanary\346\272\220\347\240\201\345\210\206\346\236\220.md"
new file mode 100644
index 00000000..62669286
--- /dev/null
+++ "b/SourceAnalysis/LeakCanary\346\272\220\347\240\201\345\210\206\346\236\220.md"
@@ -0,0 +1,792 @@
+LeakCanary源码分析
+===
+
+[LeakCanary](https://github.com/square/leakcanary)是一个用于检测内存泄漏的工具，可以用于Java和Android，是由著名开源组织Square贡献。
+
+强烈建议使用LeakCanary 2.x版本，更高效、使用更简单，而且没有任何Java代码，它当泄露引用到达5时才会发起heap dump，同时使用了全新的heap parser，减少内存占用，提升速度。只需要在dependencies中加入leakcanary的依赖即可。而且debugimplementation只在debug模式下有效，所以不用担心用户在正式环境下也会出现LeanCanary收集。而且是完全使用kotlin实现了，同时使用了[see Shark](https://square.github.io/leakcanary/shark/)来进行heap内存分析，更节省内存。
+
+
+
+### 使用
+
+只需在app的build.gradle中按如下配置即可，没有任何其他代码：
+
+```xml
+dependencies {
+  // debugImplementation because LeakCanary should only run in debug builds.
+  debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.6'
+}
+```
+
+
+
+到这里你肯定会有个疑问：一行Java代码都没有，它是如何做到监控的？ 后面我们就带着这个疑问来进行源码查看。不过再看源码之前，我们需要先了解一些引用的知识[**强引用、软引用、弱引用、虚引用**](https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E5%BC%BA%E5%BC%95%E7%94%A8%E3%80%81%E8%BD%AF%E5%BC%95%E7%94%A8%E3%80%81%E5%BC%B1%E5%BC%95%E7%94%A8%E3%80%81%E8%99%9A%E5%BC%95%E7%94%A8.md)
+
+这篇文章中在介绍弱引用时是这样说的: 
+
+同软引用，也用来描述非必须对象，但是它的强度比软引用更弱一些，被弱引用关联的对象只能生存到下一次垃圾收集发生之前。在对象没有其他引用的情况下，调用system.gc对象可被虚拟机回收，就是一个普通的员工，平常如果表现不佳会被开除（对象没有其他引用的情况下），遇到别人投诉（调用GC)上班看片,那开除是肯定了(被虚拟机回收)。
+
+在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了***只具***有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。
+
+而LeakCanary的原因也正是使用了弱引用的这个特点。
+
+### 监测原理
+
+ReferenceQueue+WeakReference+手动调用GC可实现这个需求。
+
+WeakReference和ReferenceQueue联合使用，
+当被WeakReference引用的对象的生命周期结束，一旦被GC检查到，GC将会把该对象添加到ReferenceQueue中，待ReferenceQueue处理。
+当GC过后对象一直不被加入ReferenceQueue，它可能存在内存泄漏。  
+
+LeakCanary的基础是一个叫做ObjectWatcher Android的library。它hook了Android的生命周期，当activity和fragment 被销毁并且应该被垃圾回收时候自动检测。这些被销毁的对象被传递给ObjectWatcher， ObjectWatcher持有这些被销毁对象的弱引用（weak references）。如果弱引用在等待5秒钟并运行垃圾收集器后仍未被清除，那么被观察的对象就被认为是保留的（retained，在生命周期结束后仍然保留），并存在潜在的泄漏。LeakCanary会在Logcat中输出这些日志。
+
+### 监测内容
+
+LeakCanary会自动监测如下对象的泄露情况： 
+
+- destroyed `Activity` instances
+- destroyed `Fragment` instances
+- destroyed fragment `View` instances
+- cleared `ViewModel` instances
+
+
+
+### 监测步骤
+
+一旦LeakCanary被安装，它会自动监测和上报泄露，分为以下四步： 
+
+1. Detecting retained objects.
+2. Dumping the heap.
+3. Analyzing the heap.
+4. Categorizing leaks.
+
+
+
+好了，我们接下来从源码的角度来看一下具体的实现，但是看到代码我懵逼了，从哪里看呢？ 我完全没头绪。 
+
+![leakcanary_source](https://raw.githubusercontent.com/CharonChui/Pictures/master/leakcanary_source.png)
+
+那就继续看官方介绍吧。
+
+## 1. Detecting retained objects[¶](https://square.github.io/leakcanary/fundamentals-how-leakcanary-works/#1-detecting-retained-objects)
+
+LeakCanary hooks into the Android lifecycle to automatically detect when activities and fragments are destroyed and should be garbage collected. These destroyed objects are passed to an `ObjectWatcher`, which holds [weak references](https://en.wikipedia.org/wiki/Weak_reference) to them. LeakCanary automatically detects leaks for the following objects:
+
+- destroyed `Activity` instances
+- destroyed `Fragment` instances
+- destroyed fragment `View` instances
+- cleared `ViewModel` instances
+
+You can watch any objects that is no longer needed, for example a detached view or a destroyed presenter:
+
+```
+AppWatcher.objectWatcher.watch(myDetachedView, "View was detached")
+```
+
+If the weak reference held by `ObjectWatcher` isn’t cleared after **waiting 5 seconds** and running garbage collection, the watched object is considered **retained**, and potentially leaking. LeakCanary logs this to Logcat:
+
+```
+D LeakCanary: Watching instance of com.example.leakcanary.MainActivity
+  (Activity received Activity#onDestroy() callback) 
+
+... 5 seconds later ...
+
+D LeakCanary: Scheduling check for retained objects because found new object
+  retained
+```
+
+LeakCanary waits for the count of retained objects to reach a threshold before dumping the heap, and displays a notification with the latest count.
+
+
+
+
+
+## 2. Dumping the heap[¶](https://square.github.io/leakcanary/fundamentals-how-leakcanary-works/#2-dumping-the-heap)
+
+When the count of retained objects reaches a threshold, LeakCanary dumps the Java heap into a `.hprof` file (a **heap dump**) stored onto the Android file system (see [Where does LeakCanary store heap dumps?](https://square.github.io/leakcanary/faq/#where-does-leakcanary-store-heap-dumps)). Dumping the heap freezes the app for a short amount of time, during which LeakCanary displays the following toast:
+
+
+
+## 3. Analyzing the heap[¶](https://square.github.io/leakcanary/fundamentals-how-leakcanary-works/#3-analyzing-the-heap)
+
+LeakCanary parses the `.hprof` file using [Shark](https://square.github.io/leakcanary/shark/) and locates the retained objects in that heap dump.
+
+
+
+## How does LeakCanary get installed by only adding a dependency?[¶](https://square.github.io/leakcanary/faq/#how-does-leakcanary-get-installed-by-only-adding-a-dependency)
+
+On Android, content providers are created after the Application instance is created but before Application.onCreate() is called. The `leakcanary-object-watcher-android` artifact has a non exported ContentProvider defined in its `AndroidManifest.xml` file. When that ContentProvider is installed, it adds activity and fragment lifecycle listeners to the application.
+
+对于Application的onCreate()方法，官方文档中是这样说的: 
+
+Called when the application is starting, before any activity, service, or receiver objects(excluding content providers)have been created.
+
+
+
+看到这里，大呼内行...这个实现太巧妙了。尽然是通过在AndroidManifest.xml中注册一个内容提供者，这个内容提供者的创建会在Application.onCreate()之前，在它创建的时候去做install的操作。
+
+
+
+这也太牛逼了，之前从来没想到ContentProvider竟然还有这个功能，以后估计很多第三方的库都会这样来实现，但是这样也会有一个问题，就是会影响到应用的冷启时间，好在LeakCanary只是在Debug的时候使用，也就不会存在这个问题了。 
+
+好了，可以看代码了，先看一下这些module的依赖关系,Gradle中的module下Task中的help中的dependencies: 
+
+```
+debugRuntimeClasspath - Runtime classpath of compilation 'debug' (target  (androidJvm)).
++--- project :leakcanary-android
+|    +--- project :leakcanary-android-core
+|    |    +--- project :shark-android
+|    |    |    +--- project :shark
+|    |    |    |    +--- project :shark-graph
+|    |    |    |    |    +--- project :shark-hprof
+|    |    |    |    |    |    +--- project :shark-log
+|    |    |    |    |    |    |    \--- org.jetbrains.kotlin:kotlin-stdlib:1.3.72 -> 1.4.21
+|    |    |    |    |    |    |         +--- org.jetbrains.kotlin:kotlin-stdlib-common:1.4.21
+|    |    |    |    |    |    |         \--- org.jetbrains:annotations:13.0
+|    |    |    |    |    |    \--- org.jetbrains.kotlin:kotlin-stdlib:1.3.72 -> 1.4.21 (*)
+|    |    |    |    |    +--- org.jetbrains.kotlin:kotlin-stdlib:1.3.72 -> 1.4.21 (*)
+|    |    |    |    |    \--- com.squareup.okio:okio:2.2.2
+|    |    |    |    |         \--- org.jetbrains.kotlin:kotlin-stdlib:1.2.60 -> 1.4.21 (*)
+|    |    |    |    +--- org.jetbrains.kotlin:kotlin-stdlib:1.3.72 -> 1.4.21 (*)
+|    |    |    |    \--- com.squareup.okio:okio:2.2.2 (*)
+|    |    |    \--- org.jetbrains.kotlin:kotlin-stdlib:1.3.72 -> 1.4.21 (*)
+|    |    +--- project :leakcanary-object-watcher-android
+|    |    |    +--- project :leakcanary-object-watcher
+|    |    |    |    +--- project :shark-log (*)
+|    |    |    |    \--- org.jetbrains.kotlin:kotlin-stdlib:1.3.72 -> 1.4.21 (*)
+|    |    |    +--- project :leakcanary-android-utils
+|    |    |    |    +--- project :shark-log (*)
+|    |    |    |    \--- org.jetbrains.kotlin:kotlin-stdlib:1.3.72 -> 1.4.21 (*)
+|    |    |    +--- com.squareup.curtains:curtains:1.0.1
+|    |    |    |    \--- org.jetbrains.kotlin:kotlin-stdlib:1.4.21 (*)
+|    |    |    \--- org.jetbrains.kotlin:kotlin-stdlib:1.3.72 -> 1.4.21 (*)
+|    |    +--- project :leakcanary-object-watcher-android-androidx
+|    |    |    +--- project :leakcanary-object-watcher-android (*)
+|    |    |    \--- org.jetbrains.kotlin:kotlin-stdlib:1.3.72 -> 1.4.21 (*)
+|    |    +--- project :leakcanary-object-watcher-android-support-fragments
+|    |    |    +--- project :leakcanary-object-watcher-android (*)
+|    |    |    \--- org.jetbrains.kotlin:kotlin-stdlib:1.3.72 -> 1.4.21 (*)
+|    |    +--- project :plumber-android
+|    |    |    +--- project :shark-log (*)
+|    |    |    +--- project :leakcanary-android-utils (*)
+|    |    |    \--- org.jetbrains.kotlin:kotlin-stdlib:1.3.72 -> 1.4.21 (*)
+|    |    \--- org.jetbrains.kotlin:kotlin-stdlib:1.3.72 -> 1.4.21 (*)
+|    \--- org.jetbrains.kotlin:kotlin-stdlib:1.3.72 -> 1.4.21 (*)
+\--- org.jetbrains.kotlin:kotlin-stdlib:1.3.72 -> 1.4.21 (*)
+
+```
+
+
+
+那我们就去`leakcanary-object-watcher-android`库的AndroidManifest.xml中看一下这个内容提供者:  
+
+```xml
+  <application>
+    <provider
+        android:name="leakcanary.internal.AppWatcherInstaller$MainProcess"
+        android:authorities="${applicationId}.leakcanary-installer"
+        android:enabled="@bool/leak_canary_watcher_auto_install"
+        android:exported="false"/>
+  </application>
+```
+
+继续看一下AppWatcherInstaller类的实现:  
+
+```kotlin
+/**
+ * Content providers are loaded before the application class is created. [AppWatcherInstaller] is
+ * used to install [leakcanary.AppWatcher] on application start.
+ */
+internal sealed class AppWatcherInstaller : ContentProvider() {
+
+  /**
+   * [MainProcess] automatically sets up the LeakCanary code that runs in the main app process.
+   */
+  internal class MainProcess : AppWatcherInstaller()
+
+  /**
+   * When using the `leakcanary-android-process` artifact instead of `leakcanary-android`,
+   * [LeakCanaryProcess] automatically sets up the LeakCanary code
+   */
+  internal class LeakCanaryProcess : AppWatcherInstaller()
+
+  override fun onCreate(): Boolean {
+    val application = context!!.applicationContext as Application
+    AppWatcher.manualInstall(application)
+    return true
+  }
+
+  override fun query(
+    uri: Uri,
+    strings: Array<String>?,
+    s: String?,
+    strings1: Array<String>?,
+    s1: String?
+  ): Cursor? {
+    return null
+  }
+
+  override fun getType(uri: Uri): String? {
+    return null
+  }
+
+  override fun insert(
+    uri: Uri,
+    contentValues: ContentValues?
+  ): Uri? {
+    return null
+  }
+
+  override fun delete(
+    uri: Uri,
+    s: String?,
+    strings: Array<String>?
+  ): Int {
+    return 0
+  }
+
+  override fun update(
+    uri: Uri,
+    contentValues: ContentValues?,
+    s: String?,
+    strings: Array<String>?
+  ): Int {
+    return 0
+  }
+}
+```
+
+上面的注释说的很明白，这个内容提供者的主要目的就是调用AppWatcher.install，我们继续看一下AppWatcher.manualInstall()方法:  
+
+```kot
+  @JvmOverloads
+  fun manualInstall(
+    application: Application,
+    retainedDelayMillis: Long = TimeUnit.SECONDS.toMillis(5),
+    watchersToInstall: List<InstallableWatcher> = appDefaultWatchers(application)
+  ) {
+  	// 检查是否是主线程
+    checkMainThread()
+    // 检查是否已经installed
+    check(!isInstalled) {
+      "AppWatcher already installed"
+    }
+    check(retainedDelayMillis >= 0) {
+      "retainedDelayMillis $retainedDelayMillis must be at least 0 ms"
+    }
+    this.retainedDelayMillis = retainedDelayMillis
+    if (application.isDebuggableBuild) {
+      // debug模式的话就初始化泄露信息的logcat打印
+      LogcatSharkLog.install()
+    }
+    // Requires AppWatcher.objectWatcher to be set
+    LeakCanaryDelegate.loadLeakCanary(application)
+
+    watchersToInstall.forEach {
+      // 不传递的话，默认为appDefaultWatchers，将这里面的四个类型的检测器各自初始化
+      it.install()
+    }
+  }
+  
+  // appDefaultWatchers()的实现为: 
+    fun appDefaultWatchers(
+    application: Application,
+    reachabilityWatcher: ReachabilityWatcher = objectWatcher
+  ): List<InstallableWatcher> {
+    return listOf(
+      ActivityWatcher(application, reachabilityWatcher),
+      FragmentAndViewModelWatcher(application, reachabilityWatcher),
+      RootViewWatcher(reachabilityWatcher),
+      ServiceWatcher(reachabilityWatcher)
+    )
+  }
+  
+```
+
+这里我们以ActivityWatcher为例，看一下它的install实现: 
+
+```kotlin
+/**
+ * Expects activities to become weakly reachable soon after they receive the [Activity.onDestroy]
+ * callback.
+ */
+class ActivityWatcher(
+  private val application: Application,
+  private val reachabilityWatcher: ReachabilityWatcher
+) : InstallableWatcher {
+
+  private val lifecycleCallbacks =
+    object : Application.ActivityLifecycleCallbacks by noOpDelegate() {
+      override fun onActivityDestroyed(activity: Activity) {
+        reachabilityWatcher.expectWeaklyReachable(
+          activity, "${activity::class.java.name} received Activity#onDestroy() callback"
+        )
+      }
+    }
+
+  override fun install() {
+    application.registerActivityLifecycleCallbacks(lifecycleCallbacks)
+  }
+
+  override fun uninstall() {
+    application.unregisterActivityLifecycleCallbacks(lifecycleCallbacks)
+  }
+}
+```
+
+这里面的实现也很简单，就是通过Application.registerActivityLifecycleCallbacks然后在activity destroy的回调中去执行ReachabilityWatcher接口的expectWeaklyReachable，ReachabilityWatcher接口的实现类是ObjectWatcher类: 
+
+```kotlin
+class ObjectWatcher constructor(
+  private val clock: Clock,
+  private val checkRetainedExecutor: Executor,
+  /**
+   * Calls to [watch] will be ignored when [isEnabled] returns false
+   */
+  private val isEnabled: () -> Boolean = { true }
+) : ReachabilityWatcher {  
+  // ...
+  // Map集合，用来存放要观察对象的key和弱引用,代码会为每个观察的对象生成一个唯一的key和弱应用  
+  private val watchedObjects = mutableMapOf<String, KeyedWeakReference>()
+  // 这个队列是与弱引用联合使用，当弱引用中的对象被回收后，这个弱引用会被放到这个队列中。
+  // 也就是说只要存在与这个队列中的弱引用就代表该弱引用所包含的对象被回收了。  
+  private val queue = ReferenceQueue<Any>()
+
+  @Synchronized override fun expectWeaklyReachable(
+    watchedObject: Any,
+    description: String
+  ) {
+    if (!isEnabled()) {
+      return
+    }
+    // 清理操作：先移除watchedObjects和queue中已经被回收的对象的弱引用
+    removeWeaklyReachableObjects()
+    // 生成唯一的key  
+    val key = UUID.randomUUID()
+      .toString()
+    val watchUptimeMillis = clock.uptimeMillis()
+    // 用要监听的对象创建KeyedWeakReference  
+    val reference =
+      KeyedWeakReference(watchedObject, key, description, watchUptimeMillis, queue)
+    SharkLog.d {
+      "Watching " +
+        (if (watchedObject is Class<*>) watchedObject.toString() else "instance of ${watchedObject.javaClass.name}") +
+        (if (description.isNotEmpty()) " ($description)" else "") +
+        " with key $key"
+    }
+
+    watchedObjects[key] = reference
+    // 这是一个延迟任务，延迟五秒后再次执行moveToRetained()方法
+    checkRetainedExecutor.execute {
+      moveToRetained(key)
+    }
+  }
+}    
+```
+
+我们继续看moveToRetained()方法的实现:  
+
+```kotlin
+  @Synchronized private fun moveToRetained(key: String) {
+    // 该方法会调用removeWeaklyReachableObjects再去执行一次清理操作  
+    // 因为这个期间对象可能已经被回收了，所以需要再清理一次  
+    removeWeaklyReachableObjects()
+    val retainedRef = watchedObjects[key]
+    // 等再执行完清理操作后，那还在watchedObjects集合中的对象就是没有被回收的对象了  
+    if (retainedRef != null) {
+      retainedRef.retainedUptimeMillis = clock.uptimeMillis()
+      onObjectRetainedListeners.forEach { it.onObjectRetained() }
+    }
+  }
+```
+
+继续看OnObjectRetainedListener接口的onObjectRetained()方法，这里它的实现类是InternalLeakCanary:  
+
+```kotlin
+  private lateinit var heapDumpTrigger: HeapDumpTrigger
+
+  override fun onObjectRetained() = scheduleRetainedObjectCheck()
+
+  fun scheduleRetainedObjectCheck() {
+    if (this::heapDumpTrigger.isInitialized) {
+      heapDumpTrigger.scheduleRetainedObjectCheck()
+    }
+  }
+```
+
+继续看HeapDumpTrigger类的scheduleRetainedObjectCheck():  
+
+```kotlin
+  fun scheduleRetainedObjectCheck(
+    delayMillis: Long = 0L
+  ) {
+    val checkCurrentlyScheduledAt = checkScheduledAt
+    if (checkCurrentlyScheduledAt > 0) {
+      return
+    }
+    checkScheduledAt = SystemClock.uptimeMillis() + delayMillis
+    backgroundHandler.postDelayed({
+      checkScheduledAt = 0
+      checkRetainedObjects()
+    }, delayMillis)
+  }
+```
+
+这里会立即执行checkRetainedObjects()方法:    
+
+```kotlin
+private fun checkRetainedObjects() {
+ 	// 调用ObjectWatcher中watchedObjects集合中对象retainedUptimeMillis != -1的数量
+    // 这些是可能发生泄漏的对象数量  
+    var retainedReferenceCount = objectWatcher.retainedObjectCount
+    if (retainedReferenceCount > 0) {
+      // 如果数量> 0，调用gc
+      gcTrigger.runGc()
+      // 调用完gc后重新获取数量
+      retainedReferenceCount = objectWatcher.retainedObjectCount
+    }
+	// 如果个数小于5，不做操作等待5秒再次进行检查未回收的个数，一直循环，直到大于等于5个或者等于0个，为了防止频发回收堆造成卡顿。
+    // 大于5个后，如果处于debug模式，会再等20秒，再次执行循环gc的操作。防止debug模式会减慢回收
+    if (checkRetainedCount(retainedReferenceCount, config.retainedVisibleThreshold)) return
+
+    val now = SystemClock.uptimeMillis()
+    val elapsedSinceLastDumpMillis = now - lastHeapDumpUptimeMillis
+    // 距离上次堆栈分析是否大于等于1分钟，如果没有超过一分钟，也需要再次延迟（1分钟-当前距离上次的时间）再次循环gc的操作
+    if (elapsedSinceLastDumpMillis < WAIT_BETWEEN_HEAP_DUMPS_MILLIS) {
+      onRetainInstanceListener.onEvent(DumpHappenedRecently)
+      showRetainedCountNotification(
+        objectCount = retainedReferenceCount,
+        contentText = application.getString(R.string.leak_canary_notification_retained_dump_wait)
+      )
+      scheduleRetainedObjectCheck(
+        delayMillis = WAIT_BETWEEN_HEAP_DUMPS_MILLIS - elapsedSinceLastDumpMillis
+      )
+      return
+    }
+
+    dismissRetainedCountNotification()
+    val visibility = if (applicationVisible) "visible" else "not visible"
+    // 最终调用dump
+    dumpHeap(
+      retainedReferenceCount = retainedReferenceCount,
+      retry = true,
+      reason = "$retainedReferenceCount retained objects, app is $visibility"
+    )
+  }
+```
+
+继续看dumpHeap()方法:  
+
+```kotlin
+  private fun dumpHeap(
+    retainedReferenceCount: Int,
+    retry: Boolean,
+    reason: String
+  ) {
+    saveResourceIdNamesToMemory()
+    val heapDumpUptimeMillis = SystemClock.uptimeMillis()
+    KeyedWeakReference.heapDumpUptimeMillis = heapDumpUptimeMillis
+    // HeapDumper.dumpHeap()方法来获取Heap信息，生成hprof文件  
+    when (val heapDumpResult = heapDumper.dumpHeap()) {
+      is NoHeapDump -> {
+        if (retry) {
+          SharkLog.d { "Failed to dump heap, will retry in $WAIT_AFTER_DUMP_FAILED_MILLIS ms" }
+          scheduleRetainedObjectCheck(
+            delayMillis = WAIT_AFTER_DUMP_FAILED_MILLIS
+          )
+        } else {
+          SharkLog.d { "Failed to dump heap, will not automatically retry" }
+        }
+        showRetainedCountNotification(
+          objectCount = retainedReferenceCount,
+          contentText = application.getString(
+            R.string.leak_canary_notification_retained_dump_failed
+          )
+        )
+      }
+      is HeapDump -> {
+        lastDisplayedRetainedObjectCount = 0
+        lastHeapDumpUptimeMillis = SystemClock.uptimeMillis()
+        // 清楚早于heapDumpUptimeMillis之前的元素  
+        objectWatcher.clearObjectsWatchedBefore(heapDumpUptimeMillis)
+        // 将heap信息文件交给HeapAnalyzerService进行分析  
+        HeapAnalyzerService.runAnalysis(
+          context = application,
+          heapDumpFile = heapDumpResult.file,
+          heapDumpDurationMillis = heapDumpResult.durationMillis,
+          heapDumpReason = reason
+        )
+      }
+    }
+  }
+```
+
+
+
+所以我们要分两部分量看: 
+
+##### 1. HeapDumper接口的实现类是AndroidHeapDumper.dumpHeap()
+
+```kotlin
+  override fun dumpHeap(): DumpHeapResult {
+    val heapDumpFile = leakDirectoryProvider.newHeapDumpFile() ?: return NoHeapDump
+
+    val waitingForToast = FutureResult<Toast?>()
+    showToast(waitingForToast)
+
+    if (!waitingForToast.wait(5, SECONDS)) {
+      SharkLog.d { "Did not dump heap, too much time waiting for Toast." }
+      return NoHeapDump
+    }
+
+    val notificationManager =
+      context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+    if (Notifications.canShowNotification) {
+      val dumpingHeap = context.getString(R.string.leak_canary_notification_dumping)
+      val builder = Notification.Builder(context)
+        .setContentTitle(dumpingHeap)
+      val notification = Notifications.buildNotification(context, builder, LEAKCANARY_LOW)
+      notificationManager.notify(R.id.leak_canary_notification_dumping_heap, notification)
+    }
+
+    val toast = waitingForToast.get()
+
+    return try {
+      val durationMillis = measureDurationMillis {
+        // 系统Debug.dumpHprofData方法进行堆转储，保存在yyyy-MM-dd_HH-mm-ss_SSS.hprof
+        Debug.dumpHprofData(heapDumpFile.absolutePath)
+      }
+      if (heapDumpFile.length() == 0L) {
+        SharkLog.d { "Dumped heap file is 0 byte length" }
+        NoHeapDump
+      } else {
+        HeapDump(file = heapDumpFile, durationMillis = durationMillis)
+      }
+    } catch (e: Exception) {
+      SharkLog.d(e) { "Could not dump heap" }
+      // Abort heap dump
+      NoHeapDump
+    } finally {
+      cancelToast(toast)
+      notificationManager.cancel(R.id.leak_canary_notification_dumping_heap)
+    }
+  }
+```
+
+
+
+
+
+##### 2. HeapAnalyzerService.runAnalysis()
+
+```kotlin
+companion object {
+    private const val HEAPDUMP_FILE_EXTRA = "HEAPDUMP_FILE_EXTRA"
+    private const val HEAPDUMP_DURATION_MILLIS_EXTRA = "HEAPDUMP_DURATION_MILLIS_EXTRA"
+    private const val HEAPDUMP_REASON_EXTRA = "HEAPDUMP_REASON_EXTRA"
+    private const val PROGUARD_MAPPING_FILE_NAME = "leakCanaryObfuscationMapping.txt"
+
+    fun runAnalysis(
+      context: Context,
+      heapDumpFile: File,
+      heapDumpDurationMillis: Long? = null,
+      heapDumpReason: String = "Unknown"
+    ) {
+      val intent = Intent(context, HeapAnalyzerService::class.java)
+      intent.putExtra(HEAPDUMP_FILE_EXTRA, heapDumpFile)
+      intent.putExtra(HEAPDUMP_REASON_EXTRA, heapDumpReason)
+      heapDumpDurationMillis?.let {
+        intent.putExtra(HEAPDUMP_DURATION_MILLIS_EXTRA, heapDumpDurationMillis)
+      }
+      startForegroundService(context, intent)
+    }
+
+    private fun startForegroundService(
+      context: Context,
+      intent: Intent
+    ) {
+      if (SDK_INT >= 26) {
+        context.startForegroundService(intent)
+      } else {
+        // Pre-O behavior.
+        context.startService(intent)
+      }
+    }
+  }
+```
+
+这里面会去启动HeapAnalyzerService，然后会执行到onHandleIntentInForeground()中: 
+
+```kotlin
+override fun onHandleIntentInForeground(intent: Intent?) {
+    if (intent == null || !intent.hasExtra(HEAPDUMP_FILE_EXTRA)) {
+      SharkLog.d { "HeapAnalyzerService received a null or empty intent, ignoring." }
+      return
+    }
+
+    // Since we're running in the main process we should be careful not to impact it.
+    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND)
+    // 取出传递过来的hprof文件信息
+    val heapDumpFile = intent.getSerializableExtra(HEAPDUMP_FILE_EXTRA) as File
+    val heapDumpReason = intent.getStringExtra(HEAPDUMP_REASON_EXTRA)
+    val heapDumpDurationMillis = intent.getLongExtra(HEAPDUMP_DURATION_MILLIS_EXTRA, -1)
+
+    val config = LeakCanary.config
+    // 将解析结果保存到HeapAnalysis中
+    val heapAnalysis = if (heapDumpFile.exists()) {
+      // 解析该文件  
+      analyzeHeap(heapDumpFile, config)
+    } else {
+      missingFileFailure(heapDumpFile)
+    }
+    val fullHeapAnalysis = when (heapAnalysis) {
+      is HeapAnalysisSuccess -> heapAnalysis.copy(
+        dumpDurationMillis = heapDumpDurationMillis,
+        metadata = heapAnalysis.metadata + ("Heap dump reason" to heapDumpReason)
+      )
+      is HeapAnalysisFailure -> heapAnalysis.copy(dumpDurationMillis = heapDumpDurationMillis)
+    }
+    onAnalysisProgress(REPORTING_HEAP_ANALYSIS)
+    // 将解析结果回调回去
+    config.onHeapAnalyzedListener.onHeapAnalyzed(fullHeapAnalysis)
+  }
+```
+
+继续查看analyzeHeap() :  
+
+```kotlin
+  private fun analyzeHeap(
+    heapDumpFile: File,
+    config: Config
+  ): HeapAnalysis {
+    val heapAnalyzer = HeapAnalyzer(this)
+
+    val proguardMappingReader = try {
+      ProguardMappingReader(assets.open(PROGUARD_MAPPING_FILE_NAME))
+    } catch (e: IOException) {
+      null
+    }
+    return heapAnalyzer.analyze(
+      heapDumpFile = heapDumpFile,
+      leakingObjectFinder = config.leakingObjectFinder,
+      referenceMatchers = config.referenceMatchers,
+      computeRetainedHeapSize = config.computeRetainedHeapSize,
+      objectInspectors = config.objectInspectors,
+      metadataExtractor = config.metadataExtractor,
+      proguardMapping = proguardMappingReader?.readProguardMapping()
+    )
+  }
+```
+
+继续使用Shark库中的HeapAnalyzer.analyze()方法：   
+
+```kotlin
+fun analyze(
+    heapDumpFile: File,
+    leakingObjectFinder: LeakingObjectFinder,
+    referenceMatchers: List<ReferenceMatcher> = emptyList(),
+    computeRetainedHeapSize: Boolean = false,
+    objectInspectors: List<ObjectInspector> = emptyList(),
+    metadataExtractor: MetadataExtractor = MetadataExtractor.NO_OP,
+    proguardMapping: ProguardMapping? = null
+  ): HeapAnalysis {
+    val analysisStartNanoTime = System.nanoTime()
+
+    if (!heapDumpFile.exists()) {
+      val exception = IllegalArgumentException("File does not exist: $heapDumpFile")
+      return HeapAnalysisFailure(
+        heapDumpFile = heapDumpFile,
+        createdAtTimeMillis = System.currentTimeMillis(),
+        analysisDurationMillis = since(analysisStartNanoTime),
+        exception = HeapAnalysisException(exception)
+      )
+    }
+
+    return try {
+      listener.onAnalysisProgress(PARSING_HEAP_DUMP)
+      // 生成hprof文件中Record的关系图  
+      val sourceProvider = ConstantMemoryMetricsDualSourceProvider(FileSourceProvider(heapDumpFile))
+      sourceProvider.openHeapGraph(proguardMapping).use { graph ->
+        val helpers =
+          FindLeakInput(graph, referenceMatchers, computeRetainedHeapSize, objectInspectors)
+        // 构建从GC Roots到监测对象的最短引用路径，并返回结果                                                 
+        val result = helpers.analyzeGraph(
+          metadataExtractor, leakingObjectFinder, heapDumpFile, analysisStartNanoTime
+        )
+        val lruCacheStats = (graph as HprofHeapGraph).lruCacheStats()
+        val randomAccessStats =
+          "RandomAccess[" +
+            "bytes=${sourceProvider.randomAccessByteReads}," +
+            "reads=${sourceProvider.randomAccessReadCount}," +
+            "travel=${sourceProvider.randomAccessByteTravel}," +
+            "range=${sourceProvider.byteTravelRange}," +
+            "size=${heapDumpFile.length()}" +
+            "]"
+        val stats = "$lruCacheStats $randomAccessStats"
+        result.copy(metadata = result.metadata + ("Stats" to stats))
+      }
+    } catch (exception: Throwable) {
+      HeapAnalysisFailure(
+        heapDumpFile = heapDumpFile,
+        createdAtTimeMillis = System.currentTimeMillis(),
+        analysisDurationMillis = since(analysisStartNanoTime),
+        exception = HeapAnalysisException(exception)
+      )
+    }
+  }
+```
+
+```kotlin
+private fun FindLeakInput.analyzeGraph(
+    metadataExtractor: MetadataExtractor,
+    leakingObjectFinder: LeakingObjectFinder,
+    heapDumpFile: File,
+    analysisStartNanoTime: Long
+  ): HeapAnalysisSuccess {
+    listener.onAnalysisProgress(EXTRACTING_METADATA)
+    val metadata = metadataExtractor.extractMetadata(graph)
+
+    val retainedClearedWeakRefCount = KeyedWeakReferenceFinder.findKeyedWeakReferences(graph)
+      .filter { it.isRetained && !it.hasReferent }.count()
+
+    // This should rarely happens, as we generally remove all cleared weak refs right before a heap
+    // dump.
+    val metadataWithCount = if (retainedClearedWeakRefCount > 0) {
+      metadata + ("Count of retained yet cleared" to "$retainedClearedWeakRefCount KeyedWeakReference instances")
+    } else {
+      metadata
+    }
+
+    listener.onAnalysisProgress(FINDING_RETAINED_OBJECTS)
+    val leakingObjectIds = leakingObjectFinder.findLeakingObjectIds(graph)
+
+    val (applicationLeaks, libraryLeaks, unreachableObjects) = findLeaks(leakingObjectIds)
+
+    return HeapAnalysisSuccess(
+      heapDumpFile = heapDumpFile,
+      createdAtTimeMillis = System.currentTimeMillis(),
+      analysisDurationMillis = since(analysisStartNanoTime),
+      metadata = metadataWithCount,
+      applicationLeaks = applicationLeaks,
+      libraryLeaks = libraryLeaks,
+      unreachableObjects = unreachableObjects
+    )
+  }
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/SourceAnalysis/butterknife\346\272\220\347\240\201\350\257\246\350\247\243.md" "b/SourceAnalysis/butterknife\346\272\220\347\240\201\350\257\246\350\247\243.md"
index ada7be25..dfe613b2 100644
--- "a/SourceAnalysis/butterknife\346\272\220\347\240\201\350\257\246\350\247\243.md"
+++ "b/SourceAnalysis/butterknife\346\272\220\347\240\201\350\257\246\350\247\243.md"
@@ -261,7 +261,7 @@ private Map<TypeElement, BindingClass> findAndParseTargets(RoundEnvironment env)
     return targetClassMap;
   }
 ```
- 
+
 继续看一下`parseBindView()`方法:   
 ```java
 private void parseBindView(Element element, Map<TypeElement, BindingClass> targetClassMap,
@@ -484,7 +484,7 @@ static final Map<Class<?>, ViewBinder<Object>> BINDERS = new LinkedHashMap<>();
 
 那`$_ViewBinder`类里面都是什么内容呢？ 我们去看一下该类的代码，但是它生成的代码在哪里呢？
 ![image](https://github.com/CharonChui/Pictures/blob/master/butterknife_apt_genierate_code.png?raw=true)
-   
+
 
 开始看一下`SimpleActivity_ViewBinder.bind()`方法:      
 ```java
@@ -565,7 +565,7 @@ public class SimpleActivity_ViewBinding<T extends SimpleActivity> implements Unb
 }
 ```
 可以看到他内部会通过`findViewByid()`等来找到对应的`View`，然后将其赋值给`target.xxxx`，所以这样就相当于把所有的控件以及事件都给初始化了，以后就可以直接使用了，通过这里也可以看到我们在使用注解的时候不要把控件或者方法声明为`private`的。   
- 
+
 
 
 总结一下:      
diff --git "a/VideoDevelopment/\345\205\263\351\224\256\345\270\247.md" "b/VideoDevelopment/\345\205\263\351\224\256\345\270\247.md"
index 5366ba8d..a3884aec 100644
--- "a/VideoDevelopment/\345\205\263\351\224\256\345\270\247.md"
+++ "b/VideoDevelopment/\345\205\263\351\224\256\345\270\247.md"
@@ -33,7 +33,7 @@ GOP(Group of Pictures)是一组连续的画面，由一张I帧和数张B/P帧组
 - IDR（Instantaneous Decoding Refresh）--即时解码刷新。
      I帧:帧内编码帧是一种自带全部信息的独立帧，无需参考其它图像便可独立进行解码，视频序列中的第一个帧始终都是I帧。
      
-     那么IDR帧与I帧的区别是什 么呢?因为H264采用了多帧预测，所以I帧之后的P帧有可能会参考I 帧之前的帧，这就使得在随机访问的时候不能以找到I帧作为参考条 件，因为即使找到I帧，I帧之后的帧还是有可能解析不出来，而IDR帧 就是一种特殊的I帧，即这一帧之后的所有参考帧只会参考到这个IDR 帧，而不会再参考前面的帧。在解码器中，一旦收到一个IDR帧，就会 立即清理参考帧缓冲区，并将IDR帧作为被参考的帧。
+     那么IDR帧与I帧的区别是什么呢?因为H264采用了多帧预测，所以I帧之后的P帧有可能会参考I 帧之前的帧，这就使得在随机访问的时候不能以找到I帧作为参考条 件，因为即使找到I帧，I帧之后的帧还是有可能解析不出来，而IDR帧 就是一种特殊的I帧，即这一帧之后的所有参考帧只会参考到这个IDR 帧，而不会再参考前面的帧。在解码器中，一旦收到一个IDR帧，就会 立即清理参考帧缓冲区，并将IDR帧作为被参考的帧。
      
      
      

From 5b27ac2733fdc43cd7822a1c70aeb1932e242309 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Tue, 16 Mar 2021 21:10:29 +0800
Subject: [PATCH 047/213] update README

---
 README.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/README.md b/README.md
index cb8b3b84..1a456b7f 100644
--- a/README.md
+++ b/README.md
@@ -24,6 +24,7 @@ Android学习笔记
     - [ListView源码分析][8]
     - [VideoView源码分析][9]
     - [View绘制过程详解][10]
+    - [LeakCanary源码分析][284]
     - [网络部分][11]
         - [HttpURLConnection详解][12]
         - [HttpURLConnection与HttpClient][13]
@@ -601,7 +602,7 @@ Android学习笔记
 
 [283]: https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/AndroidKernal/9.PackageManagerService%E7%AE%80%E4%BB%8B.md "9.PackageManagerService简介"
 
-
+[ 284 ]: https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/LeakCanary%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90.md. "LeakCanary源码分析"
 
 
 Developed By

From 085c3030829e7bf8d749321ad62e96a0bd874608 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Fri, 19 Mar 2021 19:17:54 +0800
Subject: [PATCH 048/213] update

---
 ...27\256\351\242\230\345\210\206\346\236\220.md" | 15 ++++++++++++++-
 "JavaKnowledge/Git\347\256\200\344\273\213.md"    | 11 +++++------
 ...63\273\347\273\237\347\256\200\344\273\213.md" |  8 ++++++++
 ...50\213\344\270\216\347\272\277\347\250\213.md" |  4 ++--
 ...66\210\346\201\257\346\234\272\345\210\266.md" |  6 +++++-
 ...73\230\345\210\266\345\237\272\347\241\200.md" | 14 ++++++++++++++
 6 files changed, 48 insertions(+), 10 deletions(-)

diff --git "a/AdavancedPart/OOM\351\227\256\351\242\230\345\210\206\346\236\220.md" "b/AdavancedPart/OOM\351\227\256\351\242\230\345\210\206\346\236\220.md"
index 793904c7..e7dcaaa0 100644
--- "a/AdavancedPart/OOM\351\227\256\351\242\230\345\210\206\346\236\220.md"
+++ "b/AdavancedPart/OOM\351\227\256\351\242\230\345\210\206\346\236\220.md"
@@ -5,6 +5,19 @@ OOM问题分析
 
 OOM(OutOfMemoryError)，最近线上版本出现了大量线程OOM的crash，尤其是华为Android 9.0系统的手机，占总OOM量的85%左右。
 
+
+
+## 内存指标概念
+
+
+
+- USS(Unique Set Size): 物理内存，进程独占的内存
+- PSS(Proportional Set Size): 物理内存，PSS = USS + 按比例包含共享库
+- RSS(Resident Set Size): 物理内存，RSS = USS + 包含共享库
+- VSS(Virtual Set Size): 虚拟内存，VSS = RSS + 未分配实际物理内存
+
+
+
 ### OOM分类
 
 #### [XXXClassName] of length XXX would overflow“是系统限制String/Array的长度所致，这种情况比较少。
@@ -761,7 +774,7 @@ nonvoluntary_ctxt_switches:     328
 ```
 当线程数（可以在/proc/pid/status 中的threads项实时查看）超过/proc/sys/kernel/threads-max 中规定的上限时产生 OOM 崩溃。
 ```
-   
+
 ## 定位验证方法:  
 
 Thread.UncaughtExceptionHandler捕获到OutOfMemoryError时记录/proc/pid目录下的如下信息:  
diff --git "a/JavaKnowledge/Git\347\256\200\344\273\213.md" "b/JavaKnowledge/Git\347\256\200\344\273\213.md"
index c1022154..2a33f604 100644
--- "a/JavaKnowledge/Git\347\256\200\344\273\213.md"
+++ "b/JavaKnowledge/Git\347\256\200\344\273\213.md"
@@ -91,7 +91,7 @@ git push  // 把所有文件从本地仓库推送进远程仓库
 ```
 
 先上一张图             
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git.jpg)                  
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git.png)                  
 图中的`index`部分就是暂存区           
 
 - 安装好git后我们要先配置一下。以便`git`跟踪。           
@@ -99,7 +99,7 @@ git push  // 把所有文件从本地仓库推送进远程仓库
     ```
     git config --global user.name "xxx"            
     git config --global user.email "xxx@xxx.com"
-    ```          
+    ```
     上面修改后可以使用`cat ~/.gitconfig`查看                      
     如果指向修改仓库中的用户名时可以不加`--global`，这样可以用`cat .git/config`来查看             
     `git config --list`来查看所有的配置。   
@@ -135,7 +135,6 @@ git push  // 把所有文件从本地仓库推送进远程仓库
     简单用法:    
     `git cherry-pick <commit id>`
 
-    
 - `git status`查看当前仓库的状态和信息，会提示哪些内容做了改变已经当前所在的分支。              
 
 - `git diff`                 
@@ -172,7 +171,7 @@ git push  // 把所有文件从本地仓库推送进远程仓库
     - `–after` ——显示某个日期之后发生的提交
     - `–before` ——显示发生某个日期之前的提交
 
-   
+
 - `git reflog`                
     可以查看所有操作记录包括`commit`和`reset`操作以及删除的`commit`记录
 
@@ -249,7 +248,7 @@ git push  // 把所有文件从本地仓库推送进远程仓库
     ```
     git reset   // git reset 只是把修改退回到了git add .之前的状态，也就是让文件还处于已修改未暂存的状态
     git checkout .   // 上面让文件处于已修改未暂存的状态，还要执行git checkout .来撤销工作区的状态
-    ```    
+    ```
     或`git reset --hard`
 
     上面两个例子中都使用了`git reset --hard`这个命令也可以完成，这个命令可以一步到位的把你的修改完全恢复到本地仓库的未修改的状态。     
@@ -473,5 +472,5 @@ $ git log --graph --pretty=oneline --abbrev-commit
 
 
 
-    
+​    
 
diff --git "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md" "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
index 0b4d80e4..d7e13d3a 100644
--- "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
+++ "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
@@ -523,7 +523,15 @@ int main(int argc, char *argv[]) {
 
 
 
+## Linux操作系统特点
 
+Linux是类Unix系统，借鉴了Unix的设计并实现相关接口，但并非Unix。Linux是由Linus Torvalds于1991年创造的开源免费系统，采用GNU GPL协议保护，下面列举Linux的一些主要特点：
+
+- Linux系统中万物皆为文件，这种抽象方便操作数据或设备，只需一套统一的系统接口open, read, write, close即可完成对文件的操作
+- Linux是单内核，支持动态加载内核模块，可在运行时根据需求动态加载和卸载部分内核代码；
+- Linux内核支持可抢占；
+- Linux内核创建进程，采用独特的fork()系统调用，创建进程较高效；
+- Linux内核并不区分进程和线程，对于内核而言，进程与线程无非是共享资源的区别，对CPU调度来说并没有显著差异。
 
 
 
diff --git "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md" "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
index 9801b918..7cf76645 100644
--- "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
+++ "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
@@ -529,8 +529,8 @@ Android使用的进程有些不同。活动管理器是Android负责正在运行
 
 2. 引导程序BootLoader：BootLoader是在Android系统开始运行前的一个小程序，主要用于把系统OS拉起来并运行。
 3. Linux内核启动：当内核启动时，设置缓存、被保护存储器、计划列表、加载驱动。当其完成系统设置时，会先在系统文件中寻找init.rc文件，并启动init进程。
-4. init进程启动：初始化和启动属性服务，init进程会孵化出eadbd、logd、等用户守护进程，还会启动ServiceManager(binder服务管家)、botanic(开机动画)等服务，并且启动Zygote进程。
-5. Zygote进程启动：zygote进程是Android系统的第一个Java进程（即虚拟机进程），它是所有Java进程的父进程。它会创建JVM并为其注册JNI方法，创建服务器端Socket，启动SystemServer进程。并且，zygote进程在启动的时候会创建DVM或者ART。因此通过从zygote进程fork创建的应用程序进程和systemserver进程都可以在内部获取一个DVM或者ART的实例副本。它还会提前加载类preloadClasses和提前加载资源preloadResouces。
+4. init进程启动(是所有用户进程的父进程(或者父父进程))：初始化和启动属性服务，init进程会孵化出eadbd、logd、等用户守护进程，还会启动ServiceManager(binder服务管家)、botanic(开机动画)等服务，并且启动Zygote进程。
+5. Zygote进程启动(zygote是所有上层Java进程的父进程，zygote的父进程是init进程)：zygote进程是Android系统的第一个Java进程（即虚拟机进程），它是所有Java进程的父进程。它会创建JVM并为其注册JNI方法，创建服务器端Socket，启动SystemServer进程。并且，zygote进程在启动的时候会创建DVM或者ART。因此通过从zygote进程fork创建的应用程序进程和systemserver进程都可以在内部获取一个DVM或者ART的实例副本。它还会提前加载类preloadClasses和提前加载资源preloadResouces。
 6. SystemServer进程启动：System Server是zygote孵化的第一个进程，它会启动Binder线程池和SystemServiceManager，并且启动各种系统服务，包括ActivityManagerService、WindowManagerService、PackageManagerService、PowerManagerService等服务。
 7. Media Server进程，是由init进程fork而来，负责启动和管理整个C++ framework，包括AudioFlinger，Camera Service等服务。
 8. Launcher启动：是zygote孵化的第一个App进程，被SystemServer进程启动的AmS会启动Launcher，Launcher启动后会将已安装应用的快捷图标显示到系统桌面上。zygote还会创建Broweer、Phone、Email等App进程，每个App至少运行在一个进程上。
diff --git "a/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md" "b/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md"
index dbcaf9bb..ba1a361e 100644
--- "a/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md"
+++ "b/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md"
@@ -19,6 +19,10 @@ Binder/Socket用于进程间通信，而Handler消息机制用于同进程的线
 - Looper：不断循环执行(Looper.loop)，按分发机制将消息分发给目标处理者。Looper有一个MessageQueue消息队列；
 
 
+
+![handle_msg_arch](https://raw.githubusercontent.com/CharonChui/Pictures/master/handle_msg_arch.png)
+
+
 首先想一想平时我们是怎么使用的: 
 ```java
 private Handler mHandler = new Handler(new Handler.Callback() {
@@ -866,7 +870,7 @@ public class SampleActivity extends Activity {
 			- `removeCallbacksAndMessages(Object token)` ——清除所有callback以及token匹配上的Message，如果token是null就会清楚所有callback和message。我们更多需要的是清除以该`Handler`为`target`的所有`Message(Callback)`就调用如下方法即可`handler.removeCallbacksAndMessages(null)`;
 			- `removeMessages(int what)` ——按what来匹配     
 			- `removeMessages(int what, Object object)` ——按what来匹配      
-			
+	
 - 将`Handler`声明为静态类。
     静态类不持有外部类的对象，所以你的`Activity`可以随意被回收。但是不持有`Activity`的引用，如何去操作`Activity`中的一些对象？ 这里要用到弱引用
 ```java
diff --git "a/OperatingSystem/AndroidKernal/6.\345\261\217\345\271\225\347\273\230\345\210\266\345\237\272\347\241\200.md" "b/OperatingSystem/AndroidKernal/6.\345\261\217\345\271\225\347\273\230\345\210\266\345\237\272\347\241\200.md"
index 620d6f10..e24311b8 100644
--- "a/OperatingSystem/AndroidKernal/6.\345\261\217\345\271\225\347\273\230\345\210\266\345\237\272\347\241\200.md"
+++ "b/OperatingSystem/AndroidKernal/6.\345\261\217\345\271\225\347\273\230\345\210\266\345\237\272\347\241\200.md"
@@ -66,11 +66,25 @@ Framebuffer是系内核系统提供的图形硬件的抽象描述。之所以称
 
 
 
+无论开发者使用什么渲染 API，一切内容都会渲染到“Surface”。Surface 表示缓冲队列中的生产方，而缓冲队列通常会被 SurfaceFlinger 消耗。在 Android 平台上创建的每个窗口都由 Surface 提供支持。所有被渲染的可见 Surface 都被 SurfaceFlinger 合成到显示部分。
 
 
 
+### 图像流生产方
 
+图像流生产方可以是生成图形缓冲区以供消耗的任何内容。例如 OpenGL ES、Canvas 2D 和 mediaserver 视频解码器。
 
+### 图像流消耗方
+
+图像流的最常见消耗方是 SurfaceFlinger，该系统服务会消耗当前可见的 Surface，并使用窗口管理器中提供的信息将它们合成到显示部分。SurfaceFlinger 是可以修改所显示部分内容的唯一服务。SurfaceFlinger 使用 OpenGL 和 Hardware Composer 来合成一组 Surface。
+
+其他 OpenGL ES 应用也可以消耗图像流，例如相机应用会消耗相机预览图像流。非 GL 应用也可以是使用方，例如 ImageReader 类。
+
+### 硬件混合渲染器
+
+显示子系统的硬件抽象实现。SurfaceFlinger 可以将某些合成工作委托给 Hardware Composer，以分担 OpenGL 和 GPU 上的工作量。SurfaceFlinger 只是充当另一个 OpenGL ES 客户端。因此，在 SurfaceFlinger 将一个或两个缓冲区合成到第三个缓冲区中的过程中，它会使用 OpenGL ES。这样使合成的功耗比通过 GPU 执行所有计算更低。
+
+[Hardware Composer HAL](https://source.android.com/devices/graphics/architecture#hwcomposer) 则进行另一半的工作，并且是所有 Android 图形渲染的核心。Hardware Composer 必须支持事件，其中之一是 VSYNC（另一个是支持即插即用 HDMI 的热插拔）。
 
 
 

From 77f48f87b66aac56e896ace05a8ff479e54655d8 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Fri, 2 Apr 2021 22:03:37 +0800
Subject: [PATCH 049/213] update kotlin note

---
 ...&\347\261\273&\346\216\245\345\217\243.md" | 1050 +++++++++++++++++
 ...76\350\256\241\346\250\241\345\274\217.md" |  458 +++++++
 ...05\350\201\224\345\207\275\346\225\260.md" |  742 ++++++++++++
 ...0\347\273\204&\351\233\206\345\220\210.md" |  554 +++++++++
 ...7&\345\205\263\351\224\256\345\255\227.md" |  224 ++++
 ...2\344\270\276&\345\247\224\346\211\230.md" |  216 +++-
 ...47\346\211\277\351\227\256\351\242\230.md" |  211 ++++
 ...5\345\260\204&\346\211\251\345\261\225.md" |  859 ++++++++++++++
 .../8.Kotlin_\345\215\217\347\250\213.md"     |   97 ++
 ...\346\225\231\347\250\213(\344\270\200).md" |  534 ---------
 ...\346\225\231\347\250\213(\344\270\203).md" |   96 --
 ...\346\225\231\347\250\213(\344\270\211).md" |  196 ---
 ...\346\225\231\347\250\213(\344\271\235).md" |    8 +
 ...\346\225\231\347\250\213(\344\272\214).md" |   88 --
 ...\346\225\231\347\250\213(\345\205\253).md" |  121 +-
 ...\346\225\231\347\250\213(\345\205\255).md" |  204 ----
 ...\346\225\231\347\250\213(\345\215\201).md" |   35 +-
 ...\346\225\231\347\250\213(\345\233\233).md" |  581 ---------
 18 files changed, 4421 insertions(+), 1853 deletions(-)
 create mode 100644 "KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
 create mode 100644 "KotlinCourse/11.Kotlin_\350\256\276\350\256\241\346\250\241\345\274\217.md"
 create mode 100644 "KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
 create mode 100644 "KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md"
 create mode 100644 "KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md"
 rename "KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\344\272\224).md" => "KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md" (62%)
 create mode 100644 "KotlinCourse/6.Kotlin_\345\244\232\347\273\247\346\211\277\351\227\256\351\242\230.md"
 create mode 100644 "KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md"
 create mode 100644 "KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
 delete mode 100644 "KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\344\270\200).md"
 delete mode 100644 "KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\344\270\203).md"
 delete mode 100644 "KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\344\270\211).md"
 delete mode 100644 "KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\344\272\214).md"
 delete mode 100644 "KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\345\205\255).md"
 delete mode 100644 "KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\345\233\233).md"

diff --git "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md" "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
new file mode 100644
index 00000000..b4432c22
--- /dev/null
+++ "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
@@ -0,0 +1,1050 @@
+1.Kotlin_简介
+===
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_kotlin.jpeg?raw=true)
+
+在`5月18`日谷歌在`I/O`开发者大会上宣布，将`Kotlin`语言作为安卓开发的一级编程语言。并且会在`Android Studio 3.0`版本全面支持`Kotlin`。   
+
+- `Kotlin`是一个基于`JVM`的新的编程语言，由[JetBrains](https://www.jetbrains.com/)开发。`JetBrains`作为目前广受欢迎的
+`Java IDE IntelliJ`的提供商，在`Apache`许可下已经开源其`Kotlin`编程语言。     
+- `Kotlin`可以编译成`Java`字节码，也可以编译成`JavaScript`，方便在没有`JVM`的设备上运行。      
+- `Kotlin`已正式成为`Android`官方开发语言。
+
+[Kotlin官网](https://kotlinlang.org/)
+
+`JetBrains`这家公司非常牛逼，开发了很多著名的软件，他们在使用`Java`的过程中发现`java`比较笨重不方便，所以就开发了`kotlin`，`kotlin`是
+一种全栈的开发语言，可以用它进行开发`web`、`web`后端、`Android`等。    
+
+很多开发者都说`Google`学什么不好，非要学苹果，出个`android`的`swift`版本，一定会搞不起来没人用，所以不用浪费时间去学习。在这里想引用马云
+的一句话: 
+> 拥抱变化
+
+`Google`做事，向来言出必行，之前在推行`Android Studio`时也是一片骂声，吐槽各种不好用，各种慢。但是现在`Android Studio`基本都已经普及了。
+我相信`Kotlin`也不会例外。所以我们不仅要学，还要要认真的学。    
+
+## `Kotlin`的特性
+
+- 它更加易表现：这是它最重要的优点之一。你可以编写少得多的代码。
+- `Kotlin`是一种兼容`Java`的语言
+- `Kotlin`比`Java`更安全，能够静态检测常见的陷阱。如:引用空指针
+- `Kotlin`比`Java`更简洁，通过支持`variable type inference，higher-order functions (closures)，extension functions，mixins 
+and first-class delegation`等实现
+- `Kotlin`可与`Java`语言无缝通信。这意味着我们可以在`Kotlin`代码中使用任何已有的`Java`库；同样的`Kotlin`代码还可以为`Java`代码所用
+- `Kotlin`在代码中很少需要在代码中指定类型，因为编译器可以在绝大多数情况下推断出变量或是函数返回值的类型。这样就能获得两个好处:简洁与安全
+
+## `Kotlin`优势
+
+- 全面支持`Lambda`表达式
+- 数据类`Data classes`
+- 函数字面量和内联函数`Function literals & inline functions`
+- 函数扩展`Extension functions`
+- 空安全`Null safety`
+- 智能转换`Smart casts`
+- 字符串模板`String templates`
+- 主构造函数`Primary constructors`
+- 类委托`Class delegation`
+- 类型推判`Type inference`
+- 单例`Singletons`
+- 声明点变量`Declaration-site variance`
+- 区间表达式`Range expressions`
+
+
+上面说简洁简洁，到底简洁在哪里？这里先用一个例子开始，在`Java`开发过程中经常会写一些`Bean`类:  
+```java
+package com.charon.kotlinstudydemo;
+
+public class Person {
+    private int age;
+    private String name;
+    private float height;
+    private float weight;
+
+    public int getAge() {
+        return age;
+    }
+
+    public void setAge(int age) {
+        this.age = age;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public float getHeight() {
+        return height;
+    }
+
+    public void setHeight(float height) {
+        this.height = height;
+    }
+
+    public float getWeight() {
+        return weight;
+    }
+
+    public void setWeight(float weight) {
+        this.weight = weight;
+    }
+
+    @Override
+    public String toString() {
+        return "Person name is : " + name + " age is : " + age + " height is :"
+                + height + " weight is :" + weight;
+    }
+}
+```
+使用`Kotlin`:  
+```kotlin
+package com.charon.kotlinstudydemo
+
+data class Person(
+        var name: String,
+        var age: Int,
+        var height: Float,
+        var weight: Float)
+```
+这个数据类，它会自动生成所有属性和它们的访问器，以及一些有用的方法，比如`toString()`方法。   
+这里插一嘴，从上面的例子中我们可以看到对于包的声明基本是一样的，唯一不同的是`kotlin`中后面结束不用分号。 
+
+## 创建`Kotlin`项目
+
+`Google`宣布在`Android Studio 3.0`版本会全面支持`Kotlin`，目前早就有预览版了
+[Android Studio Preview](https://developer.android.com/studio/preview/index.html)(个人感觉很好用，比2.3.3版本强多了)。
+直接通过`New Project`创建就可以，与创建普通`Java`项目唯一不同的是要勾选`Include Kotlin support`的选项。   
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/studio_create_kotlin.png?raw=true)
+
+创建完成后我们看一下`MainActivity`的代码:    
+```kotlin
+// 定义包
+package com.charon.kotlinstudydemo
+
+// 导入
+import android.support.v7.app.AppCompatActivity
+import android.os.Bundle
+
+// 定义类，继承AppCompatActivity
+class MainActivity : AppCompatActivity() {
+	
+	// 重写方法用overide，函数名用fun声明  参数是a: 类型的形式 ?是啥？它是指明该对象可能为null，
+	// 如果有了?那在调用该方法的时候参数可以传递null进入，如果没有?传递null就会报错
+    override fun onCreate(savedInstanceState: Bundle?) {
+    	// super 
+        super.onCreate(savedInstanceState)
+        // 调用方法
+        setContentView(R.layout.activity_main)
+    }
+}
+```
+
+我们就从`MainActivity`的代码开始介绍一些基本的语法。   
+
+## 变量
+
+变量可以很简单地定义成可变`var`(可读可写)和不可变`val`(只读)的变量。如果var代表了varible(变量)，那么val可看成value(值)的缩写，但是也有人觉得这样并不直观或准确，而是把val解释成varible+final，即通过val声明的变量具有Java中的final关键字的效果(我们通过查看对val语法反编译后转化的java代码，从中可以很清楚的发现它是用final实现的。)，也就是引用不可变。因此，val声明的变量是只读变量，它的引用不可更改，但并不代表其引用对象也不可变。事实上，我们依然可以修改引用对象的可变成员。
+
+声明:  
+```kotlin
+var age: Int = 18
+val name: String = "charon"
+
+val book = Book("Thinking in Java") // 用val声明的book对象的引用不可变
+book.name = "Diving into Kotlin"
+book.printName() // Diving into Kotlin
+```
+
+再提示一下:`kotlin`中每行代码结束不需要分号了，不要和`java`是的每行都带分号
+
+字面上可以写明具体的类型。这个不是必须的，但是一个通用的`Kotlin`实践时省略变量的类型我们可以让编译器自己去推断出具体的类型:   
+```kotlin
+var age = 18 // int
+val name = "charon" // string
+var height = 180.5f // flat
+var weight = 70.5 // double
+```
+
+在`Kotlin`中，一切都是对象。没有像`Java`中那样的原始基本类型。
+当然，像`Integer`，`Float`或者`Boolean`等类型仍然存在，但是它们全部都会作为对象存在的。基本类型的名字和它们工作方式都是与`Java`非常相似
+的，但是有一些不同之处你可能需要考虑到:    
+
+- 数字类型中不会自动转型。举个例子，你不能给`Double`变量分配一个`Int`。必须要做一个明确的类型转换，可以使用众多的函数之一:   
+	```kotlin
+	private var age = 18
+	private var weight = age.toFloat()
+	```
+- 字符（`Char`）不能直接作为一个数字来处理。在需要时我们需要把他们转换为一个数字:       
+	```kotlin
+	val c: Char='c'
+	val i: Int = c.toInt()
+	```
+- 位运算也有一点不同。在`Android`中，我们经常在`flags`中使用`或`:      
+	```java
+	// Java
+	int bitwiseOr = FLAG1 | FLAG2;
+	int bitwiseAnd = FLAG1 & FLAG2;
+	```
+
+	```kotlin
+	// Kotlin
+	val bitwiseOr = FLAG1 or FLAG2
+	val bitwiseAnd = FLAG1 and FLAG2
+	```
+
+- 一个`String`可以像数组那样访问，并且被迭代:     
+	```kotlin
+	var s = "charon"
+	var c = s[2]
+
+	for (a in s) {
+	    Log.e("@@@", a +"");
+	}
+	```
+
+### 优先使用val来避免副作用
+
+在很多Kotlin的学习资料中，都会传递一个原则：优先使用val来声明变量。这相当正确，但更好的理解可以是：尽可能采用val、不可变对象及纯函数来设计程序。关于纯函数的概念，其实就是没有副作用的函数，具备引用透明性。
+
+简单来说，副作用就是修改了某处的某些东西，比如说：
+
+- 修改了外部变量的值
+- IO操作，如写数据到磁盘
+- UI操作，如修改了一个按钮的可操作状态
+
+来看一个实际的例子：先用va来声明一个变量a，然后在count函数内部对其进行自增操作：
+
+```kotlin
+val a = 1
+fun count(x: Int) {
+    a = a + 1
+    println(x + a)
+}
+```
+
+如果执行两次count(1)函数，第一次的执行结果是3、第二次的执行结果是4。这显然是受到了外部变量a的影响，这个就是典型的副作用。
+
+
+
+## 编译期常量
+
+已知值的属性可以使用`const`修饰符标记为编译期常量(类似`java`中的`public static final`)。
+`const`只能修复`val`不能修复`var`,这些属性需要满足以下要求:      
+- 位于顶层或者是`object`的一个成员
+- 用`String`或原生类型值初始化
+- 没有自定义`getter`
+
+```kotlin
+// Const val are only allowed on top level or in objects
+const val NAME: String = "charon"
+
+class MainActivity : AppCompatActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_main)
+    }
+}
+```
+
+## 后端变量`Backing Fields`.
+
+在`kotlin`的`getter`和`setter`是不允许本身的局部变量的，因为属性的调用也是对`get`的调用，因此会产生递归，造成内存溢出。
+
+例如:    
+
+```kotlin
+var count = 1
+var size: Int = 2
+set(value) {
+    Log.e("text", "count : ${count++}")
+    size = if (value > 10) 15 else 0
+}
+```
+这个例子中就会内存溢出。   
+
+`kotlin`为此提供了一种我们要说的后端变量，也就是`field`。编译器会检查函数体，如果使用到了它，就会生成一个后端变量，否则就不会生成。
+我们在使用的时候，用`field`代替属性本身进行操作。
+
+## 延迟初始化
+
+我们说过，在类内声明的属性必须初始化，如果设置非`null`的属性，应该将此属性在构造器内进行初始化。
+假如想在类内声明一个`null`属性，在需要时再进行初始化（最典型的就是懒汉式单例模式），与`Kotlin`的规则是相背的，此时我们可以声明一个属性并
+延迟其初始化，此属性用`lateinit`修饰符修饰。
+
+```kotlin
+class MainActivity : AppCompatActivity() {
+    lateinit var name : String
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_main)
+        var test = MainActivity()
+        // 要先调用方法让其初始化
+        test.init()
+        // 再使用其属性
+        Log.e("@@@", test.name)
+    }
+
+    fun init() {
+        // 延迟初始化
+        name = "charon"
+    }
+}
+```
+需要注意的是，我们在使用的时候，一定要确保属性是被初始化过的，通常先调用初始化方法，否则会有异常。
+如果只是用`lateinit`声明了，但是还没有调用初始化方法就使用，哪怕你判断了该变量是否为`null`也是会`crash`的。
+```kotlin
+private lateinit var test: String
+
+private fun switchFragment(position: Int) {
+    if (test == null) {
+        LogUtil.e("@@@", "test is null")
+    } else {
+        LogUtil.e("@@@", "test is not null")
+        check(test)
+    }
+}
+```
+会报`kotlin.UninitializedPropertyAccessException: lateinit property test has not been initialized`
+
+除了使用`lateinit`外还可以使用`by lazy {}`效果是一样的：   
+```kotlin
+private val test by lazy { "haha" }
+
+private fun switchFragment(position: Int) {
+    if (test == null) {
+        LogUtil.e("@@@", "test is null")
+    } else {
+        LogUtil.e("@@@", "test is not null ${test}")
+        check(test)
+    }
+}    
+```
+执行结果:   
+```
+test is not null haha
+```
+
+那`lateinit`和`by lazy`有什么区别呢？    
+
+- `by lazy{}`只能用在`val`类型而`lateinit`只能用在`var`类型
+- `lateinit`不能用在可空的属性上和`java`的基本类型上,否则会报`lateinit`错误   
+
+lazy的背后是接受一个lambda并返回一个Lazy<T>实例的函数，第一次访问该属性时，会执行lazy对应的Lambda表达式并记录结果，后续访问该属性时只是返回记录的结果。
+
+另外系统会给lazy属性默认加上同步锁，也就是LazyThreadSafetyMode.SYNCHRONIZED，它在同一时刻只允许一个线程对lazy属性进行初始化，所以它是线程安全的。但若你能确认该属性可以并行执行，没有线程安全问题，那么可以给lazy传递LazyThreadSafetyMode.PUBLICATION参数。你还可以给lazy传递LazyThreadSafetyMode.NONE参数，这将不会有任何线程方面的开销，当然也不会有任何线程安全的保证。例如:  
+
+```kotlin
+val sex: String by lazy(LazyThreadSafetyMode.PUBLICATION) {
+    // 并行模式
+    if (color == "yellow") "male" else "female"
+}
+
+val sex: String by lazy(LazyThreadSafetyMode.NONE) {
+    // 不做任何线程保证也不会有任何线程开销
+    if (color == "yellow") "male" else "female"
+}
+```
+
+
+
+## 类的定义:使用`class`关键字
+
+类可以包含:  
+- 构造函数和初始化块
+- 函数
+- 属性
+- 嵌套类和内部类
+- 对象声明
+
+
+```kotlin
+class MainActivity{
+
+}
+```
+
+如果有参数的话你只需要在类名后面写上它的参数，如果这个类没有任何内容可以省略大括号：
+```kotlin
+class Person(name: String, age: Int)
+```
+
+### 创建类的实例
+
+```kotlin
+val person = Person("charon", 18)
+```
+
+上面的类有一个默认的构造函数。
+
+注意:创建类的实例不用`new`了啊。
+
+### 构造函数
+
+在`Kotlin`中的一个类可以有一个主构造函数和一个或多个次构造函数。
+
+#### 主构造函数
+
+主构造函数是类头的一部分:它跟在类名（和可选的类型参数）后:   
+```kotlin
+class Person constructor(name: String, surname: String) {
+}
+```
+如果主构造函数没有任何注解或者可见性修饰符，可以省略`constructor`关键字:   
+```kotlin
+class Person(name: String, surname: String) {
+}
+```
+
+主构造函数不能包含任何的代码。初始化的代码可以放到以`init`关键字作为前缀的初始化块中:    
+
+```kotlin
+class Person constructor(name: String, surname: String) {
+    init {
+        print("name is $name and surname is $surname")
+    }
+}
+```
+
+如果构造函数有注解或可见性修饰符，那么`constructor`关键字是必需的，并且这些修饰符在它前面:   
+```kotlin
+class Person private @Inject constructor(name: String, surname: String) {
+    init {
+        print("name is $name and surname is $surname")
+    }
+}
+```
+
+#### 次构造函数
+
+类也可以声明前缀有`constructor`的次构造函数: 
+```kotlin
+class Person{
+    constructor(name: String) {
+        print("name is $name")
+    }
+}
+```
+
+如果类有一个主构造函数，每个次构造函数都需要委托给主构造函数(不然会报错)， 可以直接委托或者通过别的次构造函数间接委托。
+委托到同一个类的另一个构造函数用`this`关键字即可:    
+```kotlin
+class Person constructor(name: String) {
+    constructor(name: String, surName: String) : this(name) {
+        Log.d("@@@", "name is : $name surName is : $surName")
+    }
+}
+```
+使用该对象:   
+```kotlin
+class MainActivity : AppCompatActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_main)
+        Person("charon", "chui")
+    }
+}
+```
+就会在`logcat`上打印:   
+`09-20 16:51:19.738 6010-6010/com.charon.kotlinstudydemo D/@@@: name is : charon surName is : chui`
+
+如果一个非抽象类没有声明任何（主或次）构造函数，它会有一个生成的不带参数的主构造函数。构造函数的可见性是`public`。
+如果你不希望你的类有一个公有构造函数，你需要声明一个带有非默认可见性的空的主构造函数：
+
+```kotlin
+class Person private constructor(name: String) {
+}
+```
+
+#### 构造方法默认参数
+
+```kotlin
+class Bird(val weight: Double = 0.00, val age: Int = 0, val color: String = "blue")
+
+val bird1 = Bird(color = "black")
+val bird2 = Bird(weight = 1000.00, color = "black")
+```
+
+上面在Bird类中使用了val或者var来声明构造方法的参数。这一方面代表了参数的引用可变性，另一方面也使得我们再构造类的语法上得到了简化。事实上，构造方法的参数名前当然可以没有val和var。然而带上它们之后就等价于在Bird类内部声明了一个同名的属性，我们可以用this来进行调用。比如，上面定义的Bird类就类似于一下实现:  
+
+```kotlin
+// 构造方法参数名前没有val
+class Bird (weight: Double = 0.00, age: Int = 0, color: String = "blue"){
+    val weight: Double
+    val age: Int
+    val color: String
+    init {
+        this.weight = weight // 构造方法参数可以在init语句中被调用
+        this.age = age
+        this.color = color
+    }
+}
+```
+
+#### init语句块
+
+Kotlin引入了一种叫作init语句块的语法，它属于上述构造方法的一部分，两者在表现形式上确实分离的。Bird类的构造方法在类的外部，它只能对参数进行赋值。如果我们需要在初始化时进行其他的额外操作，那么我们就可以使用init语句块来执行。比如:  
+
+```kotlin
+class Bird(weight: Double, aget: Int, color: String) {
+    init {
+        println("the weight is ${weight}")
+    }
+}
+```
+
+当没有val或者var的时候，构造函数的参数可以在init语句块被直接调用。除此之外，不能在其他地方使用。以下是一个错误的用法:  
+
+```kotlin
+class Bird(weight: Double, age: Int, color: String) {
+    fun printWeight() {
+        print(weight) // Unresolved reference: weight
+    }
+}
+```
+
+事实上，我们的构造方法还可以拥有多个init，他们会在对象被创建时按照类中从上到下的顺序先后执行。例如:  
+
+```kotlin
+class Bird(weight: Double, aget: Int, color: String) {
+    val weight: Double
+    val age: Int
+    val color: String
+}
+
+init {
+    this.weight = weight
+    this.age = age
+}
+init {
+    this.color = color
+}
+
+```
+
+可以发现，多个init语句块有利于进一步对初始化的操作进行职能分离，这在复杂的业务开发中显得特别有用。
+
+
+
+## 数据类:使用`data class`定义
+
+数据类是一种非常强大的类:   
+
+```java
+public class Artist {
+    private long id;
+    private String name;
+    private String url;
+    private String mbid;
+
+    public long getId() {
+        return id;
+    }
+
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getUrl() {
+        return url;
+    }
+
+    public void setUrl(String url) {
+        this.url = url;
+    }
+
+    public String getMbid() {
+        return mbid;
+    }
+
+    public void setMbid(String mbid) {
+        this.mbid = mbid;
+    }
+
+    @Override public String toString() {
+        return "Artist{" +
+          "id=" + id +
+          ", name='" + name + '\'' +
+          ", url='" + url + '\'' +
+          ", mbid='" + mbid + '\'' +
+          '}';
+    }
+}
+```
+
+使用`Kotlin`:  
+
+```kotlin
+data class Artist(
+    var id: Long,
+    var name: String,
+    var url: String,
+    var mbid: String)
+```
+
+通过数据类，会自动提供以下函数：
+
+- 所有属性的`get() set()`方法
+- `equals()`
+- `hashCode()`
+- `copy()`
+- `toString()`
+- 一系列可以映射对象到变量中的函数(后面再说)。
+
+如果我们使用不可修改的对象，就像我们之前讲过的，假如我们需要修改这个对象状态，必须要创建一个新的一个或者多个属性被修改的实例。
+这个任务是非常重复且不简洁的。
+
+举个例子,如果要修改`Person`类中`charon`的`age`: 
+
+```kotlin
+data class Person(val name: String,
+                  val age: Int)
+```
+
+```kotlin
+val charon = Person("charon", 18)
+val charon2 = charon.copy(age = 19)
+```
+
+如上，我们拷贝了`charon`对象然后只修改了`age`的属性而没有修改这个对象的其它状态。
+
+如果你要在Kotlin声明一个数据类，必须满足以下几点条件：  
+
+- 数据类必须拥有一个构造方法，该方法至少包含一个参数，一个没有数据的数据类是没有任何用处的。
+- 与普通的类不同，数据类构造方法的参数强制使用var或者val进行声明
+- data class之前不能用abstract、open、sealed或者inner进行修饰
+- 在Kotlin 1.1版本前数据类只允许实现接口，之后的版本既可以实现接口也可以继承类
+
+
+
+
+
+## 多声明
+
+多声明，也可以理解为变量映射，这就是编译器自动生成的`componentN()`方法。
+
+```kotlin
+var personD = PersonData("PersonData", 20, "male")
+var (name, age) = personD
+
+
+Log.d("test", "name = $name, age = $age")
+
+//输出
+name = PersonData, age = 20
+```
+
+上面的多声明，大概可以翻译成这样：
+
+```kotlin
+var name = f1.component1()
+var age = f1.component2()
+```
+
+## 继承
+
+在`Kotlin`中所有类都有一个共同的超类`Any`，这对于没有超类型声明的类是默认超类:   
+
+```kotlin
+class Person // 从 Any 隐式继承
+```
+
+`Any`不是`java.lang.Object`。它除了`equals()`、`hashCode()`和`toString()`外没有任何成员。
+`Kotlin`中所有的类默认都是不可继承的(`final`)，为什么要这样设计呢？引用`Effective Java`书中的第17条:要么为继承而设计，并提供文档说明，
+要么就禁止继承。所以我们只能继承那些明确声明`open`或者`abstract`的类:要声明一个显式的超类型，我们把类型放到类头的冒号之后:   
+
+```kotlin
+open class Person(num: Int)
+// 继承
+class SuperPerson(num: Int) : Person(num)
+```
+
+如果该类有一个主构造函数，其基类必须用基类型的主构造函数参数就地初始化。
+如果类没有主构造函数，那么每个次构造函数必须使用`super`关键字初始化其基类型，或委托给另一个构造函数做到这一点。
+注意，在这种情况下，不同的次构造函数可以调用基类型的不同的构造函数:   
+
+```kotlin
+class MyView : View {
+    constructor(ctx: Context) : super(ctx)
+    constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
+}
+```
+
+在Java中，类默认是可以被继承的，除非你主动加final修饰符。而在Kotlin中恰好相反，默认是不可被继承的，除非你主动加可以继承的修饰符，那便是open，如果不加open，那它在转化为Java代码时就是final的:   
+
+```kotlin
+class Bird {
+    val weight: Double = 500.0
+    val color: String = "blue"
+    val age: Int = 1
+    fun fly() {}
+}
+```
+
+将Bird类编译后转换为Java的代码:  
+
+```java
+public final class Bird {
+    private final double weight = 500.0;
+    private final String color = "blue";
+    private final int age = 1;
+    public final double getWeight() {
+        return this.weight;
+    }
+    public final String getColor() {
+        return this.color;
+    }
+    public final int getAge() {
+        return this.age;
+    }
+    public final void fly() {
+        
+    }
+}
+```
+
+
+
+## 覆盖
+
+##### 方法覆盖
+
+
+只能重写显示标注可覆盖的方法:   
+
+```kotlin
+open class Person(num: Int) {
+    open fun changeName(name: String) {
+
+    }
+
+    fun changeAge(age: Int) {
+
+    }
+}
+
+class SuperPerson(num: Int) : Person(num) {
+    override fun changeName(name: String) {
+        // 通过super关键字调用超类实现
+        super.changeName(name)
+    }
+}
+```
+
+`SuperPerson.changeName()`方法前面必须加上`override`标注，不然编译器将会报错。如果像上面`Person.changeAge()`方法没有标注`open`,
+则子类中不能定义相同的方法:   
+
+```kotlin
+class SuperPerson(num: Int) : Person(num) {
+    override fun changeName(name: String) {
+        super.changeName(name)
+    }
+
+    // 编译器报错
+    fun changeAge(age: Int) {
+
+    }
+    // 重载是可以的
+    fun changeAge(name: String) {
+
+    }
+    // 重载是可以的
+    fun changeAge(age: Int, name: String) {
+
+    }
+}
+```
+
+标记为`override`的成员本身是开放的，也就是说，它可以在子类中覆盖。如果你想禁止再次覆盖，可以使用`final`关键字:    
+
+```kotlin
+open class SuperPerson(num: Int) : Person(num) {
+    final override fun changeName(name: String) {
+        super.changeName(name)
+    }
+}
+```
+
+##### 属性覆盖
+
+属性覆盖与方法覆盖类似，只能覆盖显示标明`open`的属性，并且要用`override`开头:  
+
+```kotlin
+open class Person(num: Int) {
+    open val name: String = ""
+
+    open fun changeName(name: String) {
+
+    }
+
+    fun changeAge(age: Int) {
+
+    }
+}
+
+open class SuperPerson(num: Int) : Person(num) {
+    override val name: String
+        get() = super.name
+
+    final override fun changeName(name: String) {
+        super.changeName(name)
+    }
+
+}
+```
+
+每个声明的属性可以由具有初始化器的属性或者具有`get`方法的属性覆盖，你也可以用一个`var`属性覆盖一个`val`属性，但反之则不行。
+
+
+
+## 抽象类
+
+类和其中的某些成员可以声明为`abstract`。抽象成员在本类中可以不用实现。 需要注意的是，我们并不需要用`open`标注一个抽象类或者函数——因为这不
+言而喻。
+
+我们可以用一个抽象成员覆盖一个非抽象的开放成员:  
+
+```kotlin
+open class Base {
+    open fun f() {}
+}
+
+abstract class Derived : Base() {
+    override abstract fun f()
+}
+```
+
+
+
+## 注释
+
+和`Java`差不多
+
+```kotlin
+// 这是一个行注释
+
+/* 这是一个多行的
+   块注释。 */
+```
+
+
+
+
+
+
+## 接口:使用`interface`关键字
+
+```kotlin
+interface FlyingAnimal {
+    fun fly()
+}
+```
+
+虽然Kotlin接口支持属性声明，然而它在Java源码中是通过一个get方法来实现的。在接口的属性并不能像Java接口那样，被直接赋值一个常量。如以下这样是错误的: 
+
+```kotlin
+interface Flyer {
+    val height = 1000 // error Property initializers are not allowed in interfaces
+    val speed: Int
+    // 可以支持默认实现方法，反编译可以看到是通过静态内部类来提供fly方法的默认实现的
+    fun fly() {
+        println("I can fly")
+    }
+}
+```
+
+Kotlin提供了另外一种方式来实现这种效果:  
+
+```kotlin
+interface Flyer {
+    val height 
+        get() = 1000
+}
+```
+
+
+
+## 函数:通过`fun`关键字定义
+
+```kotlin
+fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    setContentView(R.layout.activity_main)
+}
+```
+如果你没有指定它的返回值，它就会返回`Unit`与`Java`中的`void`类似，但是`Unit`是一个类型，而void只是一个关键字。`Unit`可以省略。
+你当然也可以指定任何其它的返回类型:      
+
+```kotlin
+fun maxOf(a: Int, b: Int): Int {
+    if (a > b) {
+        return a
+    } else {
+        return b
+    }
+}
+```
+
+### 表达式函数体
+
+然而如果返回的结果可以使用一个表达式计算出来，你可以不使用括号而是使用等号:         
+
+```kotlin
+fun add(x: Int,y: Int) : Int = x + y // 省略了{}
+```
+
+Kotlin支持这种单行表达式与等号的语法来定义函数，叫做表达式函数体，作为区分，普通的函数声明则可以叫做代码块函数体。如你所见，在使用表达式函数体的情况下我们可以不声明返回值类型，这进一步简化了语法。
+
+
+
+我们可以给参数指定一个默认值使得它们变得可选，这是非常有帮助的。这里有一个例子，在`Activity`中创建了一个函数用来`Toast`一段信息:    
+
+```kotlin
+fun toast(message: String, length: Int = Toast.LENGTH_SHORT) {
+    Toast.makeText(this, message, length).show()
+}
+```
+上面代码中第二个参数`length`指定了一个默认值。这意味着你调用的时候可以传入第二个值或者不传，这样可以避免你需要的重载函数：
+
+```kotlin
+toast("Hello")
+toast("Hello", Toast.LENGTH_LONG)
+```
+
+### 自定义`get set`方法:
+
+`Kotlin`会默认创建`set get`方法，我们也可以自定义`get set`方法:
+`kotlin`预留了一个在`set`和`get`中访问的变量`field`关键字:  
+
+```kotlin
+class Person constructor() {
+    var name: String = ""
+        get() = field
+        set(value) {
+            field = "$value"
+        }
+
+    var age: Int = 0
+        get() = field
+        set(value) {
+            field = value
+        }
+}
+```
+按照惯例`set`参数的名称是`value`，但是如果你喜欢你可以选择一个不同的名称。
+
+### 可变长参数函数:使用`vararg`关键字
+
+```kotlin
+fun vars(vararg v:Int){
+    for(vt in v){
+        print(vt)
+    }
+}
+
+// 测试
+fun main(args: Array<String>) {
+    vars(1,2,3,4,5)  // 输出12345
+}
+```
+
+### 命名风格
+
+如果拿不准的时候，默认使用`Java`的编码规范，比如:   
+
+- 使用驼峰法命名（并避免命名含有下划线）
+- 类型名以大写字母开头
+- 方法和属性以小写字母开头
+- 使用4个空格缩进
+- 公有函数应撰写函数文档，这样这些文档才会出现在`Kotlin Doc`中
+
+
+### 冒号
+
+类型和超类型之间的冒号前要有一个空格，而实例和类型之间的冒号前不要有空格:     
+
+```kotlin
+interface Foo<out T : Any> : Bar {
+    fun foo(a: Int): T
+}
+```
+
+### 类头格式化
+
+有少数几个参数的类可以写成一行：
+
+```kotlin
+class Person(id: Int, name: String)
+```
+
+具有较长类头的类应该格式化，以使每个主构造函数参数位于带有缩进的单独一行中。 此外，右括号应该另起一行。如果我们使用继承，
+那么超类构造函数调用或者实现接口列表应位于与括号相同的行上：
+
+```kotlin
+class Person(
+    id: Int, 
+    name: String,
+    surname: String
+) : Human(id, name) {
+    // ……
+}
+```
+
+对于多个接口，应首先放置超类构造函数调用，然后每个接口应位于不同的行中：
+
+```kotlin
+class Person(
+    id: Int, 
+    name: String,
+    surname: String
+) : Human(id, name),
+    KotlinMaker {
+    // ……
+}
+```
+
+### `Unit`:让函数调用皆为表达式
+
+如果函数返回`Unit`类型，该返回类型应该省略:   
+
+```kotlin
+fun foo() { // 省略了 ": Unit"
+
+}
+```
+
+之所以不能说Java中的函数调用皆是表达式，是因为存在特例void。众所周知，在Java中如果声明的函数没有返回值，那么它就需要用void来修饰，如： 
+
+```java
+void foo() {
+    System.out.println("return nothing")
+}
+```
+
+所以foo()就不具有值和类型信息，它就不能算作一个表达式。在Kotlin中，函数在所有的情况下都具有返回类型，所以他们引入了Unit来替代Java中的void关键字。
+
+Unit与Int一样，都是一种类型，然而它不代表任何信息，用面向对象的术语来描述就是一个单例，它的实例只有一个，可写为()。
+
+
+
+[下一篇:Kotlin学习教程(二)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%BA%8C).md)
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
diff --git "a/KotlinCourse/11.Kotlin_\350\256\276\350\256\241\346\250\241\345\274\217.md" "b/KotlinCourse/11.Kotlin_\350\256\276\350\256\241\346\250\241\345\274\217.md"
new file mode 100644
index 00000000..5a3a5989
--- /dev/null
+++ "b/KotlinCourse/11.Kotlin_\350\256\276\350\256\241\346\250\241\345\274\217.md"
@@ -0,0 +1,458 @@
+11.Kotlin_设计模式
+===
+
+
+
+## 工厂模式
+
+简单工厂的模式，它的核心作用是通过一个工厂类隐藏对象实例的创建逻辑，而不需要暴露给客户端。典型的使用场景就是当拥有一个父类与多个子类的时候，我们可以通过这种模式来创建子类对象。
+
+假设现在有一个电脑加工厂，同时生产个人电脑和服务器主机。我们用熟悉的工厂模式设计描述其业务逻辑:  
+
+```kotlin
+interface Computer {
+    val cpu: String
+}
+class PC(override val cpu: String = "Core") : Computer
+class Server(override val cpu: String = "Xeon") : Computer
+
+enum class ComputerType {
+    PC, Server
+}
+
+class ComputerFactory {
+    fun produce(type: ComputerType): Computer {
+        return when (type) {
+            ComputerType.PC -> PC()
+            ComputerType.Server -> Server()
+        }
+    }
+}
+fun main() {
+	val pc = ComputerFactory().produce(ComputerType.PC)
+    println(pc.cpu) // Core	
+}
+```
+
+以上代码通过调用ComputerFactory类的produce方法来创建不同的Computer子类对象，这样我们就把创建实例的逻辑和客户端之间实现解耦。这是用Kotlin模仿Java中很标准的工厂模式设计，它改善了程序的可维护性，但创建对象的表达上却显得不够简洁。当我们在不同的地方创建Computer的子类对象时，我们都需要先创建一个ComputerFactory类对象。
+
+### 用单例代替工厂类
+
+我们已经知道Kotlin支持用object来实现Java中的单例模式。所以可以实现一个ComputerFactory单例，而不是一个工厂类： 
+
+```kotlin
+object ComputerFactory {
+    fun produce(type: ComputerType) : Computer {
+        return when (type) {
+            ComputerType.PC -> PC()
+            ComputerType.Server -> Server()
+        }
+    }
+}
+fun main() {
+    // 这样我们就不用再每次都创建对象了
+	val pc = ComputerFactory.produce(ComputerType.PC)
+    println(pc.cpu)
+}
+```
+
+由于我们通过传入Computer类型来创建不同的对象，所以这里的produce又显得多余。我们可以用运算符重载来通过operator操作符重载invoke方法来代替produce，从而进一步简化表达： 
+
+```kotlin
+object ComputerFactory {
+    operator fun invoke(type: ComputerType) : Computer {
+        return when (type) {
+            ComputerType.PC -> PC()
+            ComputerType.Server -> Server()
+        }
+    }
+}
+fun main() {
+    // 这样就会非常简洁
+	val pc = ComputerFactory(ComputerType.PC)
+    println(pc.cpu)
+}
+```
+
+
+
+### 伴生对象创建静态工厂方法
+
+上面的工厂模式实现已经足够优雅，然而依旧不够完美： 我们是否可以直接通过Computer()而不是ComputerFactory()来创建一个实例呢？
+
+我们可以通过在Computer接口中定义一个伴生对象，这样就能实现以上的需求:  
+
+```kotlin
+interface Computer {
+    val cpu: String
+    companion object {
+        operator fun invoke(type: ComputerType) : Computer {
+            return when (type) {
+                ComputerType.PC -> PC()
+                ComputerType.Server -> Server()
+            }
+        }
+    }
+}
+
+fun main() {
+	val pc = Computer(ComputerType.PC)
+    println(pc.cpu)
+}
+```
+
+我们可以直接通过Computer来调用其伴生对象中的方法。当然，如果你觉得还是Factory这个名字好，那么也没有问题，我们可以用Factory来命名Computer的伴生对象，如下： 
+
+```kotlin
+interface Computer {
+    val cpu: String
+    companion object Factory {
+        operator fun invoke(type: ComputerType) : Computer {
+            return when (type) {
+                ComputerType.PC -> PC()
+                ComputerType.Server -> Server()
+            }
+        }
+    }
+}
+
+fun main() {
+	val pc = Computer.Factory(ComputerType.PC)
+    println(pc.cpu)
+}
+```
+
+
+
+### 扩展伴生对象方法
+
+依靠伴生对象的特性，我们已经很好地实现了经典的工厂模式。同时，这种方式还有一种优势，它比原有Java中的设计更加强大。假设实际业务中我们是Computer接口的使用者，比如它是工程引入的第三方类库，所有的类的实现细节都得到了很好的隐藏。那么，如果我们希望进一步改造其中的逻辑，Kotlin中伴生对象的方式同样可以依靠其扩展函数的特性，很好的实现这一需求： 
+
+比如我们希望给Computer增加一种功能，通过CPU型号来判断电脑类型，那么可以如下实现：  
+
+```kotlin
+fun Computer.Factory.fromCPU(cpu: String) : ComputerType? = when(cpu) {
+    "Core" -> ComputerType.PC
+    "Xeon" -> ComputerType.Server
+    else -> null
+}
+fun main() {
+	val pc = Computer.Factory.fromCPU("Core")
+    println(pc)
+}
+```
+
+
+
+### 内联函数简化抽象工厂
+
+Kotlin中的内联函数有一个很大的作用，就是可以具体化参数类型。利用这一特性，可以改进一种更复杂的工厂模式，称为抽象工厂。 上面的例子中已经用工厂模式很好的处理了一个产品登记结构的问题。但是如果现在引入了品牌商的概念，我们有好几个不同的电脑品牌，比如Dell、Asus、Acer，那么就有必要再增加一个工厂类。然而，我们并不希望对每个模型都建立一个工厂，这会让代码变得难以维护，所以这时候我们就需要引入抽象工厂模式。 
+
+
+
+##### 抽象工厂模式
+
+为创建一组相关或相互依赖的对象提供一个接口，而且无须指定他们的具体类。 
+
+```kotlin
+interface Computer
+class Dell: Computer
+class Asus: Computer
+class Acer: Computer
+
+class DellFactory: AbstractFactory() {
+    override fun produce() = Dell()
+}
+class AsusFactory: AbstractFactory() {
+    override fun produce() = Asus()
+}
+class AcerFactory: AbstractFactory() {
+    override fun produce() = Acer()
+}
+
+abstract class AbstractFactory {
+    abstract fun produce(): Computer
+    companion object {
+        operator fun invoke(factory: AbstractFactory): AbstractFactory {
+            return factory
+        }
+    }
+}
+fun main(args: Array<String>) {
+    val dellFactory = AbstractFactory(DellFactory())
+    val dell = dellFactory.produce()
+    println(dell)
+}
+```
+
+可以看出，每个电脑品牌拥有一个代表电脑产品的类，它们都实现了Computer接口。此外每个品牌也还有一个用于生产电脑的AbstractFactory子类，可通过AbstractFactory类的伴生对象中的invoke方法，来构造具体品牌的工厂类对象。
+
+由于Kotlin语法的简洁，以上例子的抽象工厂类的设计也比较直观。然而，当你每次创建具体的工厂类时，都需要传入一个具体的工厂类对象作为参数进行构造，这个在语法上显然不够优雅。下面我们就来看看，如何用Kotlin中的内联函数来改善这一情况。我们所需要做的，就是去重新实现AbstractFactory类中的invoke方法。 
+
+```kotlin
+abstract class AbstractFactory {
+    abstract fun produce(): Computer
+    companion object {
+        // 增加reified关键字
+        inline operator fun <reified T : Computer> invoke(): AbstractFactory = 
+            when (T::class) {
+                Dell::class -> DellFactory()
+                Asus::class -> AsusFactory()
+                Acer::class -> AcerFactory()
+                else -> throw IllegalArgumentException()
+            }
+    }
+}
+```
+
+这下我们的invoke方法定义的前缀变长了很多，但是不要害怕，如果你已经掌握了内联函数的具体应用，应该会很容易理解它。我们来分析下这段代码： 
+
+- 通过将invoke方法用inline定义为内联函数，我们就可以引入reified关键字，使用具体化参数类型的语法特性。
+- 要具体化的参数类型为Computer，在invoke方法中我们通过判断它的具体类型，来返回对应的工厂类对象。
+
+再来看看通过上面内联函数改善后的工厂类的创建语法表达： 
+
+```kotlin
+fun main(args: Array<String>) {
+    val dellFactory = AbstractFactory<Dell>()
+    val dell = dellFactory.produce()
+    println(dell)
+}
+```
+
+现在终于可以用类似创建一个泛型类对象的方式，来构建一个抽象工厂具体对象了。
+
+
+
+## 构造者模式
+
+构造者模式与单例模式一样，它主要做的事情就是将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。 
+
+工厂模式和构造函数都存在相同的问题，就是不能很好地扩展到大量的可选参数。假设我们现在有个机器人类，它含有多个属性：代号、名字、电池、重量、高度、速度、音量等。很多产品都不具有其中的某些属性，比如不能走、不能发声，甚至有的机器人也不需要电池。 
+
+一种糟糕的做法就是设计一个一开头你所看到Robot类，把所有的属性都作为构造函数的参数。或者，你也可能采用过重叠构造器模式，即先提供一个只有必要参数的构造函数，然后再提供其他更多的构造函数，分别具有不同情况的可选属性。虽然这种模式在调用的时候改进不少，但同样存在明显的确定，因为随着构造函数的参数数量增加，很快我们就会失去控制，代码变得难以维护。
+
+构建者模式可以避免以上问题，我们用Kotlin来实现Java中的构建者模式:  
+
+```kotlin
+class Robot private constructor （
+    val code: String,
+    val battery: String?,
+    val height: Int?,
+    val weight: Int?） {
+        
+        class Builder(val code: String) {
+            private var battery: String? = null
+            private var height: Int? = null
+            private var weight: Int? = null
+            
+            fun setBattery(battery: String?): Builder {
+                this.battery = battery
+                return this
+            }
+            
+            fun setHeight(height: Int): Builder {
+                this.height = height
+                return this
+            }
+            
+            fun setWeight(weight: Int): Builder {
+                this.weight = weight
+                return this
+            }
+            fun build(): Robot {
+                return Robot(code, battery, height, weight)
+            }
+        }
+    }
+}
+
+var robot = Robot.Builder("007")
+    .setBattery("R6")
+    .setHeight(100)
+    .setWeight(80)
+    .build()
+```
+
+为了避免代码太长，上面的例子中只选择了4个属性，其中code是必须属性，battery、height、weight为可选属性。我们来分析一下它的具体思路:  
+
+- Robot类内部定义了一个嵌套类Builder，由它负责创建Robot对象
+- Robot类的构造函数用private进行修饰，这样可以确保使用者无法直接通过Robot声明实例
+- 通过在Builder类中定义set方法来对可选的属性进行设置
+- 最终调用Builder类中的build方法来返回一个Robot对象
+
+这种链式调用的设计看起来确实优雅了很多，同时对于可选参数的设置也显得比较语义化。此外，构建者模式另外一个好处就是解决了多个可选参数的问题，当我们创建对象实例时，只需要用set方法对需要的参数进行赋值即可。
+
+然而，构建者模式也存在一些不足：  
+
+- 如果业务需求的参数很多，代码依然会显得比较长
+- 你可能会在使用Builder的时候忘记在最后调用build方法
+- 由于在创建对象的时候，必须先创建它的构造器，因此额外增加了多余的开销，在某些十分注重性能的情况下，可能就存在一定的问题。
+
+事实上，当用Kotlin设计程序时，我们可以在绝大多数情况下避免使用构建者模式。《Effective Java》在介绍构建者模式时，是这样子描述它的：本质上builder模式模拟了具名的可选参数。幸运的是，Kotlin也是这样一门拥有具名可选参数的编程语言。
+
+#### 具名的可选参数
+
+Kotlin中的函数和构造器都支持这一特性，它主要表现为两点： 
+
+- 在具体化一个参数的取值时，可以通过带上它的参数名，而不是它在所有参数中的位置决定。
+- 由于参数可以设置默认值，这允许我们只给出部分参数的取值，而不必是所有的参数。
+
+因此，我们可以直接使用Kotlin中原生的语法特性来实现构建者模式的效果。现在重新设计以上的Robot例子： 
+
+```kotlin
+class Robot(
+    val code: String,
+    val battery: String? = null,
+    val height: Int? = null,
+    val weight: Int? = null
+)
+
+
+private fun main() {
+    val robot1 = Robot(code = "007")
+    val robot2 = Robot(code = "007", battery = "R6")
+    val robot3 = Robot(code = "007", height = 100, weight = 80)
+
+    println(robot1)
+}
+```
+
+可以发现，相比构建者模式，通过具名的可选参数构造类具有很多优点：  
+
+- 代码变得十分简单，这不仅表现在Robot类的结构体代码量，我们在声明Robot对象时的语法也要更加简洁
+- 声明对象时，每个参数名都可以是显式的，并且无须按照顺序书写，非常方便灵活
+- 由于Robot类的每个对象都是val声明的，相较构建者模式中的var的方案更加安全，这在要求多线程并发安全的业务场景中会显得更有优势。 
+
+此外，如果你的类的功能足够简单，更好的思路是用data class直接声明一个数据类。数据类同样支持以上的所有特性。 
+
+
+
+#### require方法对参数进行约束
+
+我们再来看看构建者模式的另外一个作用，就是可以在build方法中对参数添加约束条件。举个例子，假设一个机器人的重量必须根据电池的型号决定，那么在未传入电池型号之前，你便不能对weight属性进行赋值，否则就会抛出异常。现在重新修改一下上面build方法的实现：
+
+```kotlin
+fun build(): Robot {
+    if (weight != null && battery == null) {
+        throw IllegalArgumentException("Battery should be determined when setting weight.")
+    } else {
+        return Robot(code, battery, height, weight)
+    }
+}
+```
+
+这种在build方法中对参数进行约束的手段，可以让业务变得更加安全。那么，通过具名的可选参数来构造类的方案该如何实现呢？ 
+
+显然，我们同样可以在Robot类的init方法中增加以上的校检代码。然而在Kotlin中，我们在类或函数中还可以使用require关键字进行参数限制，本质上它是一个内联的方法，有点类似于Java的assert。 
+
+```kotlin
+class Robot(
+    val code: String,
+    val battery: String? = null,
+    val height: Int? = null,
+    val weight: Int? = null
+) {
+    init {
+        require(weight == null || battery != null) {
+            "Battery should be determined when setting weight."
+        }
+    } 
+}
+```
+
+可见，Kotlin的require方法可以让我们的参数约束代码在语义上变得更加友好。总的来说，在Kotlin中我们应该尽量避免使用构建者模式，因为Kotlin支持具名的可选参数，这让我们可以在构造一个具有多个可选参数类的场景中，设计出更加简洁并利于维护的代码。
+
+
+
+
+
+## 观察者模式
+
+观察者模式定义了一个一对多的依赖关系，让一个或多个观察者对象监听一个主题对象。这样一来，当被观察者状态发生改变时，需要通知相应的观察者，使这些观察者对象能够自动更新。
+
+简单来说，观察者模式无非做两件事情： 
+
+- 订阅者（observer）添加或删除对发布者（publisher）的状态监听。
+- 发布者状态改变时，将事件通知给监听它的所有观察者，然后观察者执行响应逻辑。
+
+Java自身的标准库提供了java.util.Observable类和java.util.Observer接口，来帮助实现观察者模式，接下来我们就采用它们来实现一个动态更新股价的例子。
+
+```kotlin
+class StockUpdate: Observable() {
+    val observers = mutableSetOf<Observer>()
+    fun setStockChanged(price: Int) {
+        this.observers.forEach { it.update(this, price)}
+    }
+}
+class StockDisplay: Observer {
+    override fun update(o: Observable, price: Any) {
+        if (o is StockUpdate) {
+            println("The latest stock price is ${price}")
+        }
+    }
+}
+fun main(args: Array<String>) {
+    val su = StockUpdate()
+    val sd = StockDisplay()
+    su.observers.add(sd)
+    su.setStockChanged(100)
+}
+```
+
+上面是通过Kotlin使用Java标准库中的类和方法来实现了观察者模式。事实上，Kotlin的标准库额外引入了可被观察的委托属性，也可以利用它来实现同样的场景。 
+
+我们可以先用这一委托属性来改造以上的程序：  
+
+```kotlin
+import kotlin.properties.Delegates
+
+interface StockUpdateListener {
+    fun onRise(price: Int)
+    fun onFall(price: Int)
+}
+
+class StockDisplay: StockUpdateListener {
+    override fun onRise(price: Int) {
+        println("The latest stock price has risen to ${price}")
+    }
+    override fun onFall(price: Int) {
+        println("The latest stock price has fell to ${price}")
+    }
+}
+
+class StockUpdate {
+    var listeners = mutableSetOf<StockUpdateListener>()
+    var price: Int by Delegates.observable(0) {_, old, new ->
+        listeners.forEach {
+            if (new > old) it.onRise(price) else it.onFall(price)
+        }                                              
+    }
+}
+fun main(args: Array<String>) {
+    val su = StockUpdate()
+    val sd = StockDisplay()
+    su.listeners.add(sd)
+    su.price = 100
+    su.price = 98
+}
+// 执行结果
+The latest stock price has risen to 100
+The latest stock price has fell to 98
+```
+
+如果你仔细思考，会发现实现java.util.Observer接口的类只能覆写update方法来编写响应逻辑，也就是说如果存在多种不同的逻辑响应，我们也必须通过在该方法中进行区分实现，显然这会让订阅者的代码显得臃肿。换个角度，如果我们把发布者的事件推送看成一个第三方服务，那么它提供的API接口只有一个，API调用者必须承担更多的职责。
+
+显然，使用Delegates.observable()的方案更加灵活。它提供了三个参数，依次代表委托属性的元数据KProperty对象、旧值以及新值。通过额外定义一个StockUpdateListener接口，我们可以把上涨和下跌的不同响应逻辑封装成接口方法，从而在StockDisplay中实现该接口的onRise和onFall方法，实现了解耦。 
+
+
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md" "b/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
new file mode 100644
index 00000000..23458c79
--- /dev/null
+++ "b/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
@@ -0,0 +1,742 @@
+Kotlin之Lambda&内联函数(七)
+===
+
+
+
+函数式语言一个典型的特征就在于函数是头等公民-我们不仅可以像类一样在顶层直接定义一个函数，也可以在一个函数内部定义一个函数，例如:  
+
+```kotlin
+fun foo(x: Int) {
+    fun double(y: Int): Int {
+        return y * 2
+    }
+    println(double(x))
+}
+
+执行foo(1)结果为2
+```
+
+
+
+## 高阶函数
+
+Kotlin天然支持了部分函数式特性。函数式语言一个典型的特征就在于函数是头等公民——我们不仅可以像类一样在底层直接定义一个函数，也可以在一个函数内部定义一个局部函数。 
+
+```kotlin
+fun foo(x: Int) {
+    fun double(y: Int): Int {
+        return y * 2
+    }
+    println(double(x))
+}
+```
+
+### 抽象和高阶函数
+
+我们会善于对熟悉 或重复的事物进行抽象，比如2岁左右的小孩就会开始认识数字1、2、3....之后，我们总结除了一些公共的行为，如对数字做加减、求立方，这被称为过程，它接收的数字是一种数据，然后也可能产生另一种数据。
+
+过程也是一种抽象，几乎我们所熟悉的所有高级语言都包含了定义过程的能力，也就是函数。
+
+然而，在我们以往熟悉的编程中，过程限制为只能接收数据为参数，这个无疑限制了进一步抽象的能力。
+
+由于我们经常会遇到一些同样的程序设计模式能够用于不同的过程，比如一个包含了正整数的列表，需要对它的元素进行各种转换操作，例如对所有元素都乘以3，或者都除以2。我们就需要提供一种模式，同时接收这个列表及不同的元素操作过程，最终返回一个新的列表。
+
+为了把这种类似的模式描述为相应的概念，我们就需要构造出一种更加高级的过程，表现为：接收一个或多个过程为参数，或者以一个过程作为返回结果。这个就是所谓的高阶函数，你可以把它理解为“以其他函数作为参数或返回值的函数”。高阶函数是一种更加高级的抽象机制，它极大地增强了语言的表达能力。
+
+
+
+### 实例： 函数作为参数的需求
+
+Shaw因为旅游喜欢上了地理，然后他建了一个所有国家的数据库。作为一名程序员，他设计了一个CountryApp类对国家数据进行操作。Shaw偏好欧洲的国家，于是他设计了一个程序来获取欧洲的所有国家。
+
+```kotlin
+data class Country {
+    val name: String, 
+    val continient: String,
+    val population: Int
+}
+
+class CountryApp {
+    fun filterCountries(countries: List<Country>): List<Country> {
+        val res = mutableListOf<Country>()
+        for (c in countries) {
+            if (c.continent == "EU") { // EU代表欧洲
+                res.add(c)
+            }
+        }
+        return res
+    }
+}
+```
+
+后来Shaw对非洲也产生了兴趣，于是他又改进了上述方法的实现，支持根据具体的州来筛选国家。
+
+```kotlin
+fun filterCountries(countries: List<Country>, continient: String): List<Country> {
+    val res = mutableListOf<Country>()
+    for (c in countries) {
+        if (c.continient == continient) {
+            res.add(c)
+        }
+    }
+    return res
+}
+```
+
+以上程序具备了一定的复用性。然而，Shaw的地理知识越来越丰富了，他想对国家的特点做进一步的研究，比如筛选具有一定人口规模的国家，于是代码又变成下面这个样子: 
+
+```kotlin
+fun filterCountries(countries: List<Country>, continient: String, population: Int) : List<Country> {
+    val res = mutableListOf<Country>()
+    for (c in countries) {
+        if (c.continient == continient && c.population > population) {
+            res.add(c)
+        }
+    }
+    return res
+}
+```
+
+新增了一个population的参数来代表人口(单位:万)。Shaw开始感觉到不对劲，如果按照现有的设计，更多的筛选条件会作为方法参数而不断增加，而且业务逻辑也会高度耦合。
+
+解决问题的核心在于对filterCountries方法进行解耦，我们能否把所有的筛选逻辑行为都抽象成一个参数呢？传入一个类对象是一种解决方法，我们可以根据不同的筛选需求创建不同的子类，它们都各自实现了一个校检方法。然而，Shaw了解到Kotlin是支持高阶函数的，理论上我们同样可以把筛选的逻辑变成一个方法来传入，这样思路更简单。
+
+他想要进一步了解高级的特性，所以很快写了一个新的测试类:  
+
+```kotlin
+class CountryTest {
+    fun isBigEuropeanCountry(country: Country): Boolean {
+        return country.continient == "EU" && country.population > 10000
+    }
+}
+```
+
+调用isBigEuropeanCountry方法就能够判断一个国家是否是一个人口超过1亿的欧洲国家。然而，怎样才能把这个方法变成filterCountries方法的一个参数呢？要实现这一点似乎要先解决以下两个问题： 
+
+- 方法作为参数传入，必须像其他参数一样具备具体的类型信息
+
+    在kotlin中，函数类型的格式非常简单: 
+
+    - 通过  -> 符号来组织参数类型和返回值类型，左边是参数类型，右边是返回值类型
+    - 必须用一个括号来包裹参数类型，如果是一个没有参数的函数类型，参数类型部分就用()表示
+    - 返回值类型即使是Unit，也必须显式声明
+
+    举个例子: 
+
+    ```kotlin
+    (Int) -> Unit
+    () -> Unit
+    (Int, String) -> Unit
+    // 还支持为声明参数指定名字
+    (errCode: Int, errMsg: String) -> Unit
+    // ?表示可选，可在某种情况下为空
+    ((errCode: Int, errMsg: String?) -> Unit)?
+    ```
+
+    在学习了Kotlin函数类型知识之后，Shaw重新定义了filterCountries方法的参数声明:  
+
+    ```kotlin
+    // 增加了一个函数类型的参数test
+    fun filterCountries(countries: List<Country>, test: (Country) -> Boolean): List<Country> {
+        val res = mutableListOf<Country>()
+        for (c in countries) {
+            // 直接调用test函数来进行筛选
+            if (test(c)) {
+                res.add(c)
+            }
+        }
+        return res
+    }
+    ```
+
+    接下来就是如何把isBigEuropeanCountry方法传递给filterCountries呢？ 直接把isBigEuropeanCountry当参数肯定不行，因为函数名并不是一个表达式不具有类型信息。所以我们需要的是一个单纯的方法引用表达式。
+
+- 需要把isBigEuropeanCountry的方法引用当做参数传递给filterCountries
+
+    Kotlin存在一种特殊的语法，通过两个冒号来实现对于某个类的方法进行引用(方法引用表达式)。以上面的代码为例，假如我们有一个CountryTest类的对象实例countryTest，如果要引用它的isBigEuropeanCountry方法，就可以这样写:   
+
+    ```kotlin
+    countryTest::isBigEuropeanCountry
+    ```
+
+    于是，Shaw便使用了方法引用来传递参数:  
+
+    ```kotlin
+    val countryApp = CountryApp()
+    val countryTest = CountryTest()
+    val countries = ...
+    
+    countryApp.filterContries(countries, countryTest::isBigEuropeanCountry)
+    ```
+
+经过重构后的程序显然比之前要优雅许多，程序可以根据任意的筛选需求，调用同一个filterCountries方法来获取国家数据。
+
+#### 方法引用表达式更多使用场景
+
+此外，我们还可以直接通过这种语法，来定义一个类的构造方法引用变量。
+
+```kotlin
+class Book(val name: String) {
+    fun main(args: Array<String>) {
+        val getBook = ::Book
+        println(getBook("Dive into Kotlin").name)
+    }
+}
+```
+
+可以发现，getBook类型为(name: String) -> Book。类似的道理，如果我们要引用某个类的成员变量，如Book类中的name，就可以这样引用:  
+
+```kotlin
+Book::name
+```
+
+以上创建的Book::name的类型为(Book) -> String。
+
+
+
+## 匿名函数
+
+再来思考下上面代码中的CountryTest类，这仍算不上是一种很好的方案。因为每增加一个需求，我们都需要在类中专门写一个新增的筛选方法。然而Shaw的需求很多都是临时性的，不需要被复用。Shaw觉得这样还是比较麻烦，他打算用匿名函数对程序进一步的优化。
+
+Kotlin支持在缺省函数名的情况下，直接定义一个函数。所以isBigEuropeanCountry方法我们可以直接定义为:  
+
+```kotlin
+// 没有函数名字
+fun(country: Country): Boolean {
+    return country.continient == "EU" && country.population > 10000
+}
+```
+
+于是，Shaw直接调用filterCountries，如下:  
+
+```kotlin
+countryApp.filterCountries(countries, fun(country: Country): Boolean) {
+	return country.continient == "EU" && country.population > 10000    
+})
+```
+
+这一次我们甚至不需要CountryTest这个类了，代码的简洁性又上了一层楼。Shaw开始意识到Kotlin这门语言的魅力，很快他发现还有一种语法可以让代码更简单，这就是Lambda表达式。
+
+我们继续看上面的filterCountries方法的匿名函数，会发现:  
+
+- fun(country: Country)显得比较啰嗦，因为编译器会推导类型，所以只需要一个代表变量的country就行了。
+- return关键字也可以省略，这里返回的是一个有值的表达式
+- 模仿函数类型的语法，我们可以用 -> 把函数和返回值连接在一起
+
+因此，简化后的表达就变成了这个样子:   
+
+```kotlin
+countryApp.filterCountries(countries, {
+    country -> 
+    country.continient == "EU" && country.population > 10000
+})
+```
+
+这就是Lambda表达式，它与匿名函数一样，是一种函数字面量。
+
+Lambda的语法:  
+
+- 一个Lambda表达式必须通过{}来包裹
+- 如果Lambda声明了参数部分的类型，且返回值类型支持类型推导，那么Lambda变量就可以省略函数类型声明
+- 如果Lambda变量声明了函数类型，那么Lambda的参数部分的类型就可以省略
+
+此外，如果Lambda表达式返回的不是Unit，那么默认最后一行表达式的值类型就是返回值类型，如:  
+
+```kotlin
+val foo = { x: Int -> 
+    val y = x + 1
+	y // 返回值是y           
+}
+```
+
+## Lambda表达式
+
+
+> “Lambda 表达式”(lambda expression)其实就是匿名函数，`Lambda`表达式基于数学中的`λ`演算得名，直接对应于其中的`lambda`抽象
+> `(lambda abstraction)`，是一个匿名函数，即没有函数名的函数。`Lambda`表达式可以表示闭包（注意和数学传统意义上的不同）。
+
+`Java 8`的一个大亮点是引入`Lambda`表达式，使用它设计的代码会更加简洁。
+
+```java
+// 没有使用Lambda的老方法:   
+button.addActionListener(new ActionListener(){
+	public void actionPerformed(ActionEvent ae){
+		System.out.println("Actiondetected");
+	}
+});
+// 使用Lambda:  
+button.addActionListener(()->{ 
+	System.out.println("Actiondetected");
+});
+
+
+// 不采用Lambda的老方法: 
+Runnable runnable1=new Runnable(){
+	@Override
+	public void run(){
+		System.out.println("RunningwithoutLambda");
+	}
+};
+// 使用Lambda:   
+Runnable runnable2=()->{
+	System.out.println("RunningfromLambda");
+};
+```
+
+`Lambda`能让代码更简洁，Kotlin的支持如下:   
+
+- `lambda`表达式总是被大括号括着
+- 其参数(如果有的话)在`->`之前声明(参数类型可以省略)，
+- 函数体(如果存在的话)在`->`后面。
+
+`Lambda`表达式是定义匿名函数的简单方法。由于`Lambda`表达式避免在抽象类或接口中编写明确的函数声明，进而也避免了类的实现部分，
+所以它是非常有用的。在`Kotlin`语言中，可以将一函数作为另一函数的参数。
+
+`Lambda`表达式由箭头左侧函数的参数（在圆括号里的内容）定义的，将值返回到箭头右侧。
+`view.setOnClickListener({ view -> toast("Click")})`
+在定义函数时，必须在箭头的左侧用方括号，并指定参数值，而函数的执行代码在箭头右侧。如果左侧不使用参数，甚至可以省去左侧部分:  
+`view.setOnClickListener({ toast("Click") })`
+如果函数的最后一个参数是一个函数的话，可以将作为参数的函数移到圆括号外面:
+`view.setOnClickListener() { toast("Click") }`
+
+
+先看一个例子:    
+
+```kotlin
+fun compare(a: String, b: String): Boolean {
+    return a.length < b.length
+}
+max(strings, compare)
+```
+就是找出`strings`里面最长的那个。但是我个人觉得`compare`还是很碍眼的，因为我并不想在后面引用他，那我怎么办呢，就是用“匿名函数”方式。
+```kotlin
+max(strings, (a,b)->{a.length < b.length})
+```
+
+`(a,b)->{a.length < b.length}`就是一个没有名字的函数，直接作为参数赋给`max`方法的第二个参数。但这个方法有很多东西都没有写明，如:   
+
+- 参数的类型
+- 返回值的类型
+
+但这些真的必要吗？`a.length < b.length`很明显返回一个`Boolean`的值，再就是`max`的定义中肯定也定义了这个函数的参数类型和返回值类型。
+这么明显的事为什么不让计算机自己去做而要让人写代码去做呢？这就是匿名函数的好处了。到这里，我们已经和`Lambda`很接近了。
+
+```kotlin
+val sum: (Int, Int) -> Int = { x, y -> x + y }
+```
+
+`Lambda`表达式就是被大括号括着的那一部分，在`->`符号之前有参数声明，函数体跟在一个`->`符号之后。
+而且此`Lambda`表达式之前有一个匿名的函数声明(在此例中两个`Int`型的输入，一个`Int`型的返回值)，这个声明是可以不使用的。
+则此`Lambda`表达式变成`val sum = { x: Int, y: Int -> x + y }`，此时`Lambda`表达式会根据主体中的最后一个（或可能是单个）表达式会视为
+返回值。当然，在某些特定情况下，`x`、`y`的类型了是可以推断的，所以`val sum = { x, y -> x + y }`。
+
+## Lambda开销
+
+```kotlin
+fun foo(int: Int) = {
+    print(int)
+}
+listOf(1, 2, 3).forEach { foo(it) } // 对一个整数列表的元素遍历调用foo
+```
+
+这里，你可定会纳闷it是啥？其实它也是Kotlin简化Lambda表达的一种语法糖，叫做单个参数的隐式名称，代表了这个Lambda所接收的单个参数。这里的调用等价于:  
+
+```kotlin
+listOf(1, 2, 3).forEach { item -> foo(item) }
+```
+
+默认情况下，我们可以直接用it来代表item，而不需要用item -> 进行声明。
+
+我们看一下foo函数用IDE转换后的Java代码:  
+
+```java
+@JvmStatic
+@NotNull
+public static final Function0 foo(final int var0) {
+    return (Function0)(new Function0() {
+        // $FF: synthetic method
+        // $FF: bridge method
+        public Ojbect invoke() {
+            this.invoke();
+            return Unit.INSTANCE;
+        }
+        public final void invoke() {
+            int var1 = var0;
+            System.out.printlln(var1);
+        }
+    });
+}
+```
+
+以上是字节码反编译的Java代码，从中我们可以发现Kotlin实现Lambda表达式的机理。
+
+### Function类型
+
+Kotlin在JVM层设计了Function类型(Function0、Function1 ... Function22、FunctionN)来兼容Java的Lambda表达式，其中的后缀数字代表了Lambda参数的数量，如以上的foo函数构建的其实是一个无参Lambda，所以对应的接口是Function0，如果有一个参数那么对应的就是Function1.它在源码是如下定义的:  
+
+```kotlin
+package kotlin.jvm.functions
+interface Function1<in P1, out R> : kotlin.Function<R> {
+    fun invoke(p1: P1) : R
+}
+```
+
+可见每个Function类型都有一个invoke方法。设计Function类型的主要目的之一就是要兼容Java，实现在Kotlin中也能调用Java的Lambda。在Java中，实际上并不支持把函数作为参数，而是通过函数式接口来实现这一特性。
+
+foo函数的返回类型是Function()。这也意味着，如果我们调用了foo(n)，那么实质上仅仅是构造了一个Function()对象。这个对象并不等价于我们要调用的过程本身。通过源码可以发现，需要调用Function()的invoke方法才能执行println方法。所以上面的例子必须如下修改，才能最终打印出我们想要的结果:  
+
+```kotlin
+fun foo(int: Int) = {
+    print(int)
+}
+listOf(1, 2, 3).forEach { foo(it).invoke() } // 增加了invoke调用
+```
+
+
+
+但是invoke这种语法显得丑陋，不符合Kotlin简洁表达的设计理念，所以我们还可以用熟悉的括号调用来替代invoke，如下所示:  
+
+```kotlin
+listOf(1, 2, 3).forEach{ foo(it)() }
+```
+
+#### 闭包
+
+在Kotlin中，你会发现匿名函数体、Lambda在语法上都存在“{}"，由这对花括号包裹的代码如果访问了外部环境变量则被称为一个闭包。
+
+一个闭包可以被当做参数传递或直接使用，它可以简单的看成”访问外部环境变量的函数“。Lambda是Kotlin中最常见的闭包形式。
+
+与Java不一样的地方在于，Kotlin中的闭包不仅可以访问外部变量，还能够对其进行修改，如下： 
+
+```kotlin
+var sum = 0
+listOf(1, 2, 3).filter { it > 0 }.forEach {
+    sum += it
+}
+println(sum)  // 6
+```
+
+## 内联函数
+
+在我开始学的时候，一直没搞明白内联函数到底是干什么？ 有什么作用？Kotlin中的内联函数其实显得有点尴尬，因为它之所以被设计出来，主要是为了优化Kotlin支持Lambda表达式之后所带来的开销。然而，在Java中我们似乎并不需要特别关注这个问题，因为在Java 7之后，JVM引入了一种叫做invokedynamic的技术，它会自动帮助我们做Lambda优化。但是为什么Kotlin要引入内联函数这种手动的语法呢？ 这主要还是因为Kotlin要兼容Java 6。
+
+
+
+## 优化Lambda开销
+
+在Kotlin中每声明一个Lambda表达式，就会在字节码中产生一个匿名类。该匿名类包含了一个invoke方法，作为Lambda的调用方法，每次调用的时候，还会创建一个新的对象。可想而知，Lambda语法虽然简洁，但是额外增加的开销也不少。并且，如果Lambda捕捉了某个变量，那么每次调用的时候都会创建一个新的对象，这样导致效率较低。尤其对Kotlin这门语言来说，它当今优先要实现的目标，就是在Android这个平台上提供良好的语言特性支持。Kotlin要在Android中引入Lambda语法，必须采用某种方法来优化Lambda带来的额外开销，也就是内联函数。 
+
+#### 1. invokedynamic
+
+在讲述内联函数具体的语法之前，我们先来看看Java中是如何解决这个问题的。与Kotlin这种在编译期通过硬编码生成Lambda转换类的机制不同，Java在SE 7之后通过invokedynamic技术实现了在运行期才产生相应的翻译代码。在invokedynamic被首次调用的时候，就会触发产生一个匿名类来替换中间码invokedynamic，后续的调用会直接采用这个匿名类的代码。这种做法的好处主要体现在： 
+
+- 由于具体的转换实现是在运行时产生的，在字节码中能看到的只有一个固定的invokedynamic，所以需要静态生成的类的个数及字节码大小都显著减少。
+- 与编译时写死在字节码中的策略不同，利用invokedynamic可以把实际的翻译策略隐藏在JDK库的实现， 这极大提高了灵活性，在确保向后兼容性的同时，后期可以继续对编译策略不断优化升级
+- JVM天然支持了针对该方式的Lambda表达式的翻译和优化，这也意味着开发者在书写Lambda表达式的同时，可以完全不用关心这个问题，这极大地提升了开发的体验。 
+
+
+
+#### 2. 内联函数
+
+invokedynamic固然不错，但Kotlin不支持它的理由似乎也很充分，我们有足够的理由相信，其最大的原因是Kotlin在一开始就需要兼容Android最主流的Java版本SE 6，这导致它无法通过invovkedynamic来解决Android平台的Lambda开销问题。 
+
+因此，作为另一种主流的解决方案，Kotlin拥抱了内联函数，在C++、C#等语言中也支持这种特性。简单的来说，我们可以用inline关键字来修饰函数，这些函数就称为了内联函数。他们的函数体在编译期被嵌入每一个被调用的地方，以减少额外生成的匿名类数，以及函数执行的时间开销。 
+
+所以如果你想在用Kotlin开发时获得尽可能良好的性能支持，以及控制匿名类的生成数量，就有必要来学习下内联函数的相关语法。 
+
+这里通过一个实际的例子，看看Kotlin的内联函数是具体如何操作的:   
+
+```kotlin
+fun main(args: Array<String>) {
+    foo {
+        println("dive into Kotlin...")
+    }
+}
+
+fun foo(block: () -> Unit) {
+    println("before block")
+    block()
+    println("end block")
+}
+```
+
+首先，我们声明了一个高阶函数foo，可以接受一个类型为() -> Unit的Lambda，然后在main函数中调用它。以下是通过字节码反编译的相关Java代码:   
+
+```java
+public static final void main(@NotNull String[] args) {
+    Intrinsics.checkParameterIsNotNull(args, "args");
+    foo((Function0)null.INSTANCE);	        
+}
+
+public static final void foo(@NotNull Function0 block) {
+    Intrinsics.checkParameterIsNotNull(block, "block");
+    String var1 = "before block";
+    System.out.println(var1);
+    block.invoke();
+    var1 = "end block";
+    System.out.println(var1);
+}
+```
+
+据我们所知，调用foo就会产生一个Function()类型的block类，然后通过invovke方法来执行，这会增加额外的生成类和调用开销。现在，我们给foo函数加上inline修饰符，如下:   
+
+```kotlin
+inline fun foo(block: () -> Unit) {
+    println("before block")
+    block()
+    println("end block")
+}
+```
+
+再来看看相应的Java代码:  
+
+```java
+public static final void main(@NotNull String[] args) {
+    Intrinsics.checkParameterIsNotNull(args, "args");
+    String va1 = "before block";
+    System.out.println(var1);
+    // block函数体在这里开始粘贴
+    String var2 = "dive into Kotlin...";
+    System.out.println(var2);
+    // block函数体在这里结束粘贴
+    var1 = "end block";
+    System.out.println(var1);
+}
+
+public static final void foo(@NotNull Function0 block) {
+    Intrinsics.checkParameterIsNotNull(block, "block");
+    String var2 = "before block";
+    System.out.println(var2);
+    block.invoke();
+    var2 = "end block";
+    System.out.println(var2);
+}
+```
+
+果然，foo函数体代码及被调用的Lambda代码都粘贴到了相应调用的位置。试想下，如果这是一个工程中公共的方法，或者被嵌套在一个循环调用的逻辑体中，这个方法势必会被调用很多次。通过inline的语法，我们可以彻底消除这种额外调用，从而节省了开销。
+
+内联函数典型的一个应用场景就是Kotlin的集合类。如果你看过Kotlin的集合类API文档或者源码实现就会发现，集合函数式API，如map、filter都被定义成内联函数，如： 
+
+```kotlin
+inline fun <T, R> Array<out T>.map {
+    transform: (T) -> R
+}: List<R>
+
+inline fun <T> Array<out T>.filter {
+    predicate: (T) -> Boolean
+}: List<T>
+```
+
+这个很容易理解，由于这些方法都接收Lambda作为参数，同时都需要对集合元素进行遍历操作，所以把相应的实现进行内联无疑是非常适合的。
+
+但是内联函数不是万能的，以下情况我们应避免使用内联函数:   
+
+- 由于JVM对普通的函数已经能够根据实际情况智能地判断是否进行内联优化，所以我们并不需要对其使用Kotlin的inline语法，那只会让字节码变得更加复杂。
+- 尽量避免对具有大量函数体的函数进行内联，这样会导致过多的字节码数量。
+- 一旦一个函数被定义为内联函数，便不能获取闭包类的私有成员，除非你把他们声明为internal。
+
+
+
+#### noinline: 避免参数被内联
+
+通过上面的例子我们已经知道，如果在一个函数的开头加上inline修饰符，那么它的函数体及Lambda参数都会被内联。然而现实中的情况比较复杂，有一种可能是函数需要接受多个参数，但我们只想对其中部分Lambda参数内联，其他的则不内联，这个又该如何处理？ 
+
+解决这个问题也很简单，Kotlin在引入inline的同时，也新增了noinline关键字，我们可以把它加在不想要被内联的参数开头，该参数便不会具有内联的效果:  
+
+```kotlin
+fun main(args: Array<String>) {
+    foo ( {
+        println("I am inlined...")	     	
+    }, {
+        println("I am not inlined...")
+    })
+}
+
+inline fun foo(block1: () -> Unit, noinline block2: () -> Unit) {
+    println("before block")
+    block1()
+    block2()
+    println("end block")
+}
+
+```
+
+同样的方法，再来看看反编译的Java版本:  
+
+```java
+public static final void main(@NotNull String[] args) {
+    Intrinsics.checkParameterIsNotNull(args, "args");
+    Function0 block2$iv = (Function0)null.INSTANCE;
+    String var2 = "before block";
+    System.out.println(var2);
+    // block1 被内联了
+    String var3 = "I am inlined...";
+    System.out.println(var3);
+    // block2 还是原样
+    block2$iv.invoke();
+    System.out.println(var2);
+}
+public static final void foo(@NotNull Function0 block1, @NotNull Function0 block2) {
+    Intrinsics.checkParameterIsNotNull(block1, "block1");
+    Intrinsics.checkParameterIsNotNull(block2, "block2");
+    String var3 = "before block";
+    System.out.println(var3);
+    block1.invoke();
+    block2.invoke();
+    var3 = "end block";
+    System.out.println(var3);
+}
+```
+
+可以看出，foo函数的block2参数在带上noinline之后，反编译后的Java代码中并没有将其函数体代码在调用处进行替换。
+
+#### 非局部返回
+
+Kotlin中的内联函数除了优化Lambda开销之外，还带来了其他方面的特效，典型的就是非局部返回和具体化参数类型。我们先来看下Kotlin如何支持非局部返回。 
+
+以下是我们常见的局部返回的例子:  
+
+```kotlin
+fun main(args: Array<String>) {
+    foo()
+}
+fun localReturn() {
+    return
+}
+fun foo() {
+    println("before local return")
+    localReturn()
+    println("after local return")
+    return
+}
+// 运行结果
+before local return
+after local return
+```
+
+正如我们所熟知的，localReturn执行后，其函数体中的return只会在该函数的局部生效，所以localReturn()之后的println函数依旧生效。我们再把这个函数换成Lambda表达式的版本:   
+
+```kotlin
+fun main(args: Array<String>) {
+    foo { return }
+}
+fun foo(returning: () -> Unit) {
+    println("before local return")
+    returning()
+    println("after local return")
+    return 
+}
+// 运行结果
+Error:(2, 11)Kotlin: 'return' is not allowed here
+```
+
+这时，编译器报错了，就是说在Kotlin中，正常情况下Lambda表达式不允许存在return关键字。这时候，内联函数又可以排上用场了。我们把foo进行内联后再试试看:  
+
+```kotlin
+fun main(args: Array<String>) {
+    foo { return }
+}
+inline fun foo(returning: () -> Unit) {
+    println("before local return")
+    returning()
+    println("after local return")
+    return
+}
+// 运行结果
+before local return 
+```
+
+编译顺利通过了，但结果与我们的局部返回效果不同，Lambda的return执行后直接让foo函数退出了执行。如果你仔细考虑一下，可能很快就想出了原因。因为内联函数foo的函数体及参数Lambda会直接替代具体的调用。所以实际产生的代码中，retrurn相当于是直接暴露在main函数中，所以returning()之后的代码自然不会执行，这个就是所谓的非局部返回。
+
+#### 使用标签实现Lambda非局部返回
+
+另外一种等效的方式，是通过标签利用@符号来实现Lambda非局部返回。同样以上的例子，我们可以在不声明inline修饰符的情况下，这么做来实现相同的效果: 
+
+```kotlin
+fun main(args: Array<String>) {
+    foo { return@foo }
+}
+fun foo(returning: () -> Unit) {
+    println("before local return")
+    returning()
+    println("after local return")
+    return
+}
+// 运行结果
+before local return
+```
+
+非局部返回尤其在循环控制中显得特别有用，比如Kotlin的forEach接口，它接收的就是一个Lambda参数，由于它也是一个内联函数，所以我们可以直接在它调用的Lambda中执行return退出上一层的程序。
+
+```kotlin
+fun hasZeros(list: List<Int>): Boolean {
+    list.forEach {
+        if (it == 0) return true // 直接返回foo函数结果
+    }
+    return false
+}
+```
+
+#### crossinline
+
+值得注意的是，非局部返回虽然在某些场合下非常有用，但可能也存在危险。因为有时候，我们内联的函数所接收的Lambda参数常常来自于上下文其他地方。为了避免带有return的Lambda参数产生破坏，我们还可以使用crossinline关键字来修饰该参数，从而杜绝此类问题的发生。就像这样子: 
+
+```kotlin
+fun main(args: Array<String>) {
+    foo { return }
+}
+inline fun foo(crossinline returning: () -> Unit) {
+    println("before local return")
+    returning()
+    println("after local return")
+    return
+}
+// 运行结果
+Error: (2, 11) Kotlin: 'return' is not allowed here
+```
+
+#### 具体化参数类型
+
+除了非局部返回之外，内联函数还可以帮助Kotlin实现具体化参数类型。Kotlin与Java一样，由于运行时的类型擦除，我们并不能直接获取一个参数的类型。然而，由于内联函数会直接在字节码中生成相应的函数体实现，这种情况下我们反而可以获得参数的具体类型。我们可以用reified修饰符来实现这一效果。
+
+```kotlin
+fun main(args: Array<String>) {
+    getType<Int>()
+}
+inline fun <reified T> getType() {
+    print(T::class)
+}
+// 运行结果
+class kotlin.Int
+```
+
+这个特性在Android开发中也格外有用。比如在Java中，当我们要调用startActivity时，通常需要把具体的目标视图类作为一个参数。然而，在Kotlin中，我们可以用reified来进行简化:    
+
+```kotlin
+inline fun <refied T : Activity> Activity.startActivity() {
+    startActivity(Intent(this, T::class.java))
+}
+```
+
+这样，我们进行视图导航就非常容易了，如:  
+
+```kotlin
+startActivity<DetailActivity>()
+```
+
+
+
+
+
+
+
+
+
+[上一篇:Kotlin学习教程(六)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E5%85%AD).md)         
+[下一篇:Kotlin学习教程(八)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E5%85%AB).md)
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md" "b/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md"
new file mode 100644
index 00000000..44f17930
--- /dev/null
+++ "b/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md"
@@ -0,0 +1,554 @@
+Kotlin学习教程(三)
+===
+
+前面介绍了基本语法和编码规范后，接下来学习下基本类型。  
+
+在`Kotlin`中，所有东西都是对象，在这个意义上讲我们可以在任何变量上调用成员函数和属性。 一些类型可以有特殊的内部表示——例如，
+数字、字符和布尔值可以在运行时表示为原生类型值，但是对于用户来说，它们看起来就像普通的类。 在本节中，我们会描述`Kotlin`中使用的基本类型:
+数字、字符、布尔值、数组与字符串。
+
+### 数字  
+
+`Kotlin`处理数字在某种程度上接近`Java`,但是并不完全相同。例如，对于数字没有隐式拓宽转换（如`Java`中`int`可以隐式转换为`long`)，
+另外有些情况的字面值略有不同。
+
+`Kotlin`提供了如下的内置类型来表示数字:    
+
+```
+Type    Bit width
+Double  64
+Float   32
+Long    64
+Int     32
+Short   16
+Byte    8
+````
+
+注意在`Kotlin`中字符不是数字,字符用`Char`类型表示。它们不能直接当作数字
+
+
+### 字面常量
+
+数值常量字面值有以下几种:   
+- 十进制:123
+- `Long`类型用大写`L`标记:`123L`
+- 十六进制:`0x0F`
+- 二进制:`0b00001011`
+
+注意: 不支持八进制
+
+`Kotlin`同样支持浮点数的常规表示方法:   
+
+默认`double`:123.5、123.5e10，`Float`用`f`或者`F`标记:`123.5f`
+
+你可以使用下划线使数字常量更易读
+
+```kotlin
+val oneMillion = 1_000_000
+val creditCardNumber = 1234_5678_9012_3456L
+val socialSecurityNumber = 999_99_9999L
+val hexBytes = 0xFF_EC_DE_5E
+val bytes = 0b11010010_01101001_10010100_10010010
+```
+
+### 显式转换
+
+由于不同的表示方式，较小类型并不是较大类型的子类型。 如果它们是的话，就会出现下述问题：
+
+```kotlin
+// 假想的代码，实际上并不能编译：
+val a: Int? = 1 // 一个装箱的 Int (java.lang.Integer)
+val b: Long? = a // 隐式转换产生一个装箱的 Long (java.lang.Long)
+print(a == b) // 惊！这将输出“false”鉴于 Long 的 equals() 检测其他部分也是 Long
+```
+
+所以同一性还有相等性都会在所有地方悄无声息地失去。
+因此较小的类型不能隐式转换为较大的类型。 这意味着在不进行显式转换的情况下我们不能把`Byte`型值赋给一个`Int`变量。
+
+```kotlin
+val b: Byte = 1 // OK, 字面值是静态检测的
+val i: Int = b // 错误
+```
+
+我们可以显式转换来拓宽数字
+```kotlin
+val i: Int = b.toInt() // OK: 显式拓宽
+```
+
+每个数字类型支持如下的转换:
+
+```kotlin
+toByte(): Byte
+toShort(): Short
+toInt(): Int
+toLong(): Long
+toFloat(): Float
+toDouble(): Double
+toChar(): Char
+```
+
+### 运算
+
+这是完整的位运算列表(只用于`Int`和`Long`):
+
+```kotlin
+shl(bits) – 有符号左移 (Java 的 <<)
+shr(bits) – 有符号右移 (Java 的 >>)
+ushr(bits) – 无符号右移 (Java 的 >>>)
+and(bits) – 位与
+or(bits) – 位或
+xor(bits) – 位异或
+inv() – 位非
+相等性检测：a == b 与 a != b
+比较操作符：a < b、 a > b、 a <= b、 a >= b
+区间实例以及区间检测：a..b、 x in a..b、 x !in a..b
+|| – 短路逻辑或
+&& – 短路逻辑与
+! - 逻辑非
+```
+
+
+### 字符串
+
+字符串用`String`类型表示。字符串是不可变的。字符串的元素——字符可以使用索引运算符访问:`s[i]`。可以用`for`循环迭代字符串:   
+
+```kotlin
+for (c in str) {
+    println(c)
+}
+```
+`Kotlin`有两种类型的字符串字面值: 转义字符串可以有转义字符，以及原生字符串可以包含换行和任意文本。转义字符串很像`Java`字符串:
+```kotlin
+val s = "Hello, world!\n"
+```
+转义采用传统的反斜杠方式。
+
+原生字符串 使用三个引号`"""`分界符括起来，内部没有转义并且可以包含换行和任何其他字符:   
+
+```kotlin
+val text = """
+    for (c in "foo")
+        print(c)
+"""
+```
+你可以通过`trimMargin()`函数去除前导空格:   
+
+```kotlin
+val text = """
+    |Tell me and I forget.
+    |Teach me and I remember.
+    |Involve me and I learn.
+    |(Benjamin Franklin)
+    """.trimMargin()
+```
+
+### 字符串模板
+
+字符串可以包含模板表达式，即一些小段代码，会求值并把结果合并到字符串中。模板表达式以美元符`$`开头，由一个简单的名字构成:  
+
+```kotlin
+val i = 10
+val s = "i = $i" // 求值结果为 "i = 10"
+```
+
+或者用花括号括起来的任意表达式:
+```kotlin
+val s = "abc"
+val str = "$s.length is ${s.length}" // 求值结果为 "abc.length is 3"
+```
+
+### 字符串判等
+
+Kotlin中的判等性主要有两种类型： 
+
+- 结构相等。通过操作符==来判断两个对象的内容是否相等。
+- 引用相等。通过操作符===来判断两个对象的引用是否一样，与之相反的判断操作符是！==。如果比较的是运行时的原始类型，比如Int，那么===判断的效果也等价于==。
+
+```kotlin
+var a = "Java"
+var b = "Java"
+var c = "Kotlin"
+var d = "Kot"
+var e = "lin"
+var f = d + e
+
+a == b // true
+a === b // true
+c == f // true
+c === f // false
+```
+
+
+
+### 引用相等
+
+引用相等由`===`以及其否定形式`!===`操作判断。`a === b`当且仅当`a`和`b`指向同一个对象时求值为`true`。
+
+### 结构相等
+
+结构相等由`==`以及其否定形式`!==`操作判断。按照惯例，像`a == b`这样的表达式会翻译成      
+`a?.equals(b) ?: (b === null)`
+也就是说如果`a`不是`null`则调用`equals(Any?)`函数，否则即`a`是`null`检查`b`是否与`null`引用相等。
+
+```kotlin
+val a: Int = 10000
+print(a === a) // 输出“true”
+val boxedA: Int? = agaomnh
+val anotherBoxedA: Int? = a
+print(boxedA === anotherBoxedA) // ！！！输出“false”！！！
+```
+
+另一方面，它保留了相等性:
+
+```kotlin
+val a: Int = 10000
+print(a == a) // 输出“true”
+val boxedA: Int? = a
+val anotherBoxedA: Int? = a
+print(boxedA == anotherBoxedA) // 输出“true”
+```
+
+
+
+### 修饰符
+
+`Kotlin`中修饰符是与`Java`中的有些不同。在`kotlin`中默认的修饰符是`public`，这节约了很多的时间和字符。
+
+- `private`        
+    `private`修饰符是最限制的修饰符，和`Java`中`private`一样。它表示它只能被自己所在的文件可见。所以如果我们给一个类声明为`private`，
+    我们就不能在定义这个类之外的文件中使用它。
+    另一方面，如果我们在一个类里面使用了private修饰符，那访问权限就被限制在这个类里面了。甚至是继承这个类的子类也不能使用它。
+
+- `protected`.    
+    在Java中是包、类及子类可访问，而在Kotlin中只允许类及子类。
+
+- `internal`
+    它与Java的default有点像但也有所区别。如果是一个定义为`internal`的包成员的话，对所在的整个`module`可见。如果它是一个其它领域的成员，它就需要依赖那个领域的可见性了。
+    比如如果写了一个`private`类，那么它的`internal`修饰的函数的可见性就会限制与它所在的这个类的可见性。
+
+- `public`.   
+    你应该可以才想到，这是最没有限制的修饰符。这是默认的修饰符，成员在任何地方被修饰为public，很明显它只限制于它的领域。
+
+### 数组
+
+数组用类`Array`实现，并且还有一个`size`属性及`get`和`set`方法，由于使用`[]`重载了`get`和`set`方法，所以我们可以通过下标很方便的获取或者
+设置数组对应位置的值。       
+`Kotlin`标准库提供了`arrayOf()`创建数组和`xxArrayOf`创建特定类型数组      
+
+```kotlin
+val array = arrayOf(1, 2, 3)
+val countries = arrayOf("UK", "Germany", "Italy")
+val numbers = intArrayOf(10, 20, 30)
+val array1 = Array(10, { k -> k * k })
+val longArray = emptyArray<Long>()
+val studentArray = Array<Student>(2)
+studentArray[0] = Student("james")
+```
+
+和`Java`不一样的是`Kotlin`的数组是容器类，提供了`ByteArray`,`CharArray`,`ShortArray`,`IntArray`,`LongArray`,`BooleanArray`,
+`FloatArray`和`DoubleArray`。
+
+### 集合 
+
+`Kotlin`的`List<out T>`类型是一个提供只读操作如`size`、`get`等的接口。和`Java`类似，它继承自`Collection<T>`进而继承自`Iterable<T>`。
+改变`list`的方法是由`MutableList<T>`加入的。这一模式同样适用于`Set<out T>/MutableSet<T>`及`Map<K, out V>/MutableMap<K, V>`。
+
+可变集合，顾名思义，就是可以改变的集合。可变集合都会有一个修饰前缀“Mutable”，比如MutableList。这里的改变是指改变集合中的元素，比如以下可变集合: 
+
+```kotlin
+val list = mutableListOf(1, 2, 3, 4, 5)
+list[0] = 0 // 变成[0, 2, 3, 4, 5]
+```
+
+
+
+`Kotlin`没有专门的语法结构创建`list`或`set`。要用标准库的方法如`listOf()`、`mutableListOf()`、`setOf()`、`mutableSetOf()`。
+创建`map`可以用`mapOf(a to b, c to d)`。
+
+```kotlin
+fun main(args : Array<String>) {
+    var lists = listOf("a", "b", "c")
+    for(list in lists) {
+        println(list)
+    }
+}
+```
+
+```kotlin
+fun main(args : Array<String>) {
+    var map = TreeMap<String, String>()
+    map["0"] = "0 haha"
+    map["1"] = "1 haha"
+    map["2"] = "2 haha"
+    
+    println(map["1"])
+}
+```
+
+```kotlin    
+val numbers: MutableList<Int> = mutableListOf(1, 2, 3)
+val readOnlyView: List<Int> = numbers
+println(numbers)        // 输出 "[1, 2, 3]"
+numbers.add(4)
+println(readOnlyView)   // 输出 "[1, 2, 3, 4]"
+readOnlyView.clear()    // -> 不能编译
+
+val strings = hashSetOf("a", "b", "c", "c")
+assert(strings.size == 3)
+```
+
+Kotlin中提供了很多操作结合的函数，例如: 
+
+```kotlin
+val newList = list.map{it * 2} // 对集合遍历，在遍历过程中，给每个元素都乘以2，得到一个新的集合
+
+val mStudents = students.filter{it.sex == "m"} // 筛选出性别为男的学生
+
+val scoreTotal = students.sumBy{it.score} // 拥挤和中的sumby实现求和
+```
+
+#### 通过序列提高效率
+
+```kotlin
+val list = listOf(1, 2, 3, 4, 5)
+list.filter {it > 2}.map {it * 2}
+```
+
+上面的写法很简洁，在处理集合时，类似于上面的操作能够帮助我们解决大部分的问题。但是list中的元素非常多的时候(比如超过10万)，上面的操作在处理集合的时候就会显得比较低效。因为filter方法和map方法都会返回一个新的集合，也就是说上面的操作会产生两个临时集合，因为list会先调用filter方法，然后产生的集合会再次调用map方法。如果list中的元素非常多，这将会是一笔不小的开销。为了解决这一问题，序列(Sequence)就出现了。 
+
+```kotlin
+list.asSequence().filter {it > 2}.map {it * 2}.toList()
+```
+
+首先通过asSequence方法将一个列表转换为序列，然后在这个序列上进行相应的操作，最后通过toList方法将序列转为列表。将list转换为序列，在很大程度上就提高了上面操作集合的效率。因为在使用序列的时候filter方法和map方法的操作都没有创建额外的集合，这样当集合中的元素数量巨大的时候，就减少了大部分开销。在Kotlin中，序列中元素的求值是惰性的，这就意味着在利用序列进行链式求值的时候，不需要像操作普通集合那样，每进行一次求值操作，就产生一个新的集合保存中间数据。那么什么惰性又是什么意思呢？
+
+在编程语言理论中，惰性求值(Lazy Evaluation)表示一种在需要时才进行求值的计算方式。在使用惰性求值的时候，表达式不在它被绑定到变量之后就立即求值，而是在该值被取用时才去求值。通过这种方式，不仅能得到性能上的提升，还有一个重要的好处就是它可以构造出一个无限的数据类型。
+
+
+
+#### 序列的操作方式
+
+```kotlin
+list.asSequence().filter {it > 2}.map {it * 2}.toList()
+```
+
+在这个例子中，我们序列总共执行了两类操作分别是: 
+
+- `filter{it > 2}.map{it * 2}`:filter和map的操作返回的都是序列，我们将这类操作称为中间操作。
+- `toList()`:这一类操作将序列转换为List，我们将这类操作称为末端操作。
+
+其实，Kotlin中序列的操作就分为两类： 
+
+- 中间操作
+
+    中间操作都是采用惰性求值的，例如: 
+
+    ```kotlin
+    list.asSequence().filter {
+        println("filter($it)")
+    }.map {
+        println("map($it)")
+    }
+    ```
+
+    上面操作中的println方法根本没有被执行，这说明filter和map方法的执行被延迟了，这就是惰性求值的体现。惰性求值也被称为延迟求值，通过前面的定义我们知道，惰性求值仅仅在该值被需要的时候才会真正去求值。那么这个”被需要“的状态怎么去触发呢？这就需要另外一个操作了-末端操作。
+
+- 末端操作
+
+    在对集合进行操作的时候，大部分情况下，我们在意的只是结果，而不是中间过程。末端操作就是一个返回结果的操作，它的返回值不能是序列，必须是一个明确的结果，比如列表、数字、对象等表意明确的结果。末端操作一般都放在链式操作的末尾，在执行末端操作的时候，会去触发中间操作的延迟计算，也就是将”被需要“这个状态打开了，我们给上面的例子加上末端操作: 
+
+    ```kotlin
+    list.asSequence().filter {
+        println("filter($it)")
+        it > 2
+    }.map {
+        println("map($it)")
+        it * 2
+    }.toList()
+    // 结果
+    filter(1)
+    filter(2)
+    filter(3)
+    map(3)
+    filter(4)
+    map(4)
+    filter(5)
+    map(5)
+    [6, 8, 10]
+    ```
+
+    可以看到，所有的中间操作都被执行了。从上面执行打印的结果我们发现，它的执行顺序与我们预想的不一样。普通集合在进行链式操作的时候会先在list上调用filter，然后产生一个结果列表，接下来map就在这个结果列表上进行操作。而序列则不一样，序列在执行链式操作的时候，会将所有的操作都应用在一个元素上，也就是说，第一个元素执行完所有的操作之后，第二个元素再去执行所有的操作，以此类推。放映到我们这个例子上面，就是第一个元素执行了filter之后再去执行map，然后第二个元素也是这样。
+
+#### 序列可以是无限的
+
+在介绍惰性求值的时候，我们提过一点，就是惰性求值最大的好处是可以构造出一个无限的数据类型。那么我们能否使用序列来构造出一个无限的数据类型呢？答案是肯定的。
+
+那接下来，该怎么去实现一个自然数数列呢？采用一般的列表肯定是不行的，因为构造一个列表必须列举出列表中的元素，而我们是没有办法将自然数全部列举出来的。 
+
+我们知道，自然数是有一定规律的，就是最后一个数永远是前一个数加1的结果，我们只需要实现一个列表，让这个列表描述这种规律，那么也就相当于实现了一个无限的自然数数列。好看Kotlin也给我们提供了这样一个方法，去创建无限的数列： 
+
+```kotlin
+val naturalNumList = generateSequence(0) { it + 1}
+```
+
+通过上面这一行代码，我们就非常简单的实现了自然数数列，上面我们调用了一个方法generateSequence来创建序列。我们知道序列是惰性求值的，所以上面创建的序列是不会把所有的自然数都列举出来的，只有在我们调用一个末端操作的时候，才去列举我们所需要的列表。比如我们要从这个自然数列表中取出前10个自然数：  
+
+```kotlin
+naturalNumList.takeWhile{it <= 9}.toList()
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+```
+
+
+
+
+
+### 可`null`类型
+
+
+因为在`Kotlin`中一切都是对象，一切都是可`null`的。当某个变量的值可以为`null`的时候，必须在声明处的类型后添加`?`来标识该引用可为空。
+`Kotlin`通过`?`将是否允许为空分割开来，比如`str:String`为不能空，加上`?`后的`str:String?`为允许空，通过这种方式，将本是不能确定的变
+量人为的加入了限制条件。而不符合条件的输入，则会在`IDE`上显示编译错误而无法执行。
+
+```kotlin
+var value1: String
+value1 = null        // 编译错误 Null can not be a value of a non-null type String
+
+var value2 : String? 
+value2 = null       // 编译通过
+```
+
+在对变量进行操作时，如果变量是可能为空的，那么将不能直接调用，因为编译器不知道你的变量是否为空，所以编译器就要求你一定要对变量进行判断
+
+```kotlin
+var str : String? = null
+// 编译错误 Only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable receiver of type String?
+str.length    
+// 编译能通过，这表示如果str不为空的时候执行length方法
+str?.length   
+```
+
+那么问题来了，我们知道在`java`中`String.length`返回的是`int`，上面的`str?.length`既然编译通过了，那么它返回了什么？我们可以这么写:  
+
+`var result = str?.length`
+
+这么写编译器是能通过的，那么`result`的类型是什么呢？在`Kotlin`中，编译器会自动根据结果判断变量的类型，翻译成普通代码如下:   
+
+```kotlin
+if(str == null)
+    result = null;            // 这里result为一个引用类型
+else
+    result = str.length;    // 这里result为Int
+```
+
+那么如果我们需要的就是一个`Int`的结果(事实上大部分情况都是如此)，那又该怎么办呢？在`kotlin`中除了`?`表示可为空以外，还有一个新的符号`:`双
+感叹号`!!`，表示一定不能为空。所以上面的例子，如果要对`result`进行操作，可以这么写:  
+
+```kotlin
+var str : String? = null
+var result : Int = str!!.length
+```
+
+这样的话，就能保证`result`的数据类型，但是这样还有一个问题，那就是`str`的定义是可为空的，上面的代码中，`str`就是空，这时候下面的操作虽然
+不会报编译异常，但是运行时就会见到我们熟悉的空指针异常`NullPointerExectpion`，这显然不是我们希望见到的，也不是`kotlin`愿意见到的。
+`java`中的三元操作符大家应该都很熟悉了，`kotlin`中也有类似的，它很好的解决了刚刚说到的问题。在`kotlin`中，三元操作符是`?:`，写起来也
+比`java`要方便一些。
+
+```kotlin
+var str : String? = null
+var result = str?.length ?: -1
+//等价于
+var result : Int = if(str != null) str.length else -1
+```
+
+`if null`缩写
+
+```kotlin
+val data = ……
+val email = data["email"] ?: throw IllegalStateException("Email is missing!")
+```
+
+如果`?:`左侧表达式非空，`elvis`操作符就返回其左侧表达式，否则返回右侧表达式。
+请注意，当且仅当左侧为空时，才会对右侧表达式求值。
+
+
+##### `!!`操作符
+
+我们可以写`b!!`，这会返回一个非空的`b`值
+(例如:在我们例子中的`String`)或者如果`b`为空，就会抛出一个空指针异常:     
+
+```kotlin
+val l = b!!.length
+```
+
+因此，如果你想要一个 NPE，你可以得到它，但是你必须显式要求它，否则它不会不期而至。
+
+
+#### 安全的类型转换
+
+如果对象不是目标类型，那么常规类型转换可能会导致`ClassCastException`。
+另一个选择是使用安全的类型转换，如果尝试转换不成功则返回`null{: .keyword }`:    
+
+```kotlin
+val aInt: Int? = a as? Int
+```
+
+#### 可空类型的集合
+
+如果你有一个可空类型元素的集合，并且想要过滤非空元素，你可以使用`filterNotNull`来实现。
+
+```kotlin
+val nullableList: List<Int?> = listOf(1, 2, null, 4)
+val intList: List<Int> = nullableList.filterNotNull()
+```
+
+
+
+### 使用类型检测及自动类型转换
+
+`is`运算符检测一个表达式是否某类型的一个实例。 如果一个不可变的局部变量或属性已经判断出为某类型，那么检测后的分支中可以直接当作该类型使用，
+无需显式转换:   
+
+```kotlin
+fun getStringLength(obj: Any): Int? {
+    if (obj !is String) return null
+
+    // `obj` 在这一分支自动转换为 `String`，这是因为Kotlin的编译器帮我们做了转换
+    // 这称为Kotlin中的智能转换(Smart Casts)。官方文档中这样介绍: 当且仅当Kotlin的编译器
+    // 确定在类型检查后该变量不会再改变，才会产生Smart Casts。
+    return obj.length
+}
+```
+
+### 返回和跳转
+
+`Kotlin`有三种结构化跳转表达式:    
+
+- `return`:默认从最直接包围它的函数或者匿名函数返回。
+- `break`:终止最直接包围它的循环。
+- `continue`:继续下一次最直接包围它的循环。
+
+在`Kotlin`中任何表达式都可以用标签`label`来标记。标签的格式为标识符后跟`@`符号，例如:`abc@`、`fooBar@`都是有效的标签。
+
+要为一个表达式加标签，我们只要在其前加标签即可。
+
+```kotlin
+loop@ for (i in 1..100) {
+    for (j in 1..100) {
+        if (……) break@loop
+    }
+}
+```
+
+
+
+
+
+[上一篇:Kotlin学习教程(二)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%BA%8C).md)         
+[下一篇:Kotlin学习教程(四)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E5%9B%9B).md)
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
diff --git "a/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md" "b/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md"
new file mode 100644
index 00000000..43178b4e
--- /dev/null
+++ "b/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md"
@@ -0,0 +1,224 @@
+Kotlin学习教程(四)
+===
+
+## `if`表达式
+
+在`Kotlin`中，`if`是一个表达式，即它会返回一个值。因此就不需要三元运算符`条件 ? 然后 : 否则`，因为普通的`if`就能胜任这个角色。
+`if`的分支可以是代码块，最后的表达式作为该块的值:   
+
+```kotlin
+val max = if (a > b) {
+    print("Choose a")
+    a
+} else {
+    print("Choose b")
+    b
+}
+```
+
+## `when`表达式
+
+`when`表达式与`Java`中的`switch/case`类似，但是要强大得多。这个表达式会去试图匹配所有可能的分支直到找到满意的一项。然后它会运行右边的表达
+式。      
+与`Java`的`switch/case`不同之处是参数可以是任何类型，并且分支也可以是一个条件。
+
+对于默认的选项，我们可以增加一个`else`分支，它会在前面没有任何条件匹配时再执行。条件匹配成功后执行的代码也可以是代码块:     
+```kotlin
+when (x){
+    1 -> print("x == 1") 
+    2 -> print("x == 2") 
+    else -> {
+        print("I'm a block")
+        print("x is neither 1 nor 2")
+    }
+}
+```
+
+因为它是一个表达式，它也可以返回一个值。我们需要考虑什么时候作为一个表达式使用，它必须要覆盖所有分支的可能性或者实现`else`分支。否则它不会被
+编译成功:   
+
+```kotlin
+val result = when (x) {
+    0, 1 -> "binary"
+    else -> "error"
+}
+```
+
+如你所见，条件可以是一系列被逗号分割的值。但是它可以更多的匹配方式。比如，我们可以检测参数类型并进行判断:  
+
+```kotlin
+when(view) {
+    is TextView -> view.setText("I'm a TextView")
+    is EditText -> toast("EditText value: ${view.getText()}")
+    is ViewGroup -> toast("Number of children: ${view.getChildCount()} ")
+    else -> view.visibility = View.GONE
+}
+```
+
+### 示例：when对if else的改造
+
+```kotlin
+fun schedule(day: Day, sunny: Boolean) = {
+    if (day == Day.SAT) {
+        basketball()
+    } else if (day == Day.SUN) {
+        fishing()
+    } else if (day == Day.FRI) {
+        appointment()
+    } else {
+        if (sunny) {
+            library()
+        } else {
+            study()
+        }
+    }
+}
+```
+
+上面的例子中因为存在不少if else分支，代码显得不够优雅，更好的改进方法是用when表达式来优化:  
+
+```kotlin
+fun schedule(sunny: Boolean, day: Day) = when (day) {
+    Day.SAT -> basketball()
+    Day.SUN -> fishing()
+    Day.FRI -> appointment()
+    else -> when {
+        // when关键字的参数可以省略
+        sunny -> library()
+        else -> study()
+    }
+}
+```
+
+一个完整的when表达式类似switch语句，由when关键字开始，用花括号包含多个逻辑分支，每个分支由-> 连接，不再需要switch的break(这真是一个恼人的关键字)，由上往下匹配，一直匹配完为止，否则执行else分支的逻辑，类似switch的default。
+
+到这里你可能会说上面的例子中，这样嵌套子when表达式，层次依旧比较深。要知道when表达式是很灵活的，我们很容易通过如下修改来解决这个问题:  
+
+```kotlin
+fun schedule(sunny: Boolean, day: Day) = when {
+    day == Day.SAT -> basketball()
+    day == Day.SUN -> fishing()
+    day == Day.FRI -> appointment()
+    sunny -> library()
+    else -> study()
+}
+```
+
+这样就会更优雅了。
+
+## for循环
+
+```kotlin
+val items = listOf("apple", "banana", "kiwi")
+for (item in items) {
+    println(item)
+}
+
+for (i in array.indices)
+    print(array[i])
+```
+
+在Kotlin中用in关键字来检查一个元素是否是一个区间或集合中的成员。如果我们在in前面加上感叹号，那么就是相反的判断结果。
+
+### Ranges
+
+`Range`表达式使用一个`..`操作符。表示就是一个该范围内的数据的数组，包含头和尾
+
+```kotlin
+var nums = 1..100 
+for(num in nums) {
+	println(num)
+	// 打印出1 2 3 ....100
+}
+```
+
+```kotlin
+if(i >= 0 && i <= 10) 
+    println(i)
+```
+
+转换成 
+
+```kotlin
+if (i in 0..10) 
+    println(i)
+```
+
+Ranges默认会自增长，所以如果像以下的代码：
+
+```kotlin
+for (i in 10..0)
+    println(i)
+```
+
+它就不会做任何事情。但是你可以使用`downTo`函数：
+
+```kotlin
+for(i in 10 downTo 0)
+    println(i)
+```
+
+我们可以在`Ranges`中使用`step`来定义一个从`1`到一个值的不同的空隙:   
+
+```kotlin
+for (i in 1..4 step 2) println(i)
+for (i in 4 downTo 1 step 2) println(i)
+```
+
+### Until
+
+上面的`Range`是包含了头和尾，那如果只想包含头不包含尾呢？ 就要用`until`
+
+```kotlin
+var nums = 1 until 100
+for(num in nums) {
+	println(num)
+	// 这样打印出来是1 2 3 .....99
+}
+```
+
+
+
+上面in、step、downTo、until这几个，他们可以不通过点号，而是通过中缀表达式来被调用，从而让语法变得更加简洁直观。
+
+
+
+### `Kotlin`用到的关键字
+
+- `var`：定义变量
+- `val`：定义常量
+- `fun`：定义方法
+- `Unit`：默认方法返回值，类似于`Java`中的`void`，可以理解成返回没什么用的值
+- `vararg`：可变参数
+- `$`：字符串模板(取值)
+- 位运算符：`or`(按位或)，`and`(按位与)，`shl`(有符号左移)，`shr`(有符号右移)，
+- `ushr`(无符号右移)，`xor`(按位异或)，`inv`(按位取反)
+- `in`：在某个范围中 检查值是否在或不在(`in/!in`)范围内或集合中
+- `downTo`：递减，循环时可用，每次减1
+- `step`:步长，循环时可用，设置每次循环的增加或减少的量
+- `when`:`Kotlin`中增强版的`switch`，可以匹配值，范围，类型与参数
+- `is`：判断类型用，类似于`Java`中的`instanceof()`，`is`运算符检查表达式是否是类型的实例。 如果一个不可变的局部变量或属性是指定类型，
+    则不需要显式转换
+- `private`仅在同一个文件中可见
+- `protected`同一个文件中或子类可见
+- `public`所有调用的地方都可见
+- `internal`同一个模块中可见
+- `abstract`抽象类标示
+- `final`标示类不可继承，默认属性
+- `enum`标示类为枚举
+- `open`类可继承，类默认是`final`的
+- `annotation`注解类
+- `init`主构造函数不能包含任何的代码。初始化的代码可以放到以`init`关键字作为前缀的初始化块(`initializer blocks`)中
+- `field`只能用在属性的访问器内。特别注意的是，`get set`方法中只能能使用`filed`。属性访问器就是`get set`方法。
+- `:`用于类的继承，变量的定义 
+- `..`围操作符(递增的) `1..5`，`2..6`千万不要`6..2`
+- `::`作用域限定符
+- `inner`类可以标记为`inner {: .keyword }`以便能够访问外部类的成员。内部类会带有一个对外部类的对象的引用
+- `object`对象声明并且它总是在`object{: .keyword }`关键字后跟一个名称。对象表达式：在要创建一个继承自某个(或某些)类型的匿名类的对象会
+    用到
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
diff --git "a/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\344\272\224).md" "b/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
similarity index 62%
rename from "KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\344\272\224).md"
rename to "KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
index 8f1e87bb..4bcc58cc 100644
--- "a/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\344\272\224).md"
+++ "b/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
@@ -95,9 +95,15 @@ val outter = Outter()
 outter.Inner().execute()
 ```
 
+#### 内部类vs嵌套类
 
+在Java中，我们通过在内部类的语法上增加一个static关键词，把它变成一个嵌套类。然而，Kotlin则是相反的思路，默认是一个嵌套类，必须加上inner关键字才是一个内部类，也就是说可以把静态的内部类看成嵌套类。
 
-匿名内部类
+内部类和嵌套类有明显的差别，具体体现在：内部类包含着对其外部类实例的引用，在内部类中我们可以使用外部类中的属性。而在嵌套类中不包含对其外部类实例的引用，所以它无法调用其外部类的属性。
+
+
+
+#### 匿名内部类
 
 ```kotlin
 // 通过对象表达式来 创建匿名内部类的对象，可以避免重写抽象类的子类和接口的实现类，这和Java中匿名内部类的是接口和抽象类的延伸一致。
@@ -124,8 +130,9 @@ mViewPager.addOnPageChangeListener(object : ViewPager.OnPageChangeListener {
 })
 ```
 
+### 枚举
 
-### 枚举    
+与Java中的enum语法大体类似，无非多了一个class关键字，表示它是一个枚举类。
 
 ```kotlin
 enum class Day {
@@ -133,16 +140,23 @@ enum class Day {
     THURSDAY, FRIDAY, SATURDAY
 }
 ```
-枚举可以带参数:   
+不过Kotlin中的枚举类当然没有那么简单，由于它是一种类，我们可以猜测它自然应该可以拥有构造函数，以及定义额外的属性和方法。
 
 ```kotlin
-enum class Icon(val res: Int) {
-    UP(R.drawable.ic_up),
-    SEARCH(R.drawable.ic_search),
-    CAST(R.drawable.ic_cast)
+enum class DayOfWeek(val day: Int) {
+	MON(1),
+    TUE(2),
+    WEN(3),
+    THU(4),
+    FRI(5),
+    SAT(6),
+    SUN(7)
+    ; // 需要注意的是，当在枚举类中存在额外的方法或或属性定义，则必须强制加上分号，虽然你可能不会喜欢这个语法
+    fun getDayNumber(): Int {
+        return day
+    }
 }
 
-val searchIconRes = Icon.SEARCH.res
 ```
 枚举可以通过`String`匹配名字来获取，我们也可以获取包含所有枚举的`Array`，所以我们可以遍历它。
 ```kotlin
@@ -157,6 +171,42 @@ val searchPosition: Int = Icon.SEARCH.ordinal()
 
 ### 密封类     
 
+Kotlin除了可以利用final来限制类的继承之外，还可以通过密封类的语法来限制一个类的继承，比如: 
+
+```kotlin
+sealed class Bird {
+    open fun fly() = "I can fly"
+    class Eagle : Bird()
+}
+```
+
+Kotlin通过sealed关键字来修饰一个类为密封类，若要继承则需要将子类定义在同一个文件中，其他文件中的类将无法继承他。但这种方式也有它的局限性。即它不能被初始化，因为它背后是基于一个抽象类实现的，这一点可以从它转换后的Java代码看出:  
+
+```java
+public abstract class Bird {
+    @NotNull
+    public String fly() {
+        return "I can fly"
+    }
+    private Bird() {
+        
+    }
+    // $FF: synthetic method
+    public Bird(DefaultConstructorMarker $constructor_maker) {
+        this();
+    }
+    
+    public static final class Eagle extends Bird {
+        public Eagle() {
+            super((DefaultConstructorMarker) null);
+        }
+    }
+}
+
+```
+
+
+
 密封类用来表示受限的类继承结构:当一个值为有限集中的
 类型、而不能有任何其他类型时。在某种意义上，他们是枚举类的扩展:枚举类型的值集合
 也是受限的，但每个枚举常量只存在一个实例，而密封类
@@ -229,8 +279,103 @@ val s = try { x as String } catch(e: ClassCastException) { null }
 
 ### 对象`(Object)`
 
+在Java中，static是非常重要的特性，它可以用来修饰类、方法或属性。然而static修饰的内容都属于类的，而不是某个具体对象的，但在定义时却与普通的变量和方法混杂在一起，显得格格不入。 
+
+在Kotlin中，你将告别static这种语法，因为它引入了全新的关键字object，可以完美的代替使用static的所有场景。当然除了代替static的场景之外，它还能实现更多的功能，比如单例对象及简化匿名表达式等。 
+
+#### 伴生对象
+
+先看一个Java例子:  
+
+```java
+public class Prize {
+    private String name;
+    private int count;
+    private int type;
+    
+    public Prize(String name, int count, int type) {
+        this.name = name;
+        this.count = count;
+        this.type = type;
+    }
+    
+    static int TYPE_REDPACK = 0;
+    static int TYPE_COUPON = 1;
+    
+    static boolean isRedpack(Prize prize) {
+        return prize.type == TYPE_REDPACK;
+    }
+    
+    public static void main(String[] args) {
+        Prize prize = new Prize("hongbao", 10, Prize.TYPE_REDPACK);
+        System.out.println(Prize.isRedpack(prize));
+    }
+}
+```
+
+上面是很常见的Java代码，也许你已经习惯了，但是如果仔细思考，会发现这种语法其实并不是非常好。因为在一个类中既有静态变量、静态方法，也有普通变量、普通方法的声明。然而，静态变量和静态方法是属于一个类的，普通变量、普通方法是属于一个具体对象的。虽然有static作为区分，然而在代码结构上职能并不是区分得很清晰。 
+
+那么，有没有一种方式能将这两部分代码清晰的分开，但又不失语义化呢？Kotlin中引入了伴生对象的概念，简单来说，这是一种利用companion object两个关键字创造的语法。 
+
+伴生对象：“伴生”是相较于一个类而言的，意为伴随某个类的对象，它属于这个类所有，因此伴生对象跟Java中static修饰效果性质一样，全局只有一个单例。它需要声明在类的内部，在类被装载时会被初始化。 
+
+现在将上面的例子改写成伴生对象的版本:   
+
+```kotlin
+class Prize(val name: String, val count: Int, val type: Int) {
+    companion object {
+        val TYPE_REDPACK = 0
+        val TYPE_COUPON = 1
+        
+        fun isRedpack(prize: Prize): Boolean {
+            return prize.type == TYPE_REDPACK
+        }
+    }
+    
+    fun main(args: Array<String>) {
+        val prize = Prize("hongbao", 10, Prize.TYPE_REDPACK)
+        print(Prize.isRedpack(prize))
+    }
+}
+```
+
+可以发现，该版本在语义上更清晰了。而且，companion object用花括号包裹了所有静态属性和方法，使得它可以与Prize类的普通方法和属性清晰的区分开来。最后，我们可以使用点号来对一个类的静态的成员进行调用。  
+
+伴生对象的另一个作用是可以实现工厂方法模式。前面也说过如何从构造方法实现工厂方法模式，然而这种方法存在以下缺点:  
+
+- 利用多个构造方法语义不够明确，只能靠参数区分
+- 每次获取对象时都需要重新创建对象
+
+你会发现，伴生对象也是实现工厂方法模式的另一种思路，可以改进以上的两个问题。 
+
+```kotlin
+class Prize private constructor(val name: String, val count: Int, val type: Int) {
+    companion object {
+        val TYPE_COMMON = 1
+        val TYPE_REDPACK = 2
+        val TYPE_COUPON = 3
+        
+        val defaultCommonPrize = Prize("common", 10, Prize.TYPE_COMMON) 
+        
+        fun newRedpackPrize(name: String, count: int) = Prize(name, count, Prize.TYPE_REDPACK)
+        fun newCouponPrize(name: String, count: Int) = Prize(name, count, Prize.TYPE_COUPON)
+        fun defaultCommonPrize() = defaultCommonPrize // 无须构造新对象
+    }
+    
+    fun main(args: Array<String>) {
+        val redpackPrize = Prize.newRedpackPrize("hongbao", 10)
+        val couponPrize = Prize.newCouponPrize("shiyuan", 10)
+        vval commonPrize = Prize.defaultCommonPrize()
+    }
+}
+```
+
+总的来说，伴生对象是Kotlin中用来代替static关键字的一种方式，任何在Java类内部用static定义的内容都可以用Kotlin中的伴生对象来实现。然而，他们是类似的，一个类的伴生对象跟一个静态类一样，全局只能有一个。
+
+
+
 声明对象就如同声明一个类，你只需要用保留字`object`替代`class`，其他都相同。只需要考虑到对象不能有构造函数，因为我们不调用任何构造函数来访问
-它们。事实上，对象就是具有单一实现的数据类型。    
+它们。事实上，对象就是具有单一实现的数据类型。object声明的内容可以看成没有构造方法的类，它会在系统或者类加载时进行初始化。
 
 ```kotlin
 object Resource {
@@ -240,14 +385,59 @@ object Resource {
 
 ### 单例
 
+因为一个类的伴生对象跟一个静态类一样，全局只能有一个。这让我们联想到了什么？ 没错，就是单例对象。
+
 ```kotlin
 object Resource {
     val name = "Name"
 }
 ```
 
-因为对象就是具有单一实现的数据类型，所以在`kotlin`中对象就是单例。   
-对象的实例在我们第一次使用时，被创建。所以这里有一个懒惰实例化:如果一个对象永远不会被使用，这个实例永远不会被创建。
+因为对象就是具有单一实现的数据类型，所以在`kotlin`中对象就是单例。   单例对象会在系统加载的时候初始化，当然全局只有一个，所以它是饿汉式的单例。
+
+看一下自动生成的java代码: 
+
+```java
+public final class SingleTon {
+   @NotNull
+   private static String name;
+   @NotNull
+   public static final SingleTon INSTANCE;
+
+   @NotNull
+   public final String getName() {
+      return name;
+   }
+
+   public final void setName(@NotNull String var1) {
+      Intrinsics.checkNotNullParameter(var1, "<set-?>");
+      name = var1;
+   }
+
+   private SingleTon() {
+   }
+
+   static {
+      SingleTon var0 = new SingleTon();
+      INSTANCE = var0;
+      name = "";
+   }
+}
+```
+
+这里官网中对object的介绍是: object declarations are initialized lazily, when accessed for the first time
+
+为什么上面说它是饿汉式？ 这个从上面反编译的代码可以看到确实有一个static的静态代码块，静态代码块具有懒惰加载特性，但它这个是加载特性，并不是我们说的: 
+
+```java
+public static Instance getInstance() {
+    if (instance == null) {
+        instance = new Instance();
+    }
+}
+```
+
+具体可以看: [Kotlin Object Declarations Are Initialized in Static Block](https://hanru-yeh.medium.com/kotlin-object-declarations-are-initialized-in-static-block-5e1c2e1c3401)
 
 ### 对象表达式
 
@@ -267,6 +457,10 @@ recycler.adapter = object : RecyclerView.Adapter() {
 ```
 例如，每次想要创建一个接口的内联实现，或者扩展另一个类时，你将使用上面的符号。
 
+object表达式和匿名内部类很像，那对象表达式与Lambda表达式哪个更适合代替匿名内部类呢？  当你的匿名内部类使用的类接口只需要实现一个方法时，使用Lambda表达式更适合。当匿名内部类内有多个方法实现的时候，使用object表达式更适合。
+
+
+
 
 ### 伴生对象`(Companion Object)`
 
diff --git "a/KotlinCourse/6.Kotlin_\345\244\232\347\273\247\346\211\277\351\227\256\351\242\230.md" "b/KotlinCourse/6.Kotlin_\345\244\232\347\273\247\346\211\277\351\227\256\351\242\230.md"
new file mode 100644
index 00000000..7017a62f
--- /dev/null
+++ "b/KotlinCourse/6.Kotlin_\345\244\232\347\273\247\346\211\277\351\227\256\351\242\230.md"
@@ -0,0 +1,211 @@
+Kotlin学习教程之多继承问题
+===
+
+
+
+继承和实现是面向对象程序设计中不变的主题。Java是不支持类的多继承的，Kotlin亦是如此。我们他们要这样设计呢？ 现实中，其实多继承的需求经常会出现，然而类的多继承方式会导致进程关系上语义的混淆。
+
+
+
+### 骡子的多继承困惑
+
+如果你了解C++，应该知道C++中的类是支持多重继承机制的。然而，C++中存在一个经典的钻石问题--骡子的多继承困惑。我们假设Java的类也支持多继承，然后模仿C++中类似的语法，来看看它到底会导致什么问题： 
+
+```java
+abstract class Animal {
+    abstract public void run();
+}
+class Horse extends Animal {
+    @Override
+    public void run() {
+        System.out.println("I am run very fast");
+    }
+}
+class Donkey extends Animal {
+     @Override
+    public void run() {
+        System.out.println("I am run very slow");
+    }
+}
+class Mule extends Horse, Donkey {
+    // 骡子
+    ...
+}
+```
+
+这是一段伪代码，这段代码的含义是: 
+
+- 马和驴都继承了Animal类，并实现了Animal中的run抽象方法。
+- 骡子是马和驴的杂交产物，它拥有两者的特性，于是Mule利用多继承同时继承了Horse和Donkey
+
+目前看起来没有问题，然而当我们打算在Mule中实现run方法的时候，问题就产生了：Mule到底是继承Horse的run方法还是Donkey的run方法？这个就是经典的钻石问题。 
+
+![image-20210325104002353](https://raw.githubusercontent.com/CharonChui/Pictures/master/mule_problem.png?raw=true)
+
+所以钻石问题也被称为棱形继承问题。可以发现，类的多继承如果使用不当，就会在继承关系上产生歧义。而且，多继承还会给代码维护带来很多困扰：一来代码的耦合度会提高，二来各种类之间的关系令人眼花缭乱。 
+
+于是Kotlin和Java一样只支持类的单继承。那么面对多继承的需求，在Kotlin中该如何解决呢？ 
+
+
+
+#### 接口实现多继承
+
+接口支持多实现，所以一个类可以实现多个接口，这是Java经常干的事。Kotlin的接口与Java和类似，但它除了可以定义带默认实现的方法之外，还可以声明抽象的属性。下面就是用Kotlin中的接口来实现多继承:  
+
+```kotlin
+interface Flyer {
+    fun fly()
+    fun kind() = "flying animals"
+}
+interface Animal {
+    val name: String 
+    fun eat()
+    fun kind() = "flying animals"
+}
+
+class Bird(override val name: String) : Flyer, Animal {
+    override fun eat() {
+        println("I can eat")
+    }
+    override fun fly() {
+        println("I can fly")
+    }
+    override fun kind() = super<Flyer>.kind()
+}
+
+fun main(args: Array<String) {
+    val bird = Bird("sparrow")
+    println(bird.kind())
+}
+// 运行结果
+flying animals
+```
+
+上面Bird类同时实现了Flyer和Animal两个接口，但由于它们都拥有默认的kind方法，同样会引起上面所说的钻石问题。而Kotlin提供了对应的方式来解决这个问题，那就是super关键字，我们可以利用它来指定继承哪个父类接口的方法，比如上面代码中的super<Flyer>.kind()。当然我们也可以主动实现方法，覆盖父接口的方法。如:  
+
+```kotlin
+override fun kind() = "a flying ${this.name}"
+// 最终的执行结果就是
+a flying sparrow
+```
+
+通过这个例子，可以看出实现接口的语法: 
+
+- 在Kotlin中实现一个接口时，需要实现接口中没有默认实现的方法及未初始化的属性，若同时实现多个接口，而接口间又有相同方法名的默认实现时，则需要主动指定使用哪个接口的方法或者重写方法。
+- 如果是默认的接口方法，你可以在实现类中通过super<T>这种方式调用它，其中T为拥有该方法的接口名。
+- 在实现接口的属性和方法时，都必须带上override关键字，不能省略。
+
+#### 内部类解决多继承问题
+
+在Java中可以将一个类的定义放在另一个类的定义内部，这就是内部类。由于内部类可以继承一个与外部无关的类，所以这保证了内部类的独立性，可以用它这个特性来尝试解决多继承的问题。 
+
+```kotlin
+open class Horse {
+    fun runFast() {
+        println("I can run fast")
+    }
+}
+open class Donkey {
+    fun doLongTimeThing() {
+        println("I can do some thing long time")
+    }
+}
+class Mule {
+    fun runFast() {
+        HorseC().runFast()
+    }
+    fun doLongTimeThing() {
+        DonkeyC().doLongTimeThing()
+    }
+    
+    private inner class HorseC : Horse()
+    private inner class DonkeyC : Donkey()
+}
+```
+
+上面的例子可以看到:  
+
+- 可以在一个类的内部定义多个内部类，每个内部类的实例都有自己的独立状态，它们与外部对象的信息相互独立。
+- 通过让内部类HorseC、DonkeyC分别继承Horse和Donkey这两个外部类，我们可以在Mule类中定义它们的实例对象，从而获得了Horse和Donkey两者不同的状态和行为。
+- 可以利用private修饰内部类，使得其他类都不能访问内部类，这样可以具有非常良好的封闭性。
+
+所以在某些场合下，内部类确实是一种解决多继承非常好的思路。 
+
+
+
+#### 使用委托代替多继承
+
+委托是一种特殊的类型，用于方法事件委托，比如你调用A类的methodA方法，其实背后是B类的methodA去执行。 
+
+印象中，要实现委托并不是一件非常自然直观的事情。但庆幸的是，Kotlin简化了这种语法，我们只需要通过by关键字就可以实现委托的效果。比如之前提过的by lazy语法，其实就是利用委托实现的延迟初始化语法。
+
+```kotlin
+val laziness: String by lazy {
+    println("I will hava a value")
+    "I an a lazy initialized string"
+}
+```
+
+下面通过委托来替代多继承实现需求:  
+
+```kotlin
+interface CanFly {
+    fun fly()
+}
+interface CanEat {
+    fun eat()
+}
+
+open class Flyer : CanFly {
+    override fun fly() {
+        println("I can fly")
+    }
+}
+open class Animal : CanEat {
+    override fun eat() {
+        println("I can eat")
+    }
+}
+class Bird(flyer: Flyer, animal: Animal) : CanFly by flyer, CanEat by animal {}
+
+fun main(args: Array<String>) {
+    val flyer = Flyer()
+    val animal = Animal()
+    val b = Bird(flyer, animal)
+    b.fly()
+    b.eat()
+}
+```
+
+有人可能会有疑问： 首先，委托方式怎么跟接口实现多继承如此相似，而且好像也并没有简单多少。其次，这种方式好像跟组合也很想，那么它到底有什么优势? 主要有以下两点:   
+
+- 前面说到接口是无状态的，所以即使它提供了默认方法实现也是很简单的，不能实现复杂的逻辑，也不推荐在接口中实现复杂的方法逻辑。我们可以利用上面委托的这种方式，虽然它也是接口委托，但它是用一个具体的类去实现方法逻辑，可以拥有更强大的能力。
+- 假设我们需要继承的类是A，委托对象是B、C，我们再具体调用的时候并不是像组合一样A.B.method，而是可以直接调用A.method，这更能表达A拥有该method的能力，更加直观，虽然背后也是通过委托对象来执行具体的方法逻辑的。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[上一篇:Kotlin学习教程(七)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%B8%83).md)         
+[下一篇:Kotlin学习教程(八)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E5%85%AB).md)
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md" "b/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md"
new file mode 100644
index 00000000..fdbd19e2
--- /dev/null
+++ "b/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md"
@@ -0,0 +1,859 @@
+Kotlin学习教程(六)
+===
+
+### 注解  
+
+注解是将元数据附加到代码的方法。要声明注解，请将`annotation`修饰符放在类的前面:  
+
+```kotlin
+annotation class Fancy
+```
+
+注解的附加属性可以通过用元注解标注注解类来指定:  
+
+- `@Target`指定可以用该注解标注的元素的可能的类型(类、函数、属性、表达式等)
+- `@Retention`指定该注解是否存储在编译后的`class`文件中，以及它在运行时能否通过反射可见(默认都是`true`)
+- `@Repeatable`允许在单个元素上多次使用相同的该注解
+- `@MustBeDocumented`指定该注解是公有`API`的一部分，并且应该包含在生成的`API`文档中显示的类或方法的签名中
+
+
+```kotlin
+@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION,
+        AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.EXPRESSION)
+@Retention(AnnotationRetention.SOURCE)
+@MustBeDocumented
+annotation class Fancy
+```
+
+### 用法 
+
+```kotlin
+@Fancy class Foo {
+    @Fancy fun baz(@Fancy foo: Int): Int {
+        return (@Fancy 1)
+    }
+}
+```
+
+如果需要对类的主构造函数进行标注，则需要在构造函数声明中添加`constructor`关键字，并将注解添加到其前面:   
+
+```kotlin
+class Foo @Inject constructor(dependency: MyDependency) {
+    // ……
+}
+```
+
+### 反射
+
+反射是这样的一组语言和库功能，它允许在运行时自省你的程序的结构。
+`Kotlin`让语言中的函数和属性做为一等公民、并对其自省（即在运行时获悉一个名称或者一个属性或函数的类型）与简单地使用函数式或响应式风格紧密相关。
+
+在`Java`平台上，使用反射功能所需的运行时组件作为单独的`JAR`文件(`kotlin-reflect.jar`)分发。这样做是为了减少不使用反射功能的应用程序所需的
+运行时库的大小。如果你需要使用反射，请确保该`.jar`文件添加到项目的`classpath`中。
+
+
+### 类引用
+
+最基本的反射功能是获取`Kotlin`类的运行时引用。要获取对静态已知的`Kotlin`类的引用，可以使用类字面值语法:   
+
+```kotlin
+val c = MyClass::class
+```
+该引用是`KClass`类型的值。
+通过使用对象作为接收者，可以用相同的`::class`语法获取指定对象的类的引用:   
+
+```kotlin
+val widget: Widget = ……
+assert(widget is GoodWidget) { "Bad widget: ${widget::class.qualifiedName}" }
+```
+
+当我们有一个命名函数声明如下:  
+
+```kotlin
+fun isOdd(x: Int) = x % 2 != 0
+```
+我们可以很容易地直接调用它`isOdd(5)`，但是我们也可以把它作为一个值传递。例如传给另一个函数。为此我们使用`::`操作符:    
+
+```kotlin
+val numbers = listOf(1, 2, 3)
+println(numbers.filter(::isOdd)) // 输出 [1, 3]
+```
+
+### 扩展
+
+扩展是`kotlin`中非常重要的一个特性，它能让我们对一些已有的类进行功能增加、简化，使他们更好的应对我们的需求。
+
+```kotlin
+//  对Context的扩展，增加了toast方法。为了更好的看到效果，我还加了一段log日志
+fun Context.toast(msg : String){
+    Toast.makeText(this, msg, Toast.LENGTH_SHORT).show()
+    Log.d("text", "Toast msg : $msg")
+}
+
+// Activity类，由于所有Activity都是Context的子类，所以可以直接使用扩展的toast方法
+class MainActivity : AppCompatActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        ......
+        toast("hello, Extension")
+    }
+}
+
+// 输出
+Toast msg : hello, Extension
+```
+
+按照通常的做法，会写一个`ToastUtils`工具类，或者在`BaseActivity`中实现`toast`。但是使用扩展函数就会简单很。 
+上面的例子就是在`Context`中添加新的方法，让我们以更简单的方式去显示`toast`，并且不用传入任何`context`参数，可以被任何`Context`或者
+它的子类调用。我们可以在任何地方(例如一个工具类文件中)声明这个函数，然后在`Activity`中将它作为普通方法来直接调用。当然了`Anko`中已经包括了
+自己的`toast`扩展函数。有关`Anko`后面会讲到。
+
+`Kotlin`扩展函数允许我们在不改变已有类的情况下，为类添加新的函数。
+扩展函数是指对类的方法进行扩展，写法和定义方法类似，但是要声明目标类，也就是对哪个类进行扩展，`kotlin`中称之为`Top Level`。
+扩展函数表现得就像是属于这个类的一样，而且我们可以使用`this`关键字和调用所有`public`方法。
+扩展函数可以在已有类中添加新的方法，不会对原类做修改，扩展函数定义形式:   
+```kotlin
+fun receiverType.functionName(params){
+    body
+}
+receiverType：表示函数的接收者，也就是函数扩展的对象
+functionName：扩展函数的名称
+params：扩展函数的参数，可以为NULL
+```
+
+在上面我们举的扩展的例子就是扩展函数.其中`Context`就是目标类`Top Level`，我们把它放到方法名前，用点`.`表示从属关系。在方法体中用关键字
+`this`对本体进行调用。和普通方法一样，如果有返回值，在方法后面跟上返回类型，我这里没有返回值，所以直接省略了。
+
+扩展函数的原理: 通过查看对应的Java代码可以发现:  
+
+```kotlin
+package com.st.stplayer.extension
+
+fun MutableList<Int>.exchange(fromIndex: Int, toIndex: Int) {
+    val tmp = this[fromIndex]
+    this[fromIndex] = this[toIndex]
+    this[toIndex] = tmp
+}
+```
+
+
+
+```java
+package com.st.stplayer.extension;
+
+import java.util.List;
+import kotlin.Metadata;
+import kotlin.jvm.internal.Intrinsics;
+import org.jetbrains.annotations.NotNull;
+
+@Metadata(
+   mv = {1, 4, 2},
+   bv = {1, 0, 3},
+   k = 2,
+   d1 = {"\u0000\u0012\n\u0000\n\u0002\u0010\u0002\n\u0002\u0010!\n\u0002\u0010\b\n\u0002\b\u0003\u001a \u0010\u0000\u001a\u00020\u0001*\b\u0012\u0004\u0012\u00020\u00030\u00022\u0006\u0010\u0004\u001a\u00020\u00032\u0006\u0010\u0005\u001a\u00020\u0003¨\u0006\u0006"},
+   d2 = {"exchange", "", "", "", "fromIndex", "toIndex", "stplayer_debug"}
+)
+public final class ExtenndsKt {
+   public static final void exchange(@NotNull List $this$exchange, int fromIndex, int toIndex) {
+      Intrinsics.checkNotNullParameter($this$exchange, "$this$exchange");
+      int tmp = ((Number)$this$exchange.get(fromIndex)).intValue();
+      $this$exchange.set(fromIndex, $this$exchange.get(toIndex));
+      $this$exchange.set(toIndex, tmp);
+   }
+}
+```
+
+通过上面的Java代码可以看出，我们可以将扩展函数理解为静态方法。而静态方法的特点是：它独立于该类的任何对象，且不依赖类的特定实例，被该类的所有实例共享。此外，被public修饰的静态方法本质上也就是全局方法。所以扩展函数不会带来额外的性能消耗。
+
+
+
+
+
+##### 扩展函数的作用域
+
+在平时写扩展时，我们通常会把扩展方法放到一个文件中，例如ViewExtends.kt: 
+
+```kotlin
+package com.charon.ext
+
+...
+val View.isVisible: Boolean 
+    get() = visibility == View.VISIBLE
+
+fun View.toBitmap(): Bitmap? {
+    clearFocus()
+    isPress = false
+    val willNotCache = willNotCacheDrawing()
+    setWillNotCacheDrawing(false)
+    // Reset the drawing cache background color to fully transparent
+    // for the duration of this operation
+    val color = drawingCacheBackgroundColor
+    drawingCacheBackgroundColor = 0
+    if (color != 0) destroyDrawingCache()
+    buildDrawingCache()
+    val cacheBitmap = drawingCache
+    if (cacheBitmap == null) {
+        Log.e("Views", "failed to get bitmap from $this", RuntimeException())
+        return null
+    }
+    val bitmap = Bitmap.createBitmap(cacheBitmap)
+    // Restore the view
+    destroyDrawingCache()
+    setWillNotCacheDrawing(willNotCache)
+    drawingCacheBackgroundColor = color
+    return bitmap
+}
+```
+
+我们知道在同一个包内是可以直接调用exchange方法的。如果需要在其他包中调用，只需要import相应的方法即可，这与调用Java全局静态方法类似。除此之外，实际开发时我们也可能会将扩展函数定义在一个Class内部统一管理:  
+
+```kotlin
+class Extends {
+    fun MutableList<Int>.exchange(fromIndex: Int, toIndex: Int) {
+        val tmp = this[fromIndex]
+        this[fromIndex] = this[toIndex]
+        this[toIndex] = tmp
+    }
+}
+```
+
+当扩展函数定义在Extends类内部时，情况就与之前不一样了，这个时候你会发现，之前的exchange方法无法调用了(之前调用位置在Extends类外部)。借助IDEA我们可以查看到它对应的Java代码，这里展示关键部分:  
+
+```java
+public static final class Extends {
+    public final void exchange(@NotNull list $receiver, int fromIndex, int toIndex) {
+        Intrinsics.checkParameterIsNotNull($receiver, "$receiver");
+        int tmp = ((Number)$receiver.get(fromIndex)).intValue();
+        $receiver.set(fromIndex, $receiver.get(toIndex));
+        $receiver.set(toIndex, Integer.valueOf(tmp));
+    }
+}
+```
+
+我们看到，exchange方法上已经没有static关键字的修饰了。所以当扩展方法在一个Class内部时，我们只能在该类和该类的子类中进行调用。
+
+
+
+##### 成员方法优先级总高于扩展函数
+
+```kotlin
+class Son {
+    fun foo() = println("son called member foo")
+}
+```
+
+它包含一个成员方法foo()，加入我们哪天心血来潮，想对这个方法做特殊实现，利用扩展函数可能会写出如下代码:  
+
+```kotlin
+fun Son.foo() = println("son called extension foo")
+
+object Test {
+    @JvmStatic
+    fun main(args: Array<String>) {
+        Son().foo()
+    }
+}
+```
+
+在我们的预期中，我们希望调用的是扩展函数foo()，但是输出的结果为: son called member foo。这表明当扩展函数和现有类的成员方法同时存在时，Kotlin将会默认使用类的成员方法。看起来似乎不够合理，并且很容易引发一些问题：我定义了新的方法，为什么还是调用了旧的方法？
+
+但是换一个角度来思考，在多人开发的时候，如果每个人都对Son扩展了foo方法，是不是很容易造成混淆。对于第三方类库来说甚至是一场灾难：我们把不应该更改的方法改变了。所以在使用时，我们必须注意： 同名的类成员方法的优先级总高于扩展函数。
+
+
+
+#### 被滥用的扩展函数
+
+扩展函数在开发中为我们提供了非常多的便利，但是在实际应用中，我们可能会将这个特性滥用。例如ImageLoaderUtils这个加载网络图片为例:  
+
+```kotlin
+fun Context.loadImage(url: String, imageView: ImageView) {
+    GlideApp.with(this)
+        .load(url)
+        .placeholder(R.mipmap.img_default)
+        .error(R.mipmap.ic_error)
+        .into(imageView)
+}
+
+// 在ImageActivity.kt中使用
+this.loadImage(url, imageView)
+```
+
+也许你在用的时候并没有感觉出什么奇怪的地方，但是实际上，我们并没有以任何方式扩展现有类。上述代码仅仅为了在函数调用的时候省去参数，这是一种滥用扩展机制的行为。
+
+我们知道，Context作为"God Object"，已经承担了很多责任。我们基于Context扩展，还很可能产生ImageView与传入上下文周期不一致导致的很多问题。
+
+正确的做法应该是在ImageView上进行扩展:  
+
+```kotlin
+fun ImageView.loadImage(url: String) {
+    GlideApp.with(this.context)
+        .load(url)
+        .placeholder(R.mipmap.img_default)
+        .error(R.mipmap.ic_error)
+        .into(this)
+}
+```
+
+这样在调用的时候，不仅省去了更多的参数，而且ImageView的声明周期也得到了保证。
+
+在实际项目中，我们还需要考虑网络请求框架替换及维护的问题，一般会对图片的请求框架进行二次封装: 
+
+```kotlin
+object ImageLoader {
+    fun with(context: Context, url: String, imageView: ImageView) {
+        GlideApp.with(context)
+            .load(url)
+            .placeholder(R.mipmap.img_default)
+            .error(R.mipmap.ic_error)
+            .into(imageView)
+    }
+}
+```
+
+所以，虽然扩展函数能够提供许多便利，我们还是应该注意在恰当的地方使用它，否则会造成不必要的麻烦。
+
+
+
+##### 扩展属性
+
+
+扩展属性和扩展方法类似，是对目标类的属性进行扩展。扩展属性也会有`set`和`get`方法，并且要求实现这两个方法，不然会提示编译错误。
+因为扩展并不是在目标类上增加了这个属性，所以目标类其实是不持有这个属性的，我们通过`get`和`set`对这个属性进行读写操作的时候也不能使用
+`field`指代属性本体。可以使用`this`，依然表示的目标类。
+
+```kotlin
+// 扩展了一个属性paddingH
+var View.panddingH : Int
+    get() = (paddingLeft + paddingRight) / 2
+    set(value) {
+        setPadding(value, paddingTop, value, paddingBottom)
+    }
+
+// 设置值
+text.panddingH = 100
+```
+
+给`View`扩展了一个属性`paddingH`，并给属性增加了`set`和`get`方法，然后可以在`activity`中通过`textview`调用。
+
+扩展属性与扩展函数一样，其本质也是对应Java中的静态方法。由于扩展没有实际的将成员插入类中，因此对扩展属性来说幕后字段是无效的。
+
+
+##### 静态扩展
+
+`kotlin`中的静态用关键字`companion`表示，但是它不是修饰属性或方法，而是定义一个方法块，在方法块中的所有方法和属性都是静态的，
+这样就将静态部分统一包装了起来。静态部分的访问和`java`一致，直接使用类名+静态属性/方法名调用。   
+
+```kotlin
+// 定义静态部分
+class Extension {
+    companion object{
+        var name = "Extension"
+    }
+}
+
+// 通过类名+属性名直接调用
+toast("hello, ${Extension.name}")
+
+// 输出
+Toast msg : hello, Extension
+```
+上面例子中，`companion object`一起是修饰关键字，`part`是方法块的名称。其中方法块名称`part`可以省略，如果省略的话，默认缺省名为
+`Companion`
+
+静态的扩展和普通的扩展类似，但是在目标类要加上静态方法块的名称，所以如果我们要对一个静态部分扩展，就要先知道静态方法块的名称才行。
+
+```kotlin
+class Extension {
+    companion object part{
+        var name = "Extension"
+    }
+}
+
+// part为静态方法块名称
+fun Extension.part.upCase() : String{
+    return name.toUpperCase()
+}
+
+// 调用一下
+toast("hello, ${Extension.name}")
+toast("hello, ${Extension.upCase()}")
+
+//输出
+Toast msg : hello, Extension
+Toast msg : hello, EXTENSION
+```
+
+
+
+#### 标准库中的扩展函数
+
+1. run
+
+先看一下run方法，它是利用扩展实现的，定义如下: 
+
+```kotlin
+public inline fun <T, R> T.run(block: T.() -> R): R = block()
+```
+
+简单来说，run是任何类型T的通用扩展函数，run中执行了返回类型为R的扩展函数block，最终返回该扩展函数的结果。
+
+在run函数中我们拥有一个单独的作用域，能够重新定义一个nickName变量，并且它的作用域只存在于run函数中: 
+
+```kotlin
+fun testFoo() {
+    val nickName = "111"
+    run {
+        val nickName = "xxx"
+        println(nickName) // xxx
+    }
+    println(nickName) // 111
+}
+```
+
+这个范围函数本身似乎不是很有用。但是相比范围，还有一点不错的是，它返回范围内最后一个对象。
+
+例如现在有这么一个场景：用户点击领取新人奖励的按钮，如果用户此时没有登陆则弹出loginDialog，如果已经登录则弹出领取奖励的getNewAccountDialog。我们可以使用以下代码来处理这个逻辑： 
+
+```kotlin
+run {
+    if (!isLogin) loginDialog else getNewAccountDialog
+}.show()
+```
+
+
+
+2. apply
+
+`apply`函数是这样的，调用某对象的`apply`函数，在函数范围内，可以任意调用该对象的任意方法，并返回该对象.
+
+```kotlin
+fun testApply() {
+    ArrayList<String>().apply {
+        add("testApply")
+        add("testApply")
+        add("testApply")
+        println("this = " + this)
+    }.let { println(it) }
+}
+
+// 运行结果
+// this = [testApply, testApply, testApply]
+// [testApply, testApply, testApply]
+```
+
+let函数和apply函数很像，唯一不同的是返回值。apply返回的是原来的对象，而let返回的是闭包里面的值。
+
+3. let
+
+他的定义为:  
+
+```kotlin
+public inline fun <T, R> T.let(block: (T) -> R): R = block(this)
+```
+
+
+
+如果对象的值不为空，则允许执行这个方法。返回值是函数里面最后一行，或者指定return，与run一样，它同样限制了变量的作用域。
+
+```kotlin
+private var test: String? = null
+
+private fun switchFragment(position: Int) {
+    test?.let {
+        LogUtil.e("@@@", "test is not null")
+    }
+}    
+```
+
+说到可能有人会觉得没什么用，用`if`判断下是不是空不就完了.
+
+```kotlin
+private var test: String? = null
+
+private fun switchFragment(position: Int) {
+//        test?.let {
+//            LogUtil.e("@@@", "test is null")
+//        }
+
+    if (test == null) {
+        LogUtil.e("@@@", "test is null")
+    } else {
+        LogUtil.e("@@@", "test is not null ${test}")
+        check(test) // 报错
+    }
+}    
+```
+
+但是会报错:`Smart cast to 'String' is impossible, beacuase 'test' is a mutable property that could have been changed by this time`
+
+
+
+4. also
+
+also是Kotlin 1.1版本中新加入的内容，它像是let和apply函数的加强版。 
+
+```kotlin
+public inline fun <T> T.also(block: (T) -> Unit): T { block(this); return this }
+```
+
+与apply一致，它的返回值是该函数的接受者。 
+
+```kotlin
+class Kot {
+    val student: Student? = getStu()
+    var age = 0
+    fun dealStu() {
+        val result = student?.also { stu -> 
+			this.age += stu.age                                    
+            println(this.age)
+			println(stu.age)
+			this.age                                    
+        }
+    }
+}
+```
+
+
+
+#### `sNullOrEmpty | isNullOrBlank`
+
+```kotlin
+public inline fun CharSequence?.isNullOrEmpty(): Boolean = this == null || this.length == 0
+
+public inline fun CharSequence?.isNullOrBlank(): Boolean = this == null || this.isBlank()
+
+// If we do not care about the possibility of only spaces...
+if (number.isNullOrEmpty()) {
+    // alert the user to fill in their number!
+}
+
+// when we need to block the user from inputting only spaces
+if (name.isNullOrBlank()) {
+    // alert the user to fill in their name!
+}
+```
+
+#### `with`函数
+
+with和apply这两个方法最大的作用就是可以让那个我们在写Lambda的时候，省略需要多次书写的对象名，默认用this关键字来指向它，this可以省略。
+
+`with`是一个非常有用的函数，它包含在`Kotlin`的标准库中。它接收一个对象和一个扩展函数作为它的参数，然后使这个对象扩展这个函数。
+这表示所有我们在括号中编写的代码都是作为对象（第一个参数）的一个扩展函数，我们可以就像作为`this`一样使用所有它的`public`方法和属性。
+当我们针对同一个对象做很多操作的时候这个非常有利于简化代码。
+
+```kotlin
+fun testWith() {
+    with(ArrayList<String>()) {
+        add("testWith")
+        add("testWith")
+        add("testWith")
+        println("this = " + this)
+    }
+}
+// 运行结果
+// this = [testWith, testWith, testWith]
+```
+
+#### `repeat`函数
+
+`repeat`函数是一个单独的函数，定义如下:     
+
+```kotlin
+/**
+ * Executes the given function [action] specified number of [times].
+ *
+ * A zero-based index of current iteration is passed as a parameter to [action].
+ */
+@kotlin.internal.InlineOnly
+public inline fun repeat(times: Int, action: (Int) -> Unit) {
+    contract { callsInPlace(action) }
+
+    for (index in 0..times - 1) {
+        action(index)
+    }
+}
+```
+
+通过代码很容易理解，就是循环执行多少次`block`中内容。
+
+```kotlin
+fun main(args: Array<String>) {
+    repeat(3) {
+        println("Hello world")
+    }
+}
+```
+
+运行结果是:    
+
+```kotlin
+Hello world
+Hello world
+Hello world
+```
+
+#### also
+
+also是kotlin 1.1版本中新加入的内容，它像是let和apply函数的加强版:  
+
+```kotlin
+public inline fun <T> T.also(block: (T) -> Unit): T {
+    block(this); return this
+}
+```
+
+与apply一致，它的返回值是该函数的接收者。
+
+### 调度方式对扩展函数的影响
+
+Kotlin是一种静态类型语言，我们创建的每个对象不仅具有运行时，还具有编译时类型。在使用扩展函数时，要清楚地了解静态和动态调度之间的区别。
+
+#### 静态与动态调度
+
+先用一个Java的例子: 
+
+```java
+class Base {
+    public void fun() {
+        System.out.println("I'm Base foo!");
+    }
+}
+class Extended extends Base {
+    @Override
+    public void fun() {
+        System.out.println("I'm Extended foo!");
+    }
+}
+Base base = new Extended();
+base.fun();
+```
+
+毫无疑问，因为重写了fun方法，所以最终肯定会执行I'm Extended foo!。
+
+变量base具有编译时类型Base和运行时类型Extended。当我们调用时，base.foo()将动态调度该方法，这意味着运行时类型(Extended)的方法被调用。
+
+当我们调用重载方法时，调度变为静态并且仅取决于编译时类型。
+
+```java
+void foo(Base base) {
+    ...
+}
+void foo(Extended extended) {
+    ...
+}
+public static void main(String[] args) {
+    Base base = new Extended();
+    foo(base);
+}
+```
+
+在这种情况下，即使base本质上是Extended的实例，最终还是会执行Base的方法。
+
+
+
+#### 扩展函数始终静态调度
+
+可能你会好奇，这和扩展有什么关系？我们知道，扩展函数都有一个接收器(receiver)，由于接收器实际上只是字节代码中编译方法的参数，因此你可以重载它。但不能覆盖它。这可能是成员和扩展函数之间最重要的区别：前者是动态调度的，后者总是静态调度的。
+
+为了方便理解，举一个例子:  
+
+```kotlin
+open class Base
+class Extended: Base()
+fun Base.foo() = "I'm Base.foo!"
+fun Extended.foo() = "I'm Extended.foo!"
+fun main(args: Array<String>) {
+    val instance: Base = Extended()
+    val instance2 = Extended()
+    println(instance.foo())
+    println(instance2.foo())
+}
+// 执行结果
+I'm Base.foo!
+I'm Extended.foo!
+```
+
+由于只考虑了编译时类型，第一个打印将调用Base.foo()，而第二个打印将调用Extended.foo()。
+
+
+
+
+
+## 用扩展函数封装Utils
+
+在Java中，我们习惯将常用的代码放到对应的工具类中，例如ToastUtils、NetworkUtils、ImageLoaderUtils等。以NetworkUtils为例，该类中我们通常会放入Android经常需要使用的网络相关方法。比如，我们现在有一个判断手机网络是否可用的方法:  
+
+```java
+public class NetworkUtils {
+    public static boolean isMobileConnected(Context context) {
+        if (context != null) {
+            ConnectivityManager mConnectivityManager = (ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE);
+            NetworkInfo mMobileNetworkInfo = mConnectivityManager.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
+            if (mMobilieNetworkInfo != null) {
+                return mMobileNetworkInfo.isAvailable();
+            }
+        }
+        return false;
+    }
+}
+```
+
+在需要调用的地方，我们通常会这样写:  
+
+```java
+boolean isConnected = NetworkUtils.isMobileConnected(context);
+```
+
+虽然用起来比没有封装之前优雅了很多，但是每次都要传入context，造成的烦琐我们先不计较，重要是可能会让调用者忽视context和mobileNetwork间的强关系。作为代码的使用者，我们更希望在调用时省略NetworkUtils类名，并且让isMobileConnected可以看起来像context的一个属性或方法。我们期望的是下面这样的使用方式: 
+
+```java
+boolean isConnected = context.isMobileConnected();
+```
+
+由于Context是Android SDK自带的类，我们无法对其进行修改。在Java中目前只能通过继承Context新增静态成员方法来实现。但是在Kotlin中，我们通过扩展函数就能简单的实现:  
+
+```kotlin
+fun Context.isMobileConnected(): Boolean {
+    val mNetworkInfo = connectivityManager.activeNetworkInfo
+    if (mNetworkInfo != null) {
+        return mNetworkInfo.isAvailable
+    }
+    return false
+}
+```
+
+我们只需要将以上代码放入对应文件中即可。这时我们已经摆脱了类的束缚，使用方式如下:  
+
+```kotlin
+val isConnected = context.isMobileConnected();
+```
+
+值得一提的是，在Android中对Context的生命周期需要进行很好的把控。这里我们应该使用ApplicationContext，防止出现声明周期不一致导致的内存泄露或者其他问题。
+
+
+
+## 运算符重载
+
+  Kotlin允许我们对所有的运算符(+ - * / % ++ --)，以及其他关键字进行重载，从而拓展这些运算符与关键字的用法。
+
+语法：运算符重载使用的是operator关键字，在指定函数的前面加上operator关键字，就可以实现运算符重载了。
+指定函数，不同的运算符对应的重载函数是不同的，比如：+ 对应plus()  - 对应minus()
+可以在类中，对同一运算符进行多次重载，来满足不同的需求。
+
+运算符重载实际上是函数重载，本质上是对运算符函数的调用，从运算符到对应函数的映射过程由编译器完成。或者理解成是对已有的运算符赋予他们新的含义。重载的修饰符是operator。
+
+举例： 
+
+比如我们的+号，它的含义是两个数值相加：  1+1 = 2。 +号对应的函数名是plus。我们可以对+号这个函数进行重载，让它实现减法的效果。 
+
+下面我们实现一个Person数据类，然后重载Int的 + 号运算符，让一个Int对象可以直接和Person对象相加。返回的结果是这个Int对象减去Person对象的age的值。
+
+```kotlin
+data class Person(var name: String, var age: Int)
+// 通过扩展的方式来实现运算符重载
+operator fun Int.plus(b: Person): Int {
+    return this - b.age
+}
+fun main() {
+    val person1 = Person("A", 3)
+    val testInt = 5
+    println("result : ${testInt + person1}")  //输出结果=2
+}
+```
+
+再比如，我们可以对Person数据类进行重载+号运算符，让Person对象可以直接调用+号来做一些函数操作。
+
+```kotlin
+data class Person(var name: String, var age: Int) {
+    operator fun plus(other: Person): Person {
+        return Person("${this.name} + ${other.name}", this.age + other.age)
+    }
+}
+fun main() {
+    val person1 = Person("A", 3)
+    val person2 = Person("B", 4)
+    val person3 = person1 + person2
+    println("person3 = ${person3}") // person3 = Person(name=A + B, age=7)
+}
+```
+
+一些场景运算符对应的函数名如下:  
+
+### 一元前缀操作符
+
+| 表达式 | 翻译为           |
+| :----- | :--------------- |
+| `+a`   | `a.unaryPlus()`  |
+| `-a`   | `a.unaryMinus()` |
+| `!a`   | `a.not()`        |
+
+
+
+### 算术运算符
+
+| 表达式  | 翻译为                             |
+| :------ | ---------------------------------- |
+| `a + b` | `a.plus(b)`                        |
+| `a - b` | `a.minus(b)`                       |
+| `a * b` | `a.times(b)`                       |
+| `a / b` | `a.div(b)`                         |
+| `a % b` | `a.rem(b)`、 `a.mod(b)` （已弃用） |
+| `a..b`  | `a.rangeTo(b)`                     |
+
+### “In”操作符
+
+| 表达式    | 翻译为           |
+| :-------- | :--------------- |
+| `a in b`  | `b.contains(a)`  |
+| `a !in b` | `!b.contains(a)` |
+
+
+
+### 索引访问操作符
+
+| 表达式                | 翻译为                   |
+| :-------------------- | :----------------------- |
+| `a[i]`                | `a.get(i)`               |
+| `a[i, j]`             | `a.get(i, j)`            |
+| `a[i_1, ……, i_n]`     | `a.get(i_1, ……, i_n)`    |
+| `a[i] = b`            | `a.set(i, b)`            |
+| `a[i, j] = b`         | `a.set(i, j, b)`         |
+| `a[i_1, ……, i_n] = b` | `a.set(i_1, ……, i_n, b)` |
+
+### 调用操作符
+
+| 表达式            | 翻译为                   |
+| :---------------- | :----------------------- |
+| `a()`             | `a.invoke()`             |
+| `a(i)`            | `a.invoke(i)`            |
+| `a(i, j)`         | `a.invoke(i, j)`         |
+| `a(i_1, ……, i_n)` | `a.invoke(i_1, ……, i_n)` |
+
+### 相等与不等操作符
+
+| 表达式   | 翻译为                            |
+| :------- | :-------------------------------- |
+| `a == b` | `a?.equals(b) ?: (b === null)`    |
+| `a != b` | `!(a?.equals(b) ?: (b === null))` |
+
+### 比较操作符
+
+| 表达式   | 翻译为                |
+| :------- | :-------------------- |
+| `a > b`  | `a.compareTo(b) > 0`  |
+| `a < b`  | `a.compareTo(b) < 0`  |
+| `a >= b` | `a.compareTo(b) >= 0` |
+| `a <= b` | `a.compareTo(b) <= 0` |
+
+
+
+
+
+[上一篇:Kotlin学习教程(五)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%BA%94).md)          
+[下一篇:Kotlin学习教程(七)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%B8%83).md)
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
diff --git "a/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md" "b/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
new file mode 100644
index 00000000..d732bbaf
--- /dev/null
+++ "b/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
@@ -0,0 +1,97 @@
+8.Kotlin_协程
+===
+
+Kotlin引入了协程（Coroutine）来支持更好的异步操作，利用它我们可以避免在异步编程中使用大量的回调，同时相比传统多线程技术，它更容易提升系统的高并发处理能力。 
+
+一些`API`启动长时间运行的操作(例如网络`IO`、文件`IO`、`CPU`或`GPU`密集型任务等)，并要求调用者阻塞直到它们完成。协程提供了一种避免阻塞线程
+并用更廉价、更可控的操作替代线程阻塞的方法:协程挂起。     
+协程通过将复杂性放入库来简化异步编程。程序的逻辑可以在协程中顺序地表达，而底层库会为我们解决其异步性。该库可以将用户代码的相关部分包装为回调、
+订阅相关事件、在不同线程(甚至不同机器！)上调度执行，而代码则保持如同顺序执行一样简单。     
+
+
+
+### 起源
+
+协程是一个无优先级的子程序调用组件，允许子程序在特定的地方挂起恢复。线程包含于进程，协程包含于线程。只要内存足够，一个线程中可以有任意多个协程，但某一时刻只能有一个协程在运行，多个协程分享该线程分配到的计算机资源。
+
+线程是由操作系统来进行调度的，当操作系统切换线程的时候，会产生一定的消耗。而协程不一样，协程是包含于线程的，也就是说协程是工作在线程之上的，协程的切换可以由程序自己来控制，不需要操作系统进行调度。这样的话就大大降低了开销。
+
+
+
+
+### 阻塞 vs 挂起
+
+基本上，协程计算可以被挂起而无需阻塞线程。线程阻塞的代价通常是昂贵的，尤其在高负载时，因为只有相对少量线程实际可用，因此阻塞其中一个会导致一些
+重要的任务被延迟。
+
+另一方面，协程挂起几乎是无代价的。不需要上下文切换或者`OS`的任何其他干预。最重要的是，挂起可以在很大程度上由用户库控制:   
+作为库的作者，我们可以决定挂起时发生什么并根据需求优化/记日志/截获。
+
+另一个区别是，协程不能在随机的指令中挂起，而只能在所谓的挂起点挂起，这会调用特别标记的函数。
+
+#### 挂起函数    
+
+当我们调用标记有特殊修饰符`suspend`的函数时，会发生挂起:    
+
+```kotlin
+suspend fun doSomething(foo: Foo): Bar {
+    ……
+}
+```
+
+这样的函数称为挂起函数，因为调用它们可能挂起协程(如果相关调用的结果已经可用，库可以决定继续进行而不挂起)。挂起函数能够以与普通函数相同的方式
+获取参数和返回值，但它们只能从协程和其他挂起函数中调用。事实上，要启动协程，
+必须至少有一个挂起函数，它通常是匿名的(即它是一个挂起`lambda`表达式)。让我们来看一个例子，一个简化的`async()`函数
+(源自`kotlinx.coroutines`库):    
+
+```kotlin
+fun <T> async(block: suspend () -> T)
+```
+
+这里的`async()`是一个普通函数(不是挂起函数)，但是它的`block`参数具有一个带`suspend`修饰符的函数类型:`suspend() -> T`。
+所以，当我们将一个`lambda`表达式传给`async()`时，它会是挂起`lambda`表达式，于是我们可以从中调用挂起函数:    
+
+```kotlin
+async {
+    doSomething(foo)
+    ……
+}
+```
+
+继续该类比,`await()`可以是一个挂起函数(因此也可以在一个`async {}`块中调用)，该函数挂起一个协程，直到一些计算完成并返回其结果:   
+```kotlin
+async {
+    ……
+    val result = computation.await()
+    ……
+}
+
+```
+
+更多关于`async/await`函数实际在`kotlinx.coroutines`中如何工作的信息可以在这里找到。
+
+请注意，挂起函数`await()`和`doSomething()`不能在像`main()`这样的普通函数中调用:    
+```kotlin
+fun main(args: Array<String>) {
+    doSomething() // 错误：挂起函数从非协程上下文调用
+}
+```
+
+还要注意的是，挂起函数可以是虚拟的，当覆盖它们时，必须指定`suspend`修饰符:    
+```kotlin
+interface Base {
+    suspend fun foo()
+}
+
+class Derived: Base {
+    override suspend fun foo() { …… }
+}
+```
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\344\270\200).md" "b/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\344\270\200).md"
deleted file mode 100644
index 1d48ec61..00000000
--- "a/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\344\270\200).md"
+++ /dev/null
@@ -1,534 +0,0 @@
-Kotlin学习教程(一)
-===
-
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_kotlin.jpeg?raw=true)
-
-在`5月18`日谷歌在`I/O`开发者大会上宣布，将`Kotlin`语言作为安卓开发的一级编程语言。并且会在`Android Studio 3.0`版本全面支持`Kotlin`。   
-
-- `Kotlin`是一个基于`JVM`的新的编程语言，由[JetBrains](https://www.jetbrains.com/)开发。`JetBrains`作为目前广受欢迎的
-`Java IDE IntelliJ`的提供商，在`Apache`许可下已经开源其`Kotlin`编程语言。     
-- `Kotlin`可以编译成`Java`字节码，也可以编译成`JavaScript`，方便在没有`JVM`的设备上运行。      
-- `Kotlin`已正式成为`Android`官方开发语言。
-
-[Kotlin官网](https://kotlinlang.org/)
-
-`JetBrains`这家公司非常牛逼，开发了很多著名的软件，他们在使用`Java`的过程中发现`java`比较笨重不方便，所以就开发了`kotlin`，`kotlin`是
-一种全栈的开发语言，可以用它进行开发`web`、`web`后端、`Android`等。    
-
-很多开发者都说`Google`学什么不好，非要学苹果，出个`android`的`swift`版本，一定会搞不起来没人用，所以不用浪费时间去学习。在这里想引用马云
-的一句话: 
-> 拥抱变化
-
-`Google`做事，向来言出必行，之前在推行`Android Studio`时也是一片骂声，吐槽各种不好用，各种慢。但是现在`Android Studio`基本都已经普及了。
-我相信`Kotlin`也不会例外。所以我们不仅要学，还要要认真的学。    
-
-
-### `Kotlin`的特性
-
-- 它更加易表现：这是它最重要的优点之一。你可以编写少得多的代码。
-- `Kotlin`是一种兼容`Java`的语言
-- `Kotlin`比`Java`更安全，能够静态检测常见的陷阱。如:引用空指针
-- `Kotlin`比`Java`更简洁，通过支持`variable type inference，higher-order functions (closures)，extension functions，mixins 
-and first-class delegation`等实现
-- `Kotlin`可与`Java`语言无缝通信。这意味着我们可以在`Kotlin`代码中使用任何已有的`Java`库；同样的`Kotlin`代码还可以为`Java`代码所用
-- `Kotlin`在代码中很少需要在代码中指定类型，因为编译器可以在绝大多数情况下推断出变量或是函数返回值的类型。这样就能获得两个好处:简洁与安全
-
-
-### `Kotlin`优势 
-
-- 全面支持`Lambda`表达式
-- 数据类`Data classes`
-- 函数字面量和内联函数`Function literals & inline functions`
-- 函数扩展`Extension functions`
-- 空安全`Null safety`
-- 智能转换`Smart casts`
-- 字符串模板`String templates`
-- 主构造函数`Primary constructors`
-- 类委托`Class delegation`
-- 类型推判`Type inference`
-- 单例`Singletons`
-- 声明点变量`Declaration-site variance`
-- 区间表达式`Range expressions`
-
-
-上面说简洁简洁，到底简洁在哪里？这里先用一个例子开始，在`Java`开发过程中经常会写一些`Bean`类:  
-```java
-package com.charon.kotlinstudydemo;
-
-public class Person {
-    private int age;
-    private String name;
-    private float height;
-    private float weight;
-
-    public int getAge() {
-        return age;
-    }
-
-    public void setAge(int age) {
-        this.age = age;
-    }
-
-    public String getName() {
-        return name;
-    }
-
-    public void setName(String name) {
-        this.name = name;
-    }
-
-    public float getHeight() {
-        return height;
-    }
-
-    public void setHeight(float height) {
-        this.height = height;
-    }
-
-    public float getWeight() {
-        return weight;
-    }
-
-    public void setWeight(float weight) {
-        this.weight = weight;
-    }
-
-    @Override
-    public String toString() {
-        return "Person name is : " + name + " age is : " + age + " height is :"
-                + height + " weight is :" + weight;
-    }
-}
-```
-使用`Kotlin`:  
-```kotlin
-package com.charon.kotlinstudydemo
-
-data class Person(
-        var name: String,
-        var age: Int,
-        var height: Float,
-        var weight: Float)
-```
-这个数据类，它会自动生成所有属性和它们的访问器，以及一些有用的方法，比如`toString()`方法。   
-这里插一嘴，从上面的例子中我们可以看到对于包的声明基本是一样的，唯一不同的是`kotlin`中后面结束不用分号。 
-
-
-### 创建`Kotlin`项目      
-
-`Google`宣布在`Android Studio 3.0`版本会全面支持`Kotlin`，目前早就有预览版了
-[Android Studio Preview](https://developer.android.com/studio/preview/index.html)(个人感觉很好用，比2.3.3版本强多了)。
-直接通过`New Project`创建就可以，与创建普通`Java`项目唯一不同的是要勾选`Include Kotlin support`的选项。   
-
-
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/studio_create_kotlin.png?raw=true)
-
-创建完成后我们看一下`MainActivity`的代码:    
-```kotlin
-// 定义包
-package com.charon.kotlinstudydemo
-
-// 导入
-import android.support.v7.app.AppCompatActivity
-import android.os.Bundle
-
-// 定义类，继承AppCompatActivity
-class MainActivity : AppCompatActivity() {
-	
-	// 重写方法用overide，函数名用fun声明  参数是a: 类型的形式 ?是啥？它是指明该对象可能为null，
-	// 如果有了?那在调用该方法的时候参数可以传递null进入，如果没有?传递null就会报错
-    override fun onCreate(savedInstanceState: Bundle?) {
-    	// super 
-        super.onCreate(savedInstanceState)
-        // 调用方法
-        setContentView(R.layout.activity_main)
-    }
-}
-```
-
-我们就从`MainActivity`的代码开始介绍一些基本的语法。   
-
-### 变量
-
-变量可以很简单地定义成可变`var`(可读可写)和不可变`val`(只读)的变量。
-
-`val`与`Java`中使用的`final`很相似。一个不可变对象意味着它在实例化之后就不能再去改变它的状态了。如果你需要一个这个对象修改之后的版本，
-那就会再创建一个新的对象。
-
-声明:  
-```kotlin
-var age: Int = 18
-val name: String = "charon"
-```
-
-再提示一下:`kotlin`中每行代码结束不需要分号了，不要和`java`是的每行都带分号
-
-字面上可以写明具体的类型。这个不是必须的，但是一个通用的`Kotlin`实践时省略变量的类型我们可以让编译器自己去推断出具体的类型:   
-```kotlin
-var age = 18 // int
-val name = "charon" // string
-var height = 180.5f // flat
-var weight = 70.5 // double
-```
-
-在`Kotlin`中，一切都是对象。没有像`Java`中那样的原始基本类型。
-当然，像`Integer`，`Float`或者`Boolean`等类型仍然存在，但是它们全部都会作为对象存在的。基本类型的名字和它们工作方式都是与`Java`非常相似
-的，但是有一些不同之处你可能需要考虑到:    
-
-- 数字类型中不会自动转型。举个例子，你不能给`Double`变量分配一个`Int`。必须要做一个明确的类型转换，可以使用众多的函数之一:   
-	```kotlin
-	private var age = 18
-	private var weight = age.toFloat()
-	```
-- 字符（`Char`）不能直接作为一个数字来处理。在需要时我们需要把他们转换为一个数字:       
-	```kotlin
-	val c: Char='c'
-	val i: Int = c.toInt()
-	```
-- 位运算也有一点不同。在`Android`中，我们经常在`flags`中使用`或`:      
-	```java
-	// Java
-	int bitwiseOr = FLAG1 | FLAG2;
-	int bitwiseAnd = FLAG1 & FLAG2;
-	```
-
-	```kotlin
-	// Kotlin
-	val bitwiseOr = FLAG1 or FLAG2
-	val bitwiseAnd = FLAG1 and FLAG2
-	```
-
-- 一个`String`可以像数组那样访问，并且被迭代:     
-	```kotlin
-	var s = "charon"
-	var c = s[2]
-
-	for (a in s) {
-	    Log.e("@@@", a +"");
-	}
-	```
-
-
-##### 编译期常量
-
-已知值的属性可以使用`const`修饰符标记为编译期常量(类似`java`中的`public static final`)。
-`const`只能修复`val`不能修复`var`,这些属性需要满足以下要求:      
-- 位于顶层或者是`object`的一个成员
-- 用`String`或原生类型值初始化
-- 没有自定义`getter`
-
-```kotlin
-// Const val are only allowed on top level or in objects
-const val NAME: String = "charon"
-
-class MainActivity : AppCompatActivity() {
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        setContentView(R.layout.activity_main)
-    }
-}
-```
-
-
-##### 后端变量`Backing Fields`.  
-
-在`kotlin`的`getter`和`setter`是不允许本身的局部变量的，因为属性的调用也是对`get`的调用，因此会产生递归，造成内存溢出。
-
-例如:    
-
-```kotlin
-var count = 1
-var size: Int = 2
-set(value) {
-    Log.e("text", "count : ${count++}")
-    size = if (value > 10) 15 else 0
-}
-```
-这个例子中就会内存溢出。   
-
-`kotlin`为此提供了一种我们要说的后端变量，也就是`field`。编译器会检查函数体，如果使用到了它，就会生成一个后端变量，否则就不会生成。
-我们在使用的时候，用`field`代替属性本身进行操作。
-
-
-##### 延迟初始化   
-
-我们说过，在类内声明的属性必须初始化，如果设置非`null`的属性，应该将此属性在构造器内进行初始化。
-假如想在类内声明一个`null`属性，在需要时再进行初始化（最典型的就是懒汉式单例模式），与`Kotlin`的规则是相背的，此时我们可以声明一个属性并
-延迟其初始化，此属性用`lateinit`修饰符修饰。
-
-```kotlin
-class MainActivity : AppCompatActivity() {
-    lateinit var name : String
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        setContentView(R.layout.activity_main)
-        var test = MainActivity()
-        // 要先调用方法让其初始化
-        test.init()
-        // 再使用其属性
-        Log.e("@@@", test.name)
-    }
-
-    fun init() {
-        // 延迟初始化
-        name = "charon"
-    }
-}
-```
-需要注意的是，我们在使用的时候，一定要确保属性是被初始化过的，通常先调用初始化方法，否则会有异常。
-如果只是用`lateinit`声明了，但是还没有调用初始化方法就使用，哪怕你判断了该变量是否为`null`也是会`crash`的。
-```kotlin
-private lateinit var test: String
-
-private fun switchFragment(position: Int) {
-    if (test == null) {
-        LogUtil.e("@@@", "test is null")
-    } else {
-        LogUtil.e("@@@", "test is not null")
-        check(test)
-    }
-}
-```
-会报`kotlin.UninitializedPropertyAccessException: lateinit property test has not been initialized`
-
-除了使用`lateinit`外还可以使用`by lazy {}`效果是一样的：   
-```kotlin
-private val test by lazy { "haha" }
-
-private fun switchFragment(position: Int) {
-    if (test == null) {
-        LogUtil.e("@@@", "test is null")
-    } else {
-        LogUtil.e("@@@", "test is not null ${test}")
-        check(test)
-    }
-}    
-```
-执行结果:   
-```
-test is not null haha
-```
-
-那`lateinit`和`by lazy`有什么区别呢？    
-
-- `by lazy{}`只能用在`val`类型而`lateinit`只能用在`var`类型
-- `lateinit`不能用在可空的属性上和`java`的基本类型上,否则会报`lateinit`错误   
-
-
-### 类的定义:使用`class`关键字   
-
-类可以包含:  
-- 构造函数和初始化块
-- 函数
-- 属性
-- 嵌套类和内部类
-- 对象声明
-
-
-```kotlin
-class MainActivity{
-
-}
-```
-
-如果有参数的话你只需要在类名后面写上它的参数，如果这个类没有任何内容可以省略大括号：
-```kotlin
-class Person(name: String, age: Int)
-```
-
-##### 创建类的实例  
-
-```kotlin
-val person = Person("charon", 18)
-```
-
-上面的类有一个默认的构造函数。
-
-注意:创建类的实例不用`new`了啊。
-
-
-### 构造函数 
-
-在`Kotlin`中的一个类可以有一个主构造函数和一个或多个次构造函数。
-
-##### 主构造函数
-
-主构造函数是类头的一部分:它跟在类名（和可选的类型参数）后:   
-```kotlin
-class Person constructor(name: String, surname: String) {
-}
-```
-如果主构造函数没有任何注解或者可见性修饰符，可以省略`constructor`关键字:   
-```kotlin
-class Person(name: String, surname: String) {
-}
-```
-
-主构造函数不能包含任何的代码。初始化的代码可以放到以`init`关键字作为前缀的初始化块中:    
-
-```kotlin
-class Person constructor(name: String, surname: String) {
-    init {
-        print("name is $name and surname is $surname")
-    }
-}
-```
-
-如果构造函数有注解或可见性修饰符，那么`constructor`关键字是必需的，并且这些修饰符在它前面:   
-```kotlin
-class Person private @Inject constructor(name: String, surname: String) {
-    init {
-        print("name is $name and surname is $surname")
-    }
-}
-```
-
-##### 次构造函数
-
-类也可以声明前缀有`constructor`的次构造函数: 
-```kotlin
-class Person{
-    constructor(name: String) {
-        print("name is $name")
-    }
-}
-```
-
-如果类有一个主构造函数，每个次构造函数都需要委托给主构造函数(不然会报错)， 可以直接委托或者通过别的次构造函数间接委托。
-委托到同一个类的另一个构造函数用`this`关键字即可:    
-```kotlin
-class Person constructor(name: String) {
-    constructor(name: String, surName: String) : this(name) {
-        Log.d("@@@", "name is : $name surName is : $surName")
-    }
-}
-```
-使用该对象:   
-```kotlin
-class MainActivity : AppCompatActivity() {
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        setContentView(R.layout.activity_main)
-        Person("charon", "chui")
-    }
-}
-```
-就会在`logcat`上打印:   
-`09-20 16:51:19.738 6010-6010/com.charon.kotlinstudydemo D/@@@: name is : charon surName is : chui`
-
-如果一个非抽象类没有声明任何（主或次）构造函数，它会有一个生成的不带参数的主构造函数。构造函数的可见性是`public`。
-如果你不希望你的类有一个公有构造函数，你需要声明一个带有非默认可见性的空的主构造函数：
-
-```kotlin
-class Person private constructor(name: String) {
-}
-```
-
-
-### 接口:使用`interface`关键字    
-
-```kotlin
-interface FlyingAnimal {
-    fun fly()
-}
-```
-
-### 函数:通过`fun`关键字定义
-
-```kotlin
-fun onCreate(savedInstanceState: Bundle?) {
-    super.onCreate(savedInstanceState)
-    setContentView(R.layout.activity_main)
-}
-```
-如果你没有指定它的返回值，它就会返回`Unit`与`Java`中的`void`类似，但是`Unit`是一个真正的对象。`Unit`可以省略，
-你当然也可以指定任何其它的返回类型:      
-```kotlin
-fun maxOf(a: Int, b: Int): Int {
-    if (a > b) {
-        return a
-    } else {
-        return b
-    }
-}
-```
-
-然而如果返回的结果可以使用一个表达式计算出来，你可以不使用括号而是使用等号:         
-```kotlin
-fun add(x: Int,y: Int) : Int = x + y
-```
-
-我们可以给参数指定一个默认值使得它们变得可选，这是非常有帮助的。这里有一个例子，在`Activity`中创建了一个函数用来`Toast`一段信息:    
-```kotlin
-fun toast(message: String, length: Int = Toast.LENGTH_SHORT) {
-    Toast.makeText(this, message, length).show()
-}
-```
-上面代码中第二个参数`length`指定了一个默认值。这意味着你调用的时候可以传入第二个值或者不传，这样可以避免你需要的重载函数：
-
-```kotlin
-toast("Hello")
-toast("Hello", Toast.LENGTH_LONG)
-```
-
-##### 自定义`get set`方法:   
-
-`Kotlin`会默认创建`set get`方法，我们也可以自定义`get set`方法:
-`kotlin`预留了一个在`set`和`get`中访问的变量`field`关键字:  
-
-```kotlin
-class Person constructor() {
-    var name: String = ""
-        get() = field
-        set(value) {
-            field = "$value"
-        }
-
-    var age: Int = 0
-        get() = field
-        set(value) {
-            field = value
-        }
-}
-```
-按照惯例`set`参数的名称是`value`，但是如果你喜欢你可以选择一个不同的名称。
-
-
-##### 可变长参数函数:使用`vararg`关键字
-
-```kotlin
-fun vars(vararg v:Int){
-    for(vt in v){
-        print(vt)
-    }
-}
-
-// 测试
-fun main(args: Array<String>) {
-    vars(1,2,3,4,5)  // 输出12345
-}
-```
-
-
-### 注释  
-
-和`Java`差不多
-
-```kotlin
-
-// 这是一个行注释
-
-/* 这是一个多行的
-   块注释。 */
-```
-
-
-[下一篇:Kotlin学习教程(二)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%BA%8C).md)
-
-
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
-
diff --git "a/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\344\270\203).md" "b/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\344\270\203).md"
deleted file mode 100644
index face6efd..00000000
--- "a/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\344\270\203).md"
+++ /dev/null
@@ -1,96 +0,0 @@
-Kotlin学习教程(七)
-===
-
-这篇文章主要学习下`lambda`表达式。因为后续一些例子会用到。
-
-
-> “Lambda 表达式”(lambda expression)其实就是匿名函数，`Lambda`表达式基于数学中的`λ`演算得名，直接对应于其中的`lambda`抽象
-> `(lambda abstraction)`，是一个匿名函数，即没有函数名的函数。`Lambda`表达式可以表示闭包（注意和数学传统意义上的不同）。
-
-`Java 8`的一个大亮点是引入`Lambda`表达式，使用它设计的代码会更加简洁。
-
-```java
-// 没有使用Lambda的老方法:   
-button.addActionListener(new ActionListener(){
-	public void actionPerformed(ActionEvent ae){
-		System.out.println("Actiondetected");
-	}
-});
-// 使用Lambda:  
-button.addActionListener(()->{ 
-	System.out.println("Actiondetected");
-});
-
-
-// 不采用Lambda的老方法: 
-Runnable runnable1=new Runnable(){
-	@Override
-	public void run(){
-		System.out.println("RunningwithoutLambda");
-	}
-};
-// 使用Lambda:   
-Runnable runnable2=()->{
-	System.out.println("RunningfromLambda");
-};
-```
-
-`Lambda`能让代码更简洁，而主打简洁的`Kotlin`怎么可能不支持呢？ 当然会支持。    
-
-下面来看看一个简短的概述:   
-
-- `lambda`表达式总是被大括号括着
-- 其参数(如果有的话)在`->`之前声明(参数类型可以省略)，
-- 函数体(如果存在的话)在`->`后面。
-
-`Lambda`表达式是定义匿名函数的简单方法。由于`Lambda`表达式避免在抽象类或接口中编写明确的函数声明，进而也避免了类的实现部分，
-所以它是非常有用的。在`Kotlin`语言中，可以将一函数作为另一函数的参数。
-
-`Lambda`表达式由箭头左侧函数的参数（在圆括号里的内容）定义的，将值返回到箭头右侧。
-`view.setOnClickListener({ view -> toast("Click")})`
-在定义函数时，必须在箭头的左侧用方括号，并指定参数值，而函数的执行代码在箭头右侧。如果左侧不使用参数，甚至可以省去左侧部分:  
-`view.setOnClickListener({ toast("Click") })`
-如果函数的最后一个参数是一个函数的话，可以将作为参数的函数移到圆括号外面:
-`view.setOnClickListener() { toast("Click") }`
-
-
-先看一个例子:    
-
-```kotlin
-fun compare(a: String, b: String): Boolean {
-    return a.length < b.length
-}
-max(strings, compare)
-```
-就是找出`strings`里面最长的那个。但是我个人觉得`compare`还是很碍眼的，因为我并不想在后面引用他，那我怎么办呢，就是用“匿名函数”方式。
-```kotlin
-max(strings, (a,b)->{a.length < b.length})
-```
-
-`(a,b)->{a.length < b.length}`就是一个没有名字的函数，直接作为参数赋给`max`方法的第二个参数。但这个方法有很多东西都没有写明，如:   
-
-- 参数的类型
-- 返回值的类型
-
-但这些真的必要吗？`a.length < b.length`很明显返回一个`Boolean`的值，再就是`max`的定义中肯定也定义了这个函数的参数类型和返回值类型。
-这么明显的事为什么不让计算机自己去做而要让人写代码去做呢？这就是匿名函数的好处了。到这里，我们已经和`Lambda`很接近了。
-
-```kotlin
-val sum: (Int, Int) -> Int = { x, y -> x + y }
-```
-
-`Lambda`表达式就是被大括号括着的那一部分，在`->`符号之前有参数声明，函数体跟在一个`->`符号之后。
-而且此`Lambda`表达式之前有一个匿名的函数声明(在此例中两个`Int`型的输入，一个`Int`型的返回值)，这个声明是可以不使用的。
-则此`Lambda`表达式变成`val sum = { x: Int, y: Int -> x + y }`，此时`Lambda`表达式会根据主体中的最后一个（或可能是单个）表达式会视为
-返回值。当然，在某些特定情况下，`x`、`y`的类型了是可以推断的，所以`val sum = { x, y -> x + y }`。
-
-
-
-[上一篇:Kotlin学习教程(六)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E5%85%AD).md)         
-[下一篇:Kotlin学习教程(八)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E5%85%AB).md)
-
-
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
diff --git "a/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\344\270\211).md" "b/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\344\270\211).md"
deleted file mode 100644
index cb0eb4e2..00000000
--- "a/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\344\270\211).md"
+++ /dev/null
@@ -1,196 +0,0 @@
-Kotlin学习教程(三)
-===
-
-前面介绍了基本语法和编码规范后，接下来学习下基本类型。  
-
-在`Kotlin`中，所有东西都是对象，在这个意义上讲我们可以在任何变量上调用成员函数和属性。 一些类型可以有特殊的内部表示——例如，
-数字、字符和布尔值可以在运行时表示为原生类型值，但是对于用户来说，它们看起来就像普通的类。 在本节中，我们会描述`Kotlin`中使用的基本类型:
-数字、字符、布尔值、数组与字符串。
-
-### 数字  
-
-`Kotlin`处理数字在某种程度上接近`Java`,但是并不完全相同。例如，对于数字没有隐式拓宽转换（如`Java`中`int`可以隐式转换为`long`)，
-另外有些情况的字面值略有不同。
-
-`Kotlin`提供了如下的内置类型来表示数字:    
-
-```
-Type    Bit width
-Double  64
-Float   32
-Long    64
-Int     32
-Short   16
-Byte    8
-````
-
-注意在`Kotlin`中字符不是数字,字符用`Char`类型表示。它们不能直接当作数字
-
-
-### 字面常量
-
-数值常量字面值有以下几种:   
-- 十进制:123
-- `Long`类型用大写`L`标记:`123L`
-- 十六进制:`0x0F`
-- 二进制:`0b00001011`
-
-注意: 不支持八进制
-
-`Kotlin`同样支持浮点数的常规表示方法:   
-
-默认`double`:123.5、123.5e10，`Float`用`f`或者`F`标记:`123.5f`
-
-你可以使用下划线使数字常量更易读
-
-```kotlin
-val oneMillion = 1_000_000
-val creditCardNumber = 1234_5678_9012_3456L
-val socialSecurityNumber = 999_99_9999L
-val hexBytes = 0xFF_EC_DE_5E
-val bytes = 0b11010010_01101001_10010100_10010010
-```
-
-### 引用相等
-
-引用相等由`===`以及其否定形式`!===`操作判断。`a === b`当且仅当`a`和`b`指向同一个对象时求值为`true`。
-
-### 结构相等
-
-结构相等由`==`以及其否定形式`!==`操作判断。按照惯例，像`a == b`这样的表达式会翻译成      
-`a?.equals(b) ?: (b === null)`
-也就是说如果`a`不是`null`则调用`equals(Any?)`函数，否则即`a`是`null`检查`b`是否与`null`引用相等。
-
-```kotlin
-val a: Int = 10000
-print(a === a) // 输出“true”
-val boxedA: Int? = agaomnh
-val anotherBoxedA: Int? = a
-print(boxedA === anotherBoxedA) // ！！！输出“false”！！！
-```
-
-另一方面，它保留了相等性:
-```kotlin
-val a: Int = 10000
-print(a == a) // 输出“true”
-val boxedA: Int? = a
-val anotherBoxedA: Int? = a
-print(boxedA == anotherBoxedA) // 输出“true”
-```
-
-### 显式转换
-
-由于不同的表示方式，较小类型并不是较大类型的子类型。 如果它们是的话，就会出现下述问题：
-
-```kotlin
-// 假想的代码，实际上并不能编译：
-val a: Int? = 1 // 一个装箱的 Int (java.lang.Integer)
-val b: Long? = a // 隐式转换产生一个装箱的 Long (java.lang.Long)
-print(a == b) // 惊！这将输出“false”鉴于 Long 的 equals() 检测其他部分也是 Long
-```
-
-所以同一性还有相等性都会在所有地方悄无声息地失去。
-因此较小的类型不能隐式转换为较大的类型。 这意味着在不进行显式转换的情况下我们不能把`Byte`型值赋给一个`Int`变量。
-
-```kotlin
-val b: Byte = 1 // OK, 字面值是静态检测的
-val i: Int = b // 错误
-```
-
-我们可以显式转换来拓宽数字
-```kotlin
-val i: Int = b.toInt() // OK: 显式拓宽
-```
-
-每个数字类型支持如下的转换:
-
-```kotlin
-toByte(): Byte
-toShort(): Short
-toInt(): Int
-toLong(): Long
-toFloat(): Float
-toDouble(): Double
-toChar(): Char
-```
-
-### 运算
-
-这是完整的位运算列表(只用于`Int`和`Long`):
-
-```kotlin
-shl(bits) – 有符号左移 (Java 的 <<)
-shr(bits) – 有符号右移 (Java 的 >>)
-ushr(bits) – 无符号右移 (Java 的 >>>)
-and(bits) – 位与
-or(bits) – 位或
-xor(bits) – 位异或
-inv() – 位非
-相等性检测：a == b 与 a != b
-比较操作符：a < b、 a > b、 a <= b、 a >= b
-区间实例以及区间检测：a..b、 x in a..b、 x !in a..b
-|| – 短路逻辑或
-&& – 短路逻辑与
-! - 逻辑非
-```
-
-
-### 字符串
-
-字符串用`String`类型表示。字符串是不可变的。字符串的元素——字符可以使用索引运算符访问:`s[i]`。可以用`for`循环迭代字符串:   
-
-```kotlin
-for (c in str) {
-    println(c)
-}
-```
-`Kotlin`有两种类型的字符串字面值: 转义字符串可以有转义字符，以及原生字符串可以包含换行和任意文本。转义字符串很像`Java`字符串:
-```kotlin
-val s = "Hello, world!\n"
-```
-转义采用传统的反斜杠方式。
-
-原生字符串 使用三个引号`"""`分界符括起来，内部没有转义并且可以包含换行和任何其他字符:   
-
-```kotlin
-val text = """
-    for (c in "foo")
-        print(c)
-"""
-```
-你可以通过`trimMargin()`函数去除前导空格:   
-
-```kotlin
-val text = """
-    |Tell me and I forget.
-    |Teach me and I remember.
-    |Involve me and I learn.
-    |(Benjamin Franklin)
-    """.trimMargin()
-```
-
-### 字符串模板
-
-字符串可以包含模板表达式，即一些小段代码，会求值并把结果合并到字符串中。模板表达式以美元符`$`开头，由一个简单的名字构成:  
-
-```kotlin
-val i = 10
-val s = "i = $i" // 求值结果为 "i = 10"
-```
-
-或者用花括号括起来的任意表达式:
-```kotlin
-val s = "abc"
-val str = "$s.length is ${s.length}" // 求值结果为 "abc.length is 3"
-```
-
-
-[上一篇:Kotlin学习教程(二)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%BA%8C).md)         
-[下一篇:Kotlin学习教程(四)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E5%9B%9B).md)
-
-
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
-
diff --git "a/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\344\271\235).md" "b/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\344\271\235).md"
index 9d2b1b1c..1a484128 100644
--- "a/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\344\271\235).md"
+++ "b/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\344\271\235).md"
@@ -170,6 +170,14 @@ class MyActivity : Activity() {
 ```
 `textView`是对`Activity`的一项扩展属性，与在`activity_main.xml`中的声明具有同样类型。
 
+这里，你肯定会想，虽然省略了R.id.几个字符，但是引入是否会造成性能问题？ 值得引入、使用 kotlin-android-extensions吗？如果我们对其反编译，就可以看到对应Java代码的实现，在第一次使用空间的时候，会在缓存集合中进行查找，有就直接使用，没有就通过findViewById进行查找，并添加到缓存的集合中。其还提供了$clearFindViewByIdCache()方法用于清除缓存，在我们想要彻底替换界面控件时可以使用。
+
+在Fragment的onDestroyView()方法中默认调用了$clearFindViewByIdCache()清除缓存，而Activity没有。
+
+所以我们并没有完全离开findViewById，只是Kotlin的扩展插件利用缓存的方式让我们开发更方便、更快捷。
+
+
+
 
 ### 网络请求   
 
diff --git "a/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\344\272\214).md" "b/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\344\272\214).md"
deleted file mode 100644
index a4d12dad..00000000
--- "a/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\344\272\214).md"
+++ /dev/null
@@ -1,88 +0,0 @@
-Kotlin学习教程(二)
-===
-
-上一篇文章介绍了`Kotlin`的基本语法，我感觉在继续学习更多知识之前有必要单独介绍以下编码规范。    
-
-不管学什么东西，开始形成的习惯以后想改都比较困难。所以开始就用规范的方式学习是最好的。 
-
-
-### 命名风格
-
-如果拿不准的时候，默认使用`Java`的编码规范，比如:   
-
-- 使用驼峰法命名（并避免命名含有下划线）
-- 类型名以大写字母开头
-- 方法和属性以小写字母开头
-- 使用4个空格缩进
-- 公有函数应撰写函数文档，这样这些文档才会出现在`Kotlin Doc`中
-
-
-### 冒号
-
-类型和超类型之间的冒号前要有一个空格，而实例和类型之间的冒号前不要有空格:     
-
-```kotlin
-interface Foo<out T : Any> : Bar {
-    fun foo(a: Int): T
-}
-```
-
-### `Lambda`表达式
-
-在`lambda`表达式中, 大括号左右要加空格，分隔参数与代码体的箭头左右也要加空格。`lambda`表达应尽可能不要写在圆括号中:    
-
-```kotlin
-list.filter { it > 10 }.map { element -> element * 2 }
-```
-
-### 类头格式化
-
-有少数几个参数的类可以写成一行：
-
-```kotlin
-class Person(id: Int, name: String)
-```
-
-具有较长类头的类应该格式化，以使每个主构造函数参数位于带有缩进的单独一行中。 此外，右括号应该另起一行。如果我们使用继承，
-那么超类构造函数调用或者实现接口列表应位于与括号相同的行上：
-
-```kotlin
-class Person(
-    id: Int, 
-    name: String,
-    surname: String
-) : Human(id, name) {
-    // ……
-}
-```
-对于多个接口，应首先放置超类构造函数调用，然后每个接口应位于不同的行中：
-```kotlin
-class Person(
-    id: Int, 
-    name: String,
-    surname: String
-) : Human(id, name),
-    KotlinMaker {
-    // ……
-}
-```
-
-
-### `Unit`  
-
-如果函数返回`Unit`类型，该返回类型应该省略:   
-```kotlin
-fun foo() { // 省略了 ": Unit"
-
-}
-```
-
-
-[上一篇:Kotlin学习教程(一)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%B8%80).md)         
-[下一篇:Kotlin学习教程(三)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%B8%89).md)
-
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
-
diff --git "a/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\345\205\253).md" "b/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\345\205\253).md"
index ee364cba..6ed5d235 100644
--- "a/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\345\205\253).md"
+++ "b/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\345\205\253).md"
@@ -4,6 +4,8 @@ Kotlin学习教程(八)
 `Kotlin`协程
 ---
 
+Kotlin引入了协程（Coroutine）来支持更好的异步操作，利用它我们可以避免在异步编程中使用大量的回调，同时相比传统多线程技术，它
+
 一些`API`启动长时间运行的操作(例如网络`IO`、文件`IO`、`CPU`或`GPU`密集型任务等)，并要求调用者阻塞直到它们完成。协程提供了一种避免阻塞线程
 并用更廉价、更可控的操作替代线程阻塞的方法:协程挂起。     
 协程通过将复杂性放入库来简化异步编程。程序的逻辑可以在协程中顺序地表达，而底层库会为我们解决其异步性。该库可以将用户代码的相关部分包装为回调、
@@ -421,130 +423,31 @@ class Group<T>(val name: String) {
 
 
 
-常用操作符及函数
----
+### Any
 
-#### `let`操作符  
+我们都知道，Java并不能在真正意义上被称为一门“ 纯面向对象”语言，因为它的原始类型(如int)的值与函数等并不能被视作对象。
 
-如果对象的值不为空，则允许执行这个方法。返回值是函数里面最后一行，或者指定`return`
-```kotlin
-private var test: String? = null
-
-private fun switchFragment(position: Int) {
-    test?.let {
-        LogUtil.e("@@@", "test is not null")
-    }
-}    
-```
+但是Kotlin不同，在Kotlin的类型系统中，并不区分原始类型（基本数据类型）和包装类型，我们使用的始终是同一个类型。虽然从严格意义上，我们不能说Kotlin是一门纯面向对象的语言，但它显然比Java有更纯的设计。
 
-说到可能有人会觉得没什么用，用`if`判断下是不是空不就完了.
-```kotlin
-private var test: String? = null
-
-private fun switchFragment(position: Int) {
-//        test?.let {
-//            LogUtil.e("@@@", "test is null")
-//        }
-
-    if (test == null) {
-        LogUtil.e("@@@", "test is null")
-    } else {
-        LogUtil.e("@@@", "test is not null ${test}")
-        check(test) // 报错
-    }
-}    
-```
-但是会报错:`Smart cast to 'String' is impossible, beacuase 'test' is a mutable property that could have been changed by this time`
-
-#### `sNullOrEmpty | isNullOrBlank`
-
-```kotlin
-public inline fun CharSequence?.isNullOrEmpty(): Boolean = this == null || this.length == 0
-
-public inline fun CharSequence?.isNullOrBlank(): Boolean = this == null || this.isBlank()
-
-// If we do not care about the possibility of only spaces...
-if (number.isNullOrEmpty()) {
-    // alert the user to fill in their number!
-}
-
-// when we need to block the user from inputting only spaces
-if (name.isNullOrBlank()) {
-    // alert the user to fill in their name!
-}
-```
 
-#### `with`函数
 
-`with`是一个非常有用的函数，它包含在`Kotlin`的标准库中。它接收一个对象和一个扩展函数作为它的参数，然后使这个对象扩展这个函数。
-这表示所有我们在括号中编写的代码都是作为对象（第一个参数）的一个扩展函数，我们可以就像作为`this`一样使用所有它的`public`方法和属性。
-当我们针对同一个对象做很多操作的时候这个非常有利于简化代码。
+#### Any：非空类型的跟类型
 
-```kotlin
-fun testWith() {
-    with(ArrayList<String>()) {
-        add("testWith")
-        add("testWith")
-        add("testWith")
-        println("this = " + this)
-    }
-}
-// 运行结果
-// this = [testWith, testWith, testWith]
-```
+与Object作为Java类层级结构的顶层类似，Any类型是Kotlin中所有非空类型（如String、Int）的超类，如:  
 
-#### `repeat`函数
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/kotlin_any.png?raw=true)
 
-`repeat`函数是一个单独的函数，定义如下:     
-```kotlin
-/**
- * Executes the given function [action] specified number of [times].
- *
- * A zero-based index of current iteration is passed as a parameter to [action].
- */
-@kotlin.internal.InlineOnly
-public inline fun repeat(times: Int, action: (Int) -> Unit) {
-    contract { callsInPlace(action) }
+与Java不同的是，Kotlin不区分“原始类型”(primitive type)和其他的类型，他们都是同一类型层级结构的一部分。 如果定义了一个没有指定父类型的类型，则该类型将是Any的直接子类型。如:  
 
-    for (index in 0..times - 1) {
-        action(index)
-    }
-}
-```
-通过代码很容易理解，就是循环执行多少次`block`中内容。
-```kotlin
-fun main(args: Array<String>) {
-    repeat(3) {
-        println("Hello world")
-    }
-}
-```
-运行结果是:    
 ```kotlin
-Hello world
-Hello world
-Hello world
+class Animal(val weight: Double)
 ```
 
-#### `apply`函数
+#### Any?：所有类型的根类型
 
-`apply`函数是这样的，调用某对象的`apply`函数，在函数范围内，可以任意调用该对象的任意方法，并返回该对象
-```kotlin
-fun testApply() {
-    ArrayList<String>().apply {
-        add("testApply")
-        add("testApply")
-        add("testApply")
-        println("this = " + this)
-    }.let { println(it) }
-}
+如果说Any是所有非空类型的根类型，那么Any?才是所有类型（可空和非空类型）的根类型。这也就是说?Any?是?Any的父类型。 
 
-// 运行结果
-// this = [testApply, testApply, testApply]
-// [testApply, testApply, testApply]
-```
 
-`run`函数和`apply`函数很像，只不过run函数是使用最后一行的返回，apply返回当前自己的对象。
 
 
 [上一篇:Kotlin学习教程(七)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%B8%83).md)         
diff --git "a/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\345\205\255).md" "b/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\345\205\255).md"
deleted file mode 100644
index f672121e..00000000
--- "a/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\345\205\255).md"
+++ /dev/null
@@ -1,204 +0,0 @@
-Kotlin学习教程(六)
-===
-
-### 注解  
-
-注解是将元数据附加到代码的方法。要声明注解，请将`annotation`修饰符放在类的前面:  
-
-```kotlin
-annotation class Fancy
-```
-
-注解的附加属性可以通过用元注解标注注解类来指定:  
-
-- `@Target`指定可以用该注解标注的元素的可能的类型(类、函数、属性、表达式等)
-- `@Retention`指定该注解是否存储在编译后的`class`文件中，以及它在运行时能否通过反射可见(默认都是`true`)
-- `@Repeatable`允许在单个元素上多次使用相同的该注解
-- `@MustBeDocumented`指定该注解是公有`API`的一部分，并且应该包含在生成的`API`文档中显示的类或方法的签名中
-
-
-```kotlin
-@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION,
-        AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.EXPRESSION)
-@Retention(AnnotationRetention.SOURCE)
-@MustBeDocumented
-annotation class Fancy
-```
-
-### 用法 
-
-```kotlin
-@Fancy class Foo {
-    @Fancy fun baz(@Fancy foo: Int): Int {
-        return (@Fancy 1)
-    }
-}
-```
-
-如果需要对类的主构造函数进行标注，则需要在构造函数声明中添加`constructor`关键字，并将注解添加到其前面:   
-
-```kotlin
-class Foo @Inject constructor(dependency: MyDependency) {
-    // ……
-}
-```
-
-### 反射
-
-反射是这样的一组语言和库功能，它允许在运行时自省你的程序的结构。
-`Kotlin`让语言中的函数和属性做为一等公民、并对其自省（即在运行时获悉一个名称或者一个属性或函数的类型）与简单地使用函数式或响应式风格紧密相关。
-
-在`Java`平台上，使用反射功能所需的运行时组件作为单独的`JAR`文件(`kotlin-reflect.jar`)分发。这样做是为了减少不使用反射功能的应用程序所需的
-运行时库的大小。如果你需要使用反射，请确保该`.jar`文件添加到项目的`classpath`中。
-
-
-### 类引用
-
-最基本的反射功能是获取`Kotlin`类的运行时引用。要获取对静态已知的`Kotlin`类的引用，可以使用类字面值语法:   
-
-```kotlin
-val c = MyClass::class
-```
-该引用是`KClass`类型的值。
-通过使用对象作为接收者，可以用相同的`::class`语法获取指定对象的类的引用:   
-
-```kotlin
-val widget: Widget = ……
-assert(widget is GoodWidget) { "Bad widget: ${widget::class.qualifiedName}" }
-```
-
-当我们有一个命名函数声明如下:  
-
-```kotlin
-fun isOdd(x: Int) = x % 2 != 0
-```
-我们可以很容易地直接调用它`isOdd(5)`，但是我们也可以把它作为一个值传递。例如传给另一个函数。为此我们使用`::`操作符:    
-
-```kotlin
-val numbers = listOf(1, 2, 3)
-println(numbers.filter(::isOdd)) // 输出 [1, 3]
-```
-
-### 扩展     
-
-扩展是`kotlin`中非常重要的一个特性，它能让我们对一些已有的类进行功能增加、简化，使他们更好的应对我们的需求。
-
-```kotlin
-//  对Context的扩展，增加了toast方法。为了更好的看到效果，我还加了一段log日志
-fun Context.toast(msg : String){
-    Toast.makeText(this, msg, Toast.LENGTH_SHORT).show()
-    Log.d("text", "Toast msg : $msg")
-}
-
-// Activity类，由于所有Activity都是Context的子类，所以可以直接使用扩展的toast方法
-class MainActivity : AppCompatActivity() {
-    override fun onCreate(savedInstanceState: Bundle?) {
-        ......
-        toast("hello, Extension")
-    }
-}
-
-// 输出
-Toast msg : hello, Extension
-```
-
-按照通常的做法，会写一个`ToastUtils`工具类，或者在`BaseActivity`中实现`toast`。但是使用扩展函数就会简单很。 
-上面的例子就是在`Context`中添加新的方法，让我们以更简单的方式去显示`toast`，并且不用传入任何`context`参数，可以被任何`Context`或者
-它的子类调用。我们可以在任何地方(例如一个工具类文件中)声明这个函数，然后在`Activity`中将它作为普通方法来直接调用。当然了`Anko`中已经包括了
-自己的`toast`扩展函数。有关`Anko`后面会讲到。
-
-`Kotlin`扩展函数允许我们在不改变已有类的情况下，为类添加新的函数。
-扩展函数是指对类的方法进行扩展，写法和定义方法类似，但是要声明目标类，也就是对哪个类进行扩展，`kotlin`中称之为`Top Level`。
-扩展函数表现得就像是属于这个类的一样，而且我们可以使用`this`关键字和调用所有`public`方法。
-扩展函数可以在已有类中添加新的方法，不会对原类做修改，扩展函数定义形式:   
-```kotlin
-fun receiverType.functionName(params){
-    body
-}
-receiverType：表示函数的接收者，也就是函数扩展的对象
-functionName：扩展函数的名称
-params：扩展函数的参数，可以为NULL
-```
-
-在上面我们举的扩展的例子就是扩展函数.其中`Context`就是目标类`Top Level`，我们把它放到方法名前，用点`.`表示从属关系。在方法体中用关键字
-`this`对本体进行调用。和普通方法一样，如果有返回值，在方法后面跟上返回类型，我这里没有返回值，所以直接省略了。
-
-
-##### 扩展属性
-
-
-扩展属性和扩展方法类似，是对目标类的属性进行扩展。扩展属性也会有`set`和`get`方法，并且要求实现这两个方法，不然会提示编译错误。
-因为扩展并不是在目标类上增加了这个属性，所以目标类其实是不持有这个属性的，我们通过`get`和`set`对这个属性进行读写操作的时候也不能使用
-`field`指代属性本体。可以使用`this`，依然表示的目标类。
-
-```kotlin
-// 扩展了一个属性paddingH
-var View.panddingH : Int
-    get() = (paddingLeft + paddingRight) / 2
-    set(value) {
-        setPadding(value, paddingTop, value, paddingBottom)
-    }
-
-// 设置值
-text.panddingH = 100
-```
-
-给`View`扩展了一个属性`paddingH`，并给属性增加了`set`和`get`方法，然后可以在`activity`中通过`textview`调用。
-
-
-##### 静态扩展
-
-`kotlin`中的静态用关键字`companion`表示，但是它不是修饰属性或方法，而是定义一个方法块，在方法块中的所有方法和属性都是静态的，
-这样就将静态部分统一包装了起来。静态部分的访问和`java`一致，直接使用类名+静态属性/方法名调用。   
-
-```kotlin
-// 定义静态部分
-class Extension {
-    companion object part{
-        var name = "Extension"
-    }
-}
-
-// 通过类名+属性名直接调用
-toast("hello, ${Extension.name}")
-
-// 输出
-Toast msg : hello, Extension
-```
-上面例子中，`companion object`一起是修饰关键字，`part`是方法块的名称。其中方法块名称`part`可以省略，如果省略的话，默认缺省名为
-`Companion`
-
-静态的扩展和普通的扩展类似，但是在目标类要加上静态方法块的名称，所以如果我们要对一个静态部分扩展，就要先知道静态方法块的名称才行。
-
-```kotlin
-class Extension {
-    companion object part{
-        var name = "Extension"
-    }
-}
-
-// part为静态方法块名称
-fun Extension.part.upCase() : String{
-    return name.toUpperCase()
-}
-
-// 调用一下
-toast("hello, ${Extension.name}")
-toast("hello, ${Extension.upCase()}")
-
-//输出
-Toast msg : hello, Extension
-Toast msg : hello, EXTENSION
-```
-
-
-
-[上一篇:Kotlin学习教程(五)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%BA%94).md)          
-[下一篇:Kotlin学习教程(七)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%B8%83).md)
-
-
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
-
diff --git "a/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\345\215\201).md" "b/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\345\215\201).md"
index e70017a7..7e4012f9 100644
--- "a/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\345\215\201).md"
+++ "b/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\345\215\201).md"
@@ -1,40 +1,7 @@
 Kotlin学习教程(十)
 ===
 
-
-### `Kotlin`用到的关键字
-
-- `var`：定义变量
-- `val`：定义常量
-- `fun`：定义方法
-- `Unit`：默认方法返回值，类似于`Java`中的`void`，可以理解成返回没什么用的值
-- `vararg`：可变参数
-- `$`：字符串模板(取值)
-- 位运算符：`or`(按位或)，`and`(按位与)，`shl`(有符号左移)，`shr`(有符号右移)，
-- `ushr`(无符号右移)，`xor`(按位异或)，`inv`(按位取反)
-- `in`：在某个范围中 检查值是否在或不在(`in/!in`)范围内或集合中
-- `downTo`：递减，循环时可用，每次减1
-- `step`:步长，循环时可用，设置每次循环的增加或减少的量
-- `when`:`Kotlin`中增强版的`switch`，可以匹配值，范围，类型与参数
-- `is`：判断类型用，类似于`Java`中的`instanceof()`，`is`运算符检查表达式是否是类型的实例。 如果一个不可变的局部变量或属性是指定类型，
-则不需要显式转换
-- `private`仅在同一个文件中可见
-- `protected`同一个文件中或子类可见
-- `public`所有调用的地方都可见
-- `internal`同一个模块中可见
-- `abstract`抽象类标示
-- `final`标示类不可继承，默认属性
-- `enum`标示类为枚举
-- `open`类可继承，类默认是`final`的
-- `annotation`注解类
-- `init`主构造函数不能包含任何的代码。初始化的代码可以放到以`init`关键字作为前缀的初始化块(`initializer blocks`)中
-- `field`只能用在属性的访问器内。特别注意的是，`get set`方法中只能能使用`filed`。属性访问器就是`get set`方法。
-- `:`用于类的继承，变量的定义 
--  `..`围操作符(递增的) `1..5`，`2..6`千万不要`6..2`
-- `::`作用域限定符
-- `inner`类可以标记为`inner {: .keyword }`以便能够访问外部类的成员。内部类会带有一个对外部类的对象的引用
-- `object`对象声明并且它总是在`object{: .keyword }`关键字后跟一个名称。对象表达式：在要创建一个继承自某个(或某些)类型的匿名类的对象会
-用到
+- 
 
 
 [上一篇:Kotlin学习教程(九)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%B9%9D).md)
diff --git "a/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\345\233\233).md" "b/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\345\233\233).md"
deleted file mode 100644
index 3cc7aa0c..00000000
--- "a/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\345\233\233).md"
+++ /dev/null
@@ -1,581 +0,0 @@
-Kotlin学习教程(四)
-===
-
-
-### 数据类:使用`data class`定义
-
-数据类是一种非常强大的类。在[Kotlin学习教程(一)][1]中最开始的用的简洁的示例代码就是一个数据类。这里我们再拿过来:   
-```java
-public class Artist {
-    private long id;
-    private String name;
-    private String url;
-    private String mbid;
-
-    public long getId() {
-        return id;
-    }
-
-
-    public void setId(long id) {
-        this.id = id;
-    }
-
-    public String getName() {
-        return name;
-    }
-
-    public void setName(String name) {
-        this.name = name;
-    }
-
-    public String getUrl() {
-        return url;
-    }
-
-    public void setUrl(String url) {
-        this.url = url;
-    }
-
-    public String getMbid() {
-        return mbid;
-    }
-
-    public void setMbid(String mbid) {
-        this.mbid = mbid;
-    }
-
-    @Override public String toString() {
-        return "Artist{" +
-          "id=" + id +
-          ", name='" + name + '\'' +
-          ", url='" + url + '\'' +
-          ", mbid='" + mbid + '\'' +
-          '}';
-    }
-}
-```
-使用`Kotlin`:  
-```kotlin
-data class Artist(
-    var id: Long,
-    var name: String,
-    var url: String,
-    var mbid: String)
-```
-
-通过数据类，会自动提供以下函数：
-- 所有属性的`get() set()`方法
-- `equals()`
-- `hashCode()`
-- `copy()`
-- `toString()`
-- 一系列可以映射对象到变量中的函数(后面再说)。
-
-如果我们使用不可修改的对象，就像我们之前讲过的，假如我们需要修改这个对象状态，必须要创建一个新的一个或者多个属性被修改的实例。
-这个任务是非常重复且不简洁的。
-
-举个例子,如果要修改`Person`类中`charon`的`age`: 
-
-```kotlin
-data class Person(val name: String,
-                  val age: Int)
-```
-
-```kotlin
-val charon = Person("charon", 18)
-val charon2 = charon.copy(age = 19)
-```
-如上，我们拷贝了`charon`对象然后只修改了`age`的属性而没有修改这个对象的其它状态。
-
-### 多声明
-
-多声明，也可以理解为变量映射，这就是编译器自动生成的`componentN()`方法。
-
-```kotlin
-var personD = PersonData("PersonData", 20, "male")
-var (name, age) = personD
-
-
-Log.d("test", "name = $name, age = $age")
-
-//输出
-name = PersonData, age = 20
-```
-
-上面的多声明，大概可以翻译成这样：
-
-```kotlin
-var name = f1.component1()
-var age = f1.component2()
-```
-
-
-### 继承
-
-在`Kotlin`中所有类都有一个共同的超类`Any`，这对于没有超类型声明的类是默认超类:   
-```kotlin
-class Person // 从 Any 隐式继承
-```
-
-`Any`不是`java.lang.Object`。它除了`equals()`、`hashCode()`和`toString()`外没有任何成员。
-`Kotlin`中所有的类默认都是不可继承的(`final`)，为什么要这样设计呢？引用`Effective Java`书中的第17条:要么为继承而设计，并提供文档说明，
-要么就禁止继承。所以我们只能继承那些明确声明`open`或者`abstract`的类:要声明一个显式的超类型，我们把类型放到类头的冒号之后:   
-```kotlin
-open class Person(num: Int)
-// 继承
-class SuperPerson(num: Int) : Person(num)
-```
-如果该类有一个主构造函数，其基类必须用基类型的主构造函数参数就地初始化。
-如果类没有主构造函数，那么每个次构造函数必须使用`super`关键字初始化其基类型，或委托给另一个构造函数做到这一点。
-注意，在这种情况下，不同的次构造函数可以调用基类型的不同的构造函数:   
-```kotlin
-class MyView : View {
-    constructor(ctx: Context) : super(ctx)
-    constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
-}
-```
-
-### 覆盖
-
-##### 方法覆盖
-
-
-只能重写显示标注可覆盖的方法:   
-```kotlin
-open class Person(num: Int) {
-    open fun changeName(name: String) {
-
-    }
-
-    fun changeAge(age: Int) {
-
-    }
-}
-
-class SuperPerson(num: Int) : Person(num) {
-    override fun changeName(name: String) {
-        // 通过super关键字调用超类实现
-        super.changeName(name)
-    }
-}
-```
-`SuperPerson.changeName()`方法前面必须加上`override`标注，不然编译器将会报错。如果像上面`Person.changeAge()`方法没有标注`open`,
-则子类中不能定义相同的方法:   
-```kotlin
-class SuperPerson(num: Int) : Person(num) {
-    override fun changeName(name: String) {
-        super.changeName(name)
-    }
-
-    // 编译器报错
-    fun changeAge(age: Int) {
-
-    }
-    // 重载是可以的
-    fun changeAge(name: String) {
-
-    }
-    // 重载是可以的
-    fun changeAge(age: Int, name: String) {
-
-    }
-}
-```
-
-标记为`override`的成员本身是开放的，也就是说，它可以在子类中覆盖。如果你想禁止再次覆盖，可以使用`final`关键字:    
-
-```kotlin
-open class SuperPerson(num: Int) : Person(num) {
-    final override fun changeName(name: String) {
-        super.changeName(name)
-    }
-}
-```
-
-##### 属性覆盖
-
-属性覆盖与方法覆盖类似，只能覆盖显示标明`open`的属性，并且要用`override`开头:  
-
-```kotlin
-open class Person(num: Int) {
-    open val name: String = ""
-
-    open fun changeName(name: String) {
-
-    }
-
-    fun changeAge(age: Int) {
-
-    }
-}
-
-open class SuperPerson(num: Int) : Person(num) {
-    override val name: String
-        get() = super.name
-
-    final override fun changeName(name: String) {
-        super.changeName(name)
-    }
-
-}
-```
-
-每个声明的属性可以由具有初始化器的属性或者具有`get`方法的属性覆盖，你也可以用一个`var`属性覆盖一个`val`属性，但反之则不行。
-
-
-
-### 抽象类
-
-类和其中的某些成员可以声明为`abstract`。抽象成员在本类中可以不用实现。 需要注意的是，我们并不需要用`open`标注一个抽象类或者函数——因为这不
-言而喻。
-
-我们可以用一个抽象成员覆盖一个非抽象的开放成员:  
-```kotlin
-open class Base {
-    open fun f() {}
-}
-
-abstract class Derived : Base() {
-    override abstract fun f()
-}
-```
-
-### 修饰符
-
-`Kotlin`中修饰符是与`Java`中的有些不同。在`kotlin`中默认的修饰符是`public`，这节约了很多的时间和字符。
-
-- `private`        
-    `private`修饰符是最限制的修饰符，和`Java`中`private`一样。它表示它只能被自己所在的文件可见。所以如果我们给一个类声明为`private`，
-    我们就不能在定义这个类之外的文件中使用它。
-    另一方面，如果我们在一个类里面使用了private修饰符，那访问权限就被限制在这个类里面了。甚至是继承这个类的子类也不能使用它。
-
-- `protected`.    
-    与`Java`一样，它可以被成员自己和继承它的成员可见。
-
-- `internal`
-    如果是一个定义为`internal`的包成员的话，对所在的整个`module`可见。如果它是一个其它领域的成员，它就需要依赖那个领域的可见性了。
-    比如如果写了一个`private`类，那么它的`internal`修饰的函数的可见性就会限制与它所在的这个类的可见性。
-
-- `public`.   
-    你应该可以才想到，这是最没有限制的修饰符。这是默认的修饰符，成员在任何地方被修饰为public，很明显它只限制于它的领域。
-
-
-### 数组  
-
-数组用类`Array`实现，并且还有一个`size`属性及`get`和`set`方法，由于使用`[]`重载了`get`和`set`方法，所以我们可以通过下标很方便的获取或者
-设置数组对应位置的值。       
-`Kotlin`标准库提供了`arrayOf()`创建数组和`xxArrayOf`创建特定类型数组      
-```kotlin
-val array = arrayOf(1, 2, 3)
-val countries = arrayOf("UK", "Germany", "Italy")
-val numbers = intArrayOf(10, 20, 30)
-val array1 = Array(10, { k -> k * k })
-val longArray = emptyArray<Long>()
-val studentArray = Array<Student>(2)
-studentArray[0] = Student("james")
-```
-
-和`Java`不一样的是`Kotlin`的数组是容器类，提供了`ByteArray`,`CharArray`,`ShortArray`,`IntArray`,`LongArray`,`BooleanArray`,
-`FloatArray`和`DoubleArray`。
-
-### 集合 
-
-
-`Kotlin`的`List<out T>`类型是一个提供只读操作如`size`、`get`等的接口。和`Java`类似，它继承自`Collection<T>`进而继承自`Iterable<T>`。
-改变`list`的方法是由`MutableList<T>`加入的。这一模式同样适用于`Set<out T>/MutableSet<T>`及`Map<K, out V>/MutableMap<K, V>`。
-
-`Kotlin`没有专门的语法结构创建`list`或`set`。要用标准库的方法如`listOf()`、`mutableListOf()`、`setOf()`、`mutableSetOf()`。
-创建`map`可以用`mapOf(a to b, c to d)`。
-
-```kotlin
-fun main(args : Array<String>) {
-    var lists = listOf("a", "b", "c")
-    for(list in lists) {
-        println(list)
-    }
-}
-```
-
-```kotlin
-fun main(args : Array<String>) {
-    var map = TreeMap<String, String>()
-    map["0"] = "0 haha"
-    map["1"] = "1 haha"
-    map["2"] = "2 haha"
-    
-    println(map["1"])
-}
-```
-
-```kotlin    
-val numbers: MutableList<Int> = mutableListOf(1, 2, 3)
-val readOnlyView: List<Int> = numbers
-println(numbers)        // 输出 "[1, 2, 3]"
-numbers.add(4)
-println(readOnlyView)   // 输出 "[1, 2, 3, 4]"
-readOnlyView.clear()    // -> 不能编译
-
-val strings = hashSetOf("a", "b", "c", "c")
-assert(strings.size == 3)
-```
-
-
-### 可`null`类型  
-
-
-因为在`Kotlin`中一切都是对象，一切都是可`null`的。当某个变量的值可以为`null`的时候，必须在声明处的类型后添加`?`来标识该引用可为空。
-`Kotlin`通过`?`将是否允许为空分割开来，比如`str:String`为不能空，加上`?`后的`str:String?`为允许空，通过这种方式，将本是不能确定的变
-量人为的加入了限制条件。而不符合条件的输入，则会在`IDE`上显示编译错误而无法执行。
-
-```kotlin
-var value1: String
-value1 = null        // 编译错误 Null can not be a value of a non-null type String
-
-var value2 : String? 
-value2 = null       // 编译通过
-```
-在对变量进行操作时，如果变量是可能为空的，那么将不能直接调用，因为编译器不知道你的变量是否为空，所以编译器就要求你一定要对变量进行判断
-```kotlin
-var str : String? = null
-// 编译错误 Only safe (?.) or non-null asserted (!!.) calls are allowed on a nullable receiver of type String?
-str.length    
-// 编译能通过，这表示如果str不为空的时候执行length方法
-str?.length   
-```
-
-那么问题来了，我们知道在`java`中`String.length`返回的是`int`，上面的`str?.length`既然编译通过了，那么它返回了什么？我们可以这么写:  
-
-`var result = str?.length`
-
-这么写编译器是能通过的，那么`result`的类型是什么呢？在`Kotlin`中，编译器会自动根据结果判断变量的类型，翻译成普通代码如下:   
-
-```kotlin
-if(str == null)
-    result = null;            // 这里result为一个引用类型
-else
-    result = str.length;    // 这里result为Int
-```
-那么如果我们需要的就是一个`Int`的结果(事实上大部分情况都是如此)，那又该怎么办呢？在`kotlin`中除了`?`表示可为空以外，还有一个新的符号`:`双
-感叹号`!!`，表示一定不能为空。所以上面的例子，如果要对`result`进行操作，可以这么写:  
-```kotlin
-var str : String? = null
-var result : Int = str!!.length
-```
-
-这样的话，就能保证`result`的数据类型，但是这样还有一个问题，那就是`str`的定义是可为空的，上面的代码中，`str`就是空，这时候下面的操作虽然
-不会报编译异常，但是运行时就会见到我们熟悉的空指针异常`NullPointerExectpion`，这显然不是我们希望见到的，也不是`kotlin`愿意见到的。
-`java`中的三元操作符大家应该都很熟悉了，`kotlin`中也有类似的，它很好的解决了刚刚说到的问题。在`kotlin`中，三元操作符是`?:`，写起来也
-比`java`要方便一些。
-
-```kotlin
-var str : String? = null
-var result = str?.length ?: -1
-//等价于
-var result : Int = if(str != null) str.length else -1
-```
-
-`if null`缩写
-
-```kotlin
-val data = ……
-val email = data["email"] ?: throw IllegalStateException("Email is missing!")
-```
-
-如果`?:`左侧表达式非空，`elvis`操作符就返回其左侧表达式，否则返回右侧表达式。
-请注意，当且仅当左侧为空时，才会对右侧表达式求值。
-
-
-##### `!!`操作符
-
-我们可以写`b!!`，这会返回一个非空的`b`值
-(例如:在我们例子中的`String`)或者如果`b`为空，就会抛出一个空指针异常:     
-```kotlin
-val l = b!!.length
-```
-
-因此，如果你想要一个 NPE，你可以得到它，但是你必须显式要求它，否则它不会不期而至。
-
-
-#### 安全的类型转换
-
-如果对象不是目标类型，那么常规类型转换可能会导致`ClassCastException`。
-另一个选择是使用安全的类型转换，如果尝试转换不成功则返回`null{: .keyword }`:    
-
-```kotlin
-val aInt: Int? = a as? Int
-```
-
-#### 可空类型的集合
-
-如果你有一个可空类型元素的集合，并且想要过滤非空元素，你可以使用`filterNotNull`来实现。
-```kotlin
-val nullableList: List<Int?> = listOf(1, 2, null, 4)
-val intList: List<Int> = nullableList.filterNotNull()
-```
-
-### 表达式    
-
-##### `if`表达式    
-
-在`Kotlin`中，`if`是一个表达式，即它会返回一个值。因此就不需要三元运算符`条件 ? 然后 : 否则`，因为普通的`if`就能胜任这个角色。
-`if`的分支可以是代码块，最后的表达式作为该块的值:   
-```kotlin
-val max = if (a > b) {
-    print("Choose a")
-    a
-} else {
-    print("Choose b")
-    b
-}
-```
-
-
-##### `when`表达式    
-
-`when`表达式与`Java`中的`switch/case`类似，但是要强大得多。这个表达式会去试图匹配所有可能的分支直到找到满意的一项。然后它会运行右边的表达
-式。      
-与`Java`的`switch/case`不同之处是参数可以是任何类型，并且分支也可以是一个条件。
-
-对于默认的选项，我们可以增加一个`else`分支，它会在前面没有任何条件匹配时再执行。条件匹配成功后执行的代码也可以是代码块:     
-```kotlin
-when (x){
-    1 -> print("x == 1") 
-    2 -> print("x == 2") 
-    else -> {
-        print("I'm a block")
-        print("x is neither 1 nor 2")
-    }
-}
-```
-
-因为它是一个表达式，它也可以返回一个值。我们需要考虑什么时候作为一个表达式使用，它必须要覆盖所有分支的可能性或者实现`else`分支。否则它不会被
-编译成功:   
-
-```kotlin
-val result = when (x) {
-    0, 1 -> "binary"
-    else -> "error"
-}
-```
-
-如你所见，条件可以是一系列被逗号分割的值。但是它可以更多的匹配方式。比如，我们可以检测参数类型并进行判断:  
-
-```kotlin
-when(view) {
-    is TextView -> view.setText("I'm a TextView")
-    is EditText -> toast("EditText value: ${view.getText()}")
-    is ViewGroup -> toast("Number of children: ${view.getChildCount()} ")
-    else -> view.visibility = View.GONE
-}
-```
-
-##### for循环
-
-```kotlin
-val items = listOf("apple", "banana", "kiwi")
-for (item in items) {
-    println(item)
-}
-
-for (i in array.indices)
-    print(array[i])
-```
-
-### 使用类型检测及自动类型转换
-
-`is`运算符检测一个表达式是否某类型的一个实例。 如果一个不可变的局部变量或属性已经判断出为某类型，那么检测后的分支中可以直接当作该类型使用，
-无需显式转换:   
-
-```kotlin
-fun getStringLength(obj: Any): Int? {
-    if (obj !is String) return null
-
-    // `obj` 在这一分支自动转换为 `String`
-    return obj.length
-}
-```
-
-### 返回和跳转
-
-`Kotlin`有三种结构化跳转表达式:    
-
-- `return`:默认从最直接包围它的函数或者匿名函数返回。
-- `break`:终止最直接包围它的循环。
-- `continue`:继续下一次最直接包围它的循环。
-
-在`Kotlin`中任何表达式都可以用标签`label`来标记。标签的格式为标识符后跟`@`符号，例如:`abc@`、`fooBar@`都是有效的标签。
-
-要为一个表达式加标签，我们只要在其前加标签即可。
-```kotlin
-loop@ for (i in 1..100) {
-    for (j in 1..100) {
-        if (……) break@loop
-    }
-}
-```
-
-
-### Ranges
-
-`Range`表达式使用一个`..`操作符。表示就是一个该范围内的数据的数组，包含头和尾
-
-```kotlin
-var nums = 1..100 
-for(num in nums) {
-	println(num)
-	// 打印出1 2 3 ....100
-}
-```
-
-```kotlin
-if(i >= 0 && i <= 10) 
-    println(i)
-```
-转换成 
-
-```kotlin
-if (i in 0..10) 
-    println(i)
-```
-Ranges默认会自增长，所以如果像以下的代码：
-```kotlin
-for (i in 10..0)
-    println(i)
-```
-它就不会做任何事情。但是你可以使用`downTo`函数：
-```kotlin
-for(i in 10 downTo 0)
-    println(i)
-```
-
-我们可以在`Ranges`中使用`step`来定义一个从`1`到一个值的不同的空隙:   
-```kotlin
-for (i in 1..4 step 2) println(i)
-for (i in 4 downTo 1 step 2) println(i)
-```
-
-### Until
-
-上面的`Range`是包含了头和尾，那如果只想包含头不包含尾呢？ 就要用`until`
-
-```kotlin
-var nums = 1 until 100
-for(num in nums) {
-	println(num)
-	// 这样打印出来是1 2 3 .....99
-}
-```
-
-
-[上一篇:Kotlin学习教程(三)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%B8%89).md)         
-[下一篇:Kotlin学习教程(五)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%BA%94).md)
-
-
-[1]: https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%B8%80).md "Kotlin学习教程(一)"
-
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
-

From f38bb8f2c5427b9d9e0e4852e6874ecdf64d6a34 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 8 Apr 2021 17:26:40 +0800
Subject: [PATCH 050/213] update kotlin notes

---
 ...&\347\261\273&\346\216\245\345\217\243.md" | 185 +++--
 ...76\350\256\241\346\250\241\345\274\217.md" |  79 +-
 ...05\350\201\224\345\207\275\346\225\260.md" |  37 +-
 ...0\347\273\204&\351\233\206\345\220\210.md" |  50 +-
 ...7&\345\205\263\351\224\256\345\255\227.md" |  15 +-
 ...2\344\270\276&\345\247\224\346\211\230.md" | 134 ++--
 ...47\346\211\277\351\227\256\351\242\230.md" |  12 +-
 ...5\345\260\204&\346\211\251\345\261\225.md" | 351 +++++++--
 .../8.Kotlin_\345\215\217\347\250\213.md"     | 702 +++++++++++++++++-
 .../9.Kotlin_androidktx.md                    | 160 +---
 ...\346\225\231\347\250\213(\345\205\253).md" | 460 ------------
 ...\346\225\231\347\250\213(\345\215\201).md" |  13 -
 ...72\347\241\200\347\237\245\350\257\206.md" |   8 +-
 ...04\344\273\266\345\260\201\350\243\205.md" |  45 ++
 ...47\350\203\275\344\274\230\345\214\226.md" |  35 +
 .../HLS.md"                                   |   8 +
 16 files changed, 1366 insertions(+), 928 deletions(-)
 rename "KotlinCourse/11.Kotlin_\350\256\276\350\256\241\346\250\241\345\274\217.md" => "KotlinCourse/10.Kotlin_\350\256\276\350\256\241\346\250\241\345\274\217.md" (75%)
 rename "KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\344\271\235).md" => KotlinCourse/9.Kotlin_androidktx.md (56%)
 delete mode 100644 "KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\345\205\253).md"
 delete mode 100644 "KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\345\215\201).md"
 create mode 100644 "VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/11.\346\222\255\346\224\276\347\273\204\344\273\266\345\260\201\350\243\205.md"

diff --git "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md" "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
index b4432c22..995523d5 100644
--- "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
+++ "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
@@ -1,4 +1,4 @@
-1.Kotlin_简介
+1.Kotlin_简介&变量&类&接口
 ===
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_kotlin.jpeg?raw=true)
@@ -13,7 +13,7 @@
 [Kotlin官网](https://kotlinlang.org/)
 
 `JetBrains`这家公司非常牛逼，开发了很多著名的软件，他们在使用`Java`的过程中发现`java`比较笨重不方便，所以就开发了`kotlin`，`kotlin`是
-一种全栈的开发语言，可以用它进行开发`web`、`web`后端、`Android`等。    
+一种全栈的开发语言，可以用它进行开发`web`、`web`后端、`Android`等。    但是JetBrains团队设计Kotlin所要面临的第一个问题就是必须兼容他们所拥有的数百万行Java代码库，这也代表了Kotlin基于整个Java社区所承载的使命之一，即需要与现有的Java代码完全兼容。这个背景也决定了Kotlin的核心目标--为Java程序员提供一门更好的变成语言。
 
 很多开发者都说`Google`学什么不好，非要学苹果，出个`android`的`swift`版本，一定会搞不起来没人用，所以不用浪费时间去学习。在这里想引用马云
 的一句话: 
@@ -113,8 +113,7 @@ data class Person(
 
 ## 创建`Kotlin`项目
 
-`Google`宣布在`Android Studio 3.0`版本会全面支持`Kotlin`，目前早就有预览版了
-[Android Studio Preview](https://developer.android.com/studio/preview/index.html)(个人感觉很好用，比2.3.3版本强多了)。
+`Google`宣布在`Android Studio 3.0`版本会全面支持`Kotlin`，
 直接通过`New Project`创建就可以，与创建普通`Java`项目唯一不同的是要勾选`Include Kotlin support`的选项。   
 
 
@@ -143,7 +142,7 @@ class MainActivity : AppCompatActivity() {
 }
 ```
 
-我们就从`MainActivity`的代码开始介绍一些基本的语法。   
+
 
 ## 变量
 
@@ -161,7 +160,7 @@ book.printName() // Diving into Kotlin
 
 再提示一下:`kotlin`中每行代码结束不需要分号了，不要和`java`是的每行都带分号
 
-字面上可以写明具体的类型。这个不是必须的，但是一个通用的`Kotlin`实践时省略变量的类型我们可以让编译器自己去推断出具体的类型:   
+字面上可以写明具体的类型。这个不是必须的，但是一个通用的`Kotlin`实践时省略变量的类型我们可以让编译器自己去推断出具体的类型，**Kotlin拥有比Java更加强大的类型推导功能，这避免了静态类型语言在编码时需要书写大量类型的弊端**:   
 ```kotlin
 var age = 18 // int
 val name = "charon" // string
@@ -170,8 +169,7 @@ var weight = 70.5 // double
 ```
 
 在`Kotlin`中，一切都是对象。没有像`Java`中那样的原始基本类型。
-当然，像`Integer`，`Float`或者`Boolean`等类型仍然存在，但是它们全部都会作为对象存在的。基本类型的名字和它们工作方式都是与`Java`非常相似
-的，但是有一些不同之处你可能需要考虑到:    
+当然，像`Integer`，`Float`或者`Boolean`等类型仍然存在，但是它们全部都会作为对象存在的。基本类型的名字和它们工作方式都是与`Java`非常相似的，但是有一些不同之处你可能需要考虑到:    
 
 - 数字类型中不会自动转型。举个例子，你不能给`Double`变量分配一个`Int`。必须要做一个明确的类型转换，可以使用众多的函数之一:   
 	```kotlin
@@ -216,10 +214,10 @@ var weight = 70.5 // double
 - IO操作，如写数据到磁盘
 - UI操作，如修改了一个按钮的可操作状态
 
-来看一个实际的例子：先用va来声明一个变量a，然后在count函数内部对其进行自增操作：
+来看一个实际的例子：先用var来声明一个变量a，然后在count函数内部对其进行自增操作：
 
 ```kotlin
-val a = 1
+var a = 1
 fun count(x: Int) {
     a = a + 1
     println(x + a)
@@ -252,6 +250,8 @@ class MainActivity : AppCompatActivity() {
 
 ## 后端变量`Backing Fields`.
 
+`Kotlin`会默认创建`set get`方法，我们也可以自定义`get set`方法:
+
 在`kotlin`的`getter`和`setter`是不允许本身的局部变量的，因为属性的调用也是对`get`的调用，因此会产生递归，造成内存溢出。
 
 例如:    
@@ -259,21 +259,42 @@ class MainActivity : AppCompatActivity() {
 ```kotlin
 var count = 1
 var size: Int = 2
-set(value) {
-    Log.e("text", "count : ${count++}")
-    size = if (value > 10) 15 else 0
-}
+    set(value) {
+        Log.e("text", "count : ${count++}")
+        size = if (value > 10) 15 else 0
+    }
 ```
 这个例子中就会内存溢出。   
 
 `kotlin`为此提供了一种我们要说的后端变量，也就是`field`。编译器会检查函数体，如果使用到了它，就会生成一个后端变量，否则就不会生成。
-我们在使用的时候，用`field`代替属性本身进行操作。
+我们在使用的时候，用`field`代替属性本身进行操作。按照惯例`set`参数的名称是`value`，但是如果你喜欢你可以选择一个不同的名称。
+
+```kotlin
+class A {
+    var count = 1
+    var size: Int = 2
+        set(value) {
+            field = if (value > 10) 15 else 0
+        }
+        get() {
+            return if (field == 15) 1 else 0
+        }
+}
+fun main() {
+    val a = A()
+	a.size = 11
+    println("${a.size}")
+}
+// 
+1
+```
+
+
 
 ## 延迟初始化
 
 我们说过，在类内声明的属性必须初始化，如果设置非`null`的属性，应该将此属性在构造器内进行初始化。
-假如想在类内声明一个`null`属性，在需要时再进行初始化（最典型的就是懒汉式单例模式），与`Kotlin`的规则是相背的，此时我们可以声明一个属性并
-延迟其初始化，此属性用`lateinit`修饰符修饰。
+假如想在类内声明一个`null`属性，在需要时再进行初始化（最典型的就是懒汉式单例模式），与`Kotlin`的规则是相背的，此时我们可以声明一个属性并延迟其初始化，此属性用`lateinit`修饰符修饰。
 
 ```kotlin
 class MainActivity : AppCompatActivity() {
@@ -628,10 +649,6 @@ val charon2 = charon.copy(age = 19)
 - data class之前不能用abstract、open、sealed或者inner进行修饰
 - 在Kotlin 1.1版本前数据类只允许实现接口，之后的版本既可以实现接口也可以继承类
 
-
-
-
-
 ## 多声明
 
 多声明，也可以理解为变量映射，这就是编译器自动生成的`componentN()`方法。
@@ -718,6 +735,32 @@ public final class Bird {
 
 
 
+### Any
+
+我们都知道，Java并不能在真正意义上被称为一门“ 纯面向对象”语言，因为它的原始类型(如int)的值与函数等并不能被视作对象。
+
+但是Kotlin不同，在Kotlin的类型系统中，并不区分原始类型（基本数据类型）和包装类型，我们使用的始终是同一个类型。虽然从严格意义上，我们不能说Kotlin是一门纯面向对象的语言，但它显然比Java有更纯的设计。
+
+
+
+#### Any：非空类型的跟类型
+
+与Object作为Java类层级结构的顶层类似，Any类型是Kotlin中所有非空类型（如String、Int）的超类，如:  
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/kotlin_any.png?raw=true)
+
+与Java不同的是，Kotlin不区分“原始类型”(primitive type)和其他的类型，他们都是同一类型层级结构的一部分。 如果定义了一个没有指定父类型的类型，则该类型将是Any的直接子类型。如:  
+
+```kotlin
+class Animal(val weight: Double)
+```
+
+#### Any?：所有类型的根类型
+
+如果说Any是所有非空类型的根类型，那么Any?才是所有类型（可空和非空类型）的根类型。这也就是说?Any?是?Any的父类型。 
+
+
+
 ## 覆盖
 
 ##### 方法覆盖
@@ -812,8 +855,7 @@ open class SuperPerson(num: Int) : Person(num) {
 
 ## 抽象类
 
-类和其中的某些成员可以声明为`abstract`。抽象成员在本类中可以不用实现。 需要注意的是，我们并不需要用`open`标注一个抽象类或者函数——因为这不
-言而喻。
+类和其中的某些成员可以声明为`abstract`。抽象成员在本类中可以不用实现。 需要注意的是，我们并不需要用`open`标注一个抽象类或者函数——因为这不言而喻。
 
 我们可以用一个抽象成员覆盖一个非抽象的开放成员:  
 
@@ -859,7 +901,7 @@ interface FlyingAnimal {
 interface Flyer {
     val height = 1000 // error Property initializers are not allowed in interfaces
     val speed: Int
-    // 可以支持默认实现方法，反编译可以看到是通过静态内部类来提供fly方法的默认实现的
+    // 可以支持默认实现方法，反编译可以看到是通过静态内部类来提供fly方法的默认实现的，Java8也开始支持了接口方法的默认实现
     fun fly() {
         println("I can fly")
     }
@@ -908,8 +950,6 @@ fun add(x: Int,y: Int) : Int = x + y // 省略了{}
 
 Kotlin支持这种单行表达式与等号的语法来定义函数，叫做表达式函数体，作为区分，普通的函数声明则可以叫做代码块函数体。如你所见，在使用表达式函数体的情况下我们可以不声明返回值类型，这进一步简化了语法。
 
-
-
 我们可以给参数指定一个默认值使得它们变得可选，这是非常有帮助的。这里有一个例子，在`Activity`中创建了一个函数用来`Toast`一段信息:    
 
 ```kotlin
@@ -924,27 +964,7 @@ toast("Hello")
 toast("Hello", Toast.LENGTH_LONG)
 ```
 
-### 自定义`get set`方法:
-
-`Kotlin`会默认创建`set get`方法，我们也可以自定义`get set`方法:
-`kotlin`预留了一个在`set`和`get`中访问的变量`field`关键字:  
-
-```kotlin
-class Person constructor() {
-    var name: String = ""
-        get() = field
-        set(value) {
-            field = "$value"
-        }
 
-    var age: Int = 0
-        get() = field
-        set(value) {
-            field = value
-        }
-}
-```
-按照惯例`set`参数的名称是`value`，但是如果你喜欢你可以选择一个不同的名称。
 
 ### 可变长参数函数:使用`vararg`关键字
 
@@ -961,7 +981,33 @@ fun main(args: Array<String>) {
 }
 ```
 
-### 命名风格
+
+
+### `Unit`:让函数调用皆为表达式
+
+如果函数返回`Unit`类型，该返回类型应该省略:   
+
+```kotlin
+fun foo() { // 省略了 ": Unit"
+
+}
+```
+
+之所以不能说Java中的函数调用皆是表达式，是因为存在特例void。众所周知，在Java中如果声明的函数没有返回值，那么它就需要用void来修饰，如： 
+
+```java
+void foo() {
+    System.out.println("return nothing")
+}
+```
+
+所以foo()就不具有值和类型信息，它就不能算作一个表达式。在Kotlin中，函数在所有的情况下都具有返回类型，所以他们引入了Unit来替代Java中的void关键字。
+
+Unit与Int一样，都是一种类型，然而它不代表任何信息，用面向对象的术语来描述就是一个单例，它的实例只有一个，可写为()。
+
+
+
+## 命名风格
 
 如果拿不准的时候，默认使用`Java`的编码规范，比如:   
 
@@ -972,6 +1018,29 @@ fun main(args: Array<String>) {
 - 公有函数应撰写函数文档，这样这些文档才会出现在`Kotlin Doc`中
 
 
+
+### 类布局
+
+通常，一个类的内容按以下顺序排列：
+
+- 属性声明与初始化块
+- 次构造函数
+- 方法声明
+- 伴生对象
+
+不要按字母顺序或者可见性对方法声明排序，也不要将常规方法与扩展方法分开。而是要把相关的东西放在一起，这样从上到下阅读类的人就能够跟进所发生事情的逻辑。选择一个顺序（高级别优先，或者相反）并坚持下去。
+
+将嵌套类放在紧挨使用这些类的代码之后。如果打算在外部使用嵌套类，而且类中并没有引用这些类，那么把它们放到末尾，在伴生对象之后。
+
+### 接口实现布局
+
+在实现一个接口时，实现成员的顺序应该与该接口的成员顺序相同（如果需要， 还要插入用于实现的额外的私有方法）
+
+### 重载布局
+
+在类中总是将重载放在一起。
+
+
 ### 冒号
 
 类型和超类型之间的冒号前要有一个空格，而实例和类型之间的冒号前不要有空格:     
@@ -1016,28 +1085,6 @@ class Person(
 }
 ```
 
-### `Unit`:让函数调用皆为表达式
-
-如果函数返回`Unit`类型，该返回类型应该省略:   
-
-```kotlin
-fun foo() { // 省略了 ": Unit"
-
-}
-```
-
-之所以不能说Java中的函数调用皆是表达式，是因为存在特例void。众所周知，在Java中如果声明的函数没有返回值，那么它就需要用void来修饰，如： 
-
-```java
-void foo() {
-    System.out.println("return nothing")
-}
-```
-
-所以foo()就不具有值和类型信息，它就不能算作一个表达式。在Kotlin中，函数在所有的情况下都具有返回类型，所以他们引入了Unit来替代Java中的void关键字。
-
-Unit与Int一样，都是一种类型，然而它不代表任何信息，用面向对象的术语来描述就是一个单例，它的实例只有一个，可写为()。
-
 
 
 [下一篇:Kotlin学习教程(二)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%BA%8C).md)
diff --git "a/KotlinCourse/11.Kotlin_\350\256\276\350\256\241\346\250\241\345\274\217.md" "b/KotlinCourse/10.Kotlin_\350\256\276\350\256\241\346\250\241\345\274\217.md"
similarity index 75%
rename from "KotlinCourse/11.Kotlin_\350\256\276\350\256\241\346\250\241\345\274\217.md"
rename to "KotlinCourse/10.Kotlin_\350\256\276\350\256\241\346\250\241\345\274\217.md"
index 5a3a5989..fc6a644e 100644
--- "a/KotlinCourse/11.Kotlin_\350\256\276\350\256\241\346\250\241\345\274\217.md"
+++ "b/KotlinCourse/10.Kotlin_\350\256\276\350\256\241\346\250\241\345\274\217.md"
@@ -1,11 +1,11 @@
-11.Kotlin_设计模式
+10.Kotlin_设计模式
 ===
 
 
-
 ## 工厂模式
 
-简单工厂的模式，它的核心作用是通过一个工厂类隐藏对象实例的创建逻辑，而不需要暴露给客户端。典型的使用场景就是当拥有一个父类与多个子类的时候，我们可以通过这种模式来创建子类对象。
+简单工厂的模式，它的核心作用是通过一个工厂类隐藏对象实例的创建逻辑，而不需要暴露给客户端。典型的使用场景就是当拥有一个父类
+与多个子类的时候，我们可以通过这种模式来创建子类对象。
 
 假设现在有一个电脑加工厂，同时生产个人电脑和服务器主机。我们用熟悉的工厂模式设计描述其业务逻辑:  
 
@@ -34,7 +34,9 @@ fun main() {
 }
 ```
 
-以上代码通过调用ComputerFactory类的produce方法来创建不同的Computer子类对象，这样我们就把创建实例的逻辑和客户端之间实现解耦。这是用Kotlin模仿Java中很标准的工厂模式设计，它改善了程序的可维护性，但创建对象的表达上却显得不够简洁。当我们在不同的地方创建Computer的子类对象时，我们都需要先创建一个ComputerFactory类对象。
+以上代码通过调用ComputerFactory类的produce方法来创建不同的Computer子类对象，这样我们就把创建实例的逻辑和客户端之间实现解耦。
+这是用Kotlin模仿Java中很标准的工厂模式设计，它改善了程序的可维护性，但创建对象的表达上却显得不够简洁。
+当我们在不同的地方创建Computer的子类对象时，我们都需要先创建一个ComputerFactory类对象。
 
 ### 用单例代替工厂类
 
@@ -56,7 +58,8 @@ fun main() {
 }
 ```
 
-由于我们通过传入Computer类型来创建不同的对象，所以这里的produce又显得多余。我们可以用运算符重载来通过operator操作符重载invoke方法来代替produce，从而进一步简化表达： 
+由于我们通过传入Computer类型来创建不同的对象，所以这里的produce又显得多余。我们可以用运算符重载来通过operator操作符
+重载invoke方法来代替produce，从而进一步简化表达： 
 
 ```kotlin
 object ComputerFactory {
@@ -101,7 +104,8 @@ fun main() {
 }
 ```
 
-我们可以直接通过Computer来调用其伴生对象中的方法。当然，如果你觉得还是Factory这个名字好，那么也没有问题，我们可以用Factory来命名Computer的伴生对象，如下： 
+我们可以直接通过Computer来调用其伴生对象中的方法。当然，如果你觉得还是Factory这个名字好，那么也没有问题，我们可以用
+Factory来命名Computer的伴生对象，如下： 
 
 ```kotlin
 interface Computer {
@@ -126,7 +130,9 @@ fun main() {
 
 ### 扩展伴生对象方法
 
-依靠伴生对象的特性，我们已经很好地实现了经典的工厂模式。同时，这种方式还有一种优势，它比原有Java中的设计更加强大。假设实际业务中我们是Computer接口的使用者，比如它是工程引入的第三方类库，所有的类的实现细节都得到了很好的隐藏。那么，如果我们希望进一步改造其中的逻辑，Kotlin中伴生对象的方式同样可以依靠其扩展函数的特性，很好的实现这一需求： 
+依靠伴生对象的特性，我们已经很好地实现了经典的工厂模式。同时，这种方式还有一种优势，它比原有Java中的设计更加强大。
+假设实际业务中我们是Computer接口的使用者，比如它是工程引入的第三方类库，所有的类的实现细节都得到了很好的隐藏。
+那么，如果我们希望进一步改造其中的逻辑，Kotlin中伴生对象的方式同样可以依靠其扩展函数的特性，很好的实现这一需求： 
 
 比如我们希望给Computer增加一种功能，通过CPU型号来判断电脑类型，那么可以如下实现：  
 
@@ -146,7 +152,10 @@ fun main() {
 
 ### 内联函数简化抽象工厂
 
-Kotlin中的内联函数有一个很大的作用，就是可以具体化参数类型。利用这一特性，可以改进一种更复杂的工厂模式，称为抽象工厂。 上面的例子中已经用工厂模式很好的处理了一个产品登记结构的问题。但是如果现在引入了品牌商的概念，我们有好几个不同的电脑品牌，比如Dell、Asus、Acer，那么就有必要再增加一个工厂类。然而，我们并不希望对每个模型都建立一个工厂，这会让代码变得难以维护，所以这时候我们就需要引入抽象工厂模式。 
+Kotlin中的内联函数有一个很大的作用，就是可以具体化参数类型。利用这一特性，可以改进一种更复杂的工厂模式，称为抽象工厂。 
+上面的例子中已经用工厂模式很好的处理了一个产品登记结构的问题。但是如果现在引入了品牌商的概念，我们有好几个不同的电脑品牌，
+比如Dell、Asus、Acer，那么就有必要再增加一个工厂类。然而，我们并不希望对每个模型都建立一个工厂，这会让代码变得难以维护，
+所以这时候我们就需要引入抽象工厂模式。 
 
 
 
@@ -185,9 +194,12 @@ fun main(args: Array<String>) {
 }
 ```
 
-可以看出，每个电脑品牌拥有一个代表电脑产品的类，它们都实现了Computer接口。此外每个品牌也还有一个用于生产电脑的AbstractFactory子类，可通过AbstractFactory类的伴生对象中的invoke方法，来构造具体品牌的工厂类对象。
+可以看出，每个电脑品牌拥有一个代表电脑产品的类，它们都实现了Computer接口。此外每个品牌也还有一个用于生产电脑的
+AbstractFactory子类，可通过AbstractFactory类的伴生对象中的invoke方法，来构造具体品牌的工厂类对象。
 
-由于Kotlin语法的简洁，以上例子的抽象工厂类的设计也比较直观。然而，当你每次创建具体的工厂类时，都需要传入一个具体的工厂类对象作为参数进行构造，这个在语法上显然不够优雅。下面我们就来看看，如何用Kotlin中的内联函数来改善这一情况。我们所需要做的，就是去重新实现AbstractFactory类中的invoke方法。 
+由于Kotlin语法的简洁，以上例子的抽象工厂类的设计也比较直观。然而，当你每次创建具体的工厂类时，都需要传入一个具体的
+工厂类对象作为参数进行构造，这个在语法上显然不够优雅。下面我们就来看看，如何用Kotlin中的内联函数来改善这一情况。
+我们所需要做的，就是去重新实现AbstractFactory类中的invoke方法。 
 
 ```kotlin
 abstract class AbstractFactory {
@@ -205,7 +217,8 @@ abstract class AbstractFactory {
 }
 ```
 
-这下我们的invoke方法定义的前缀变长了很多，但是不要害怕，如果你已经掌握了内联函数的具体应用，应该会很容易理解它。我们来分析下这段代码： 
+这下我们的invoke方法定义的前缀变长了很多，但是不要害怕，如果你已经掌握了内联函数的具体应用，应该会很容易理解它。
+我们来分析下这段代码： 
 
 - 通过将invoke方法用inline定义为内联函数，我们就可以引入reified关键字，使用具体化参数类型的语法特性。
 - 要具体化的参数类型为Computer，在invoke方法中我们通过判断它的具体类型，来返回对应的工厂类对象。
@@ -228,9 +241,12 @@ fun main(args: Array<String>) {
 
 构造者模式与单例模式一样，它主要做的事情就是将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。 
 
-工厂模式和构造函数都存在相同的问题，就是不能很好地扩展到大量的可选参数。假设我们现在有个机器人类，它含有多个属性：代号、名字、电池、重量、高度、速度、音量等。很多产品都不具有其中的某些属性，比如不能走、不能发声，甚至有的机器人也不需要电池。 
+工厂模式和构造函数都存在相同的问题，就是不能很好地扩展到大量的可选参数。假设我们现在有个机器人类，它含有多个属性：
+代号、名字、电池、重量、高度、速度、音量等。很多产品都不具有其中的某些属性，比如不能走、不能发声，甚至有的机器人也不需要电池。 
 
-一种糟糕的做法就是设计一个一开头你所看到Robot类，把所有的属性都作为构造函数的参数。或者，你也可能采用过重叠构造器模式，即先提供一个只有必要参数的构造函数，然后再提供其他更多的构造函数，分别具有不同情况的可选属性。虽然这种模式在调用的时候改进不少，但同样存在明显的确定，因为随着构造函数的参数数量增加，很快我们就会失去控制，代码变得难以维护。
+一种糟糕的做法就是设计一个一开头你所看到Robot类，把所有的属性都作为构造函数的参数。或者，你也可能采用过重叠构造器模式，
+即先提供一个只有必要参数的构造函数，然后再提供其他更多的构造函数，分别具有不同情况的可选属性。虽然这种模式在调用的时候改进不少，
+但同样存在明显的缺点，因为随着构造函数的参数数量增加，很快我们就会失去控制，代码变得难以维护。
 
 构建者模式可以避免以上问题，我们用Kotlin来实现Java中的构建者模式:  
 
@@ -281,7 +297,8 @@ var robot = Robot.Builder("007")
 - 通过在Builder类中定义set方法来对可选的属性进行设置
 - 最终调用Builder类中的build方法来返回一个Robot对象
 
-这种链式调用的设计看起来确实优雅了很多，同时对于可选参数的设置也显得比较语义化。此外，构建者模式另外一个好处就是解决了多个可选参数的问题，当我们创建对象实例时，只需要用set方法对需要的参数进行赋值即可。
+这种链式调用的设计看起来确实优雅了很多，同时对于可选参数的设置也显得比较语义化。此外，构建者模式另外一个好处就是解决了
+多个可选参数的问题，当我们创建对象实例时，只需要用set方法对需要的参数进行赋值即可。
 
 然而，构建者模式也存在一些不足：  
 
@@ -289,7 +306,8 @@ var robot = Robot.Builder("007")
 - 你可能会在使用Builder的时候忘记在最后调用build方法
 - 由于在创建对象的时候，必须先创建它的构造器，因此额外增加了多余的开销，在某些十分注重性能的情况下，可能就存在一定的问题。
 
-事实上，当用Kotlin设计程序时，我们可以在绝大多数情况下避免使用构建者模式。《Effective Java》在介绍构建者模式时，是这样子描述它的：本质上builder模式模拟了具名的可选参数。幸运的是，Kotlin也是这样一门拥有具名可选参数的编程语言。
+事实上，当用Kotlin设计程序时，我们可以在绝大多数情况下避免使用构建者模式。《Effective Java》在介绍构建者模式时，
+是这样子描述它的：本质上builder模式模拟了具名的可选参数。幸运的是，Kotlin也是这样一门拥有具名可选参数的编程语言。
 
 #### 具名的可选参数
 
@@ -330,7 +348,8 @@ private fun main() {
 
 #### require方法对参数进行约束
 
-我们再来看看构建者模式的另外一个作用，就是可以在build方法中对参数添加约束条件。举个例子，假设一个机器人的重量必须根据电池的型号决定，那么在未传入电池型号之前，你便不能对weight属性进行赋值，否则就会抛出异常。现在重新修改一下上面build方法的实现：
+我们再来看看构建者模式的另外一个作用，就是可以在build方法中对参数添加约束条件。举个例子，假设一个机器人的重量必须根据
+电池的型号决定，那么在未传入电池型号之前，你便不能对weight属性进行赋值，否则就会抛出异常。现在重新修改一下上面build方法的实现：
 
 ```kotlin
 fun build(): Robot {
@@ -344,7 +363,8 @@ fun build(): Robot {
 
 这种在build方法中对参数进行约束的手段，可以让业务变得更加安全。那么，通过具名的可选参数来构造类的方案该如何实现呢？ 
 
-显然，我们同样可以在Robot类的init方法中增加以上的校检代码。然而在Kotlin中，我们在类或函数中还可以使用require关键字进行参数限制，本质上它是一个内联的方法，有点类似于Java的assert。 
+显然，我们同样可以在Robot类的init方法中增加以上的校检代码。然而在Kotlin中，我们在类或函数中还可以使用require关键字
+进行参数限制，本质上它是一个内联的方法，有点类似于Java的assert。 
 
 ```kotlin
 class Robot(
@@ -361,22 +381,22 @@ class Robot(
 }
 ```
 
-可见，Kotlin的require方法可以让我们的参数约束代码在语义上变得更加友好。总的来说，在Kotlin中我们应该尽量避免使用构建者模式，因为Kotlin支持具名的可选参数，这让我们可以在构造一个具有多个可选参数类的场景中，设计出更加简洁并利于维护的代码。
-
-
-
+可见，Kotlin的require方法可以让我们的参数约束代码在语义上变得更加友好。总的来说，在Kotlin中我们应该尽量避免使用构建者模式，
+因为Kotlin支持具名的可选参数，这让我们可以在构造一个具有多个可选参数类的场景中，设计出更加简洁并利于维护的代码。
 
 
 ## 观察者模式
 
-观察者模式定义了一个一对多的依赖关系，让一个或多个观察者对象监听一个主题对象。这样一来，当被观察者状态发生改变时，需要通知相应的观察者，使这些观察者对象能够自动更新。
+观察者模式定义了一个一对多的依赖关系，让一个或多个观察者对象监听一个主题对象。这样一来，当被观察者状态发生改变时，
+需要通知相应的观察者，使这些观察者对象能够自动更新。
 
 简单来说，观察者模式无非做两件事情： 
 
 - 订阅者（observer）添加或删除对发布者（publisher）的状态监听。
 - 发布者状态改变时，将事件通知给监听它的所有观察者，然后观察者执行响应逻辑。
 
-Java自身的标准库提供了java.util.Observable类和java.util.Observer接口，来帮助实现观察者模式，接下来我们就采用它们来实现一个动态更新股价的例子。
+Java自身的标准库提供了java.util.Observable类和java.util.Observer接口，来帮助实现观察者模式，接下来我们就采用
+它们来实现一个动态更新股价的例子。
 
 ```kotlin
 class StockUpdate: Observable() {
@@ -400,9 +420,8 @@ fun main(args: Array<String>) {
 }
 ```
 
-上面是通过Kotlin使用Java标准库中的类和方法来实现了观察者模式。事实上，Kotlin的标准库额外引入了可被观察的委托属性，也可以利用它来实现同样的场景。 
-
-我们可以先用这一委托属性来改造以上的程序：  
+上面是通过Kotlin使用Java标准库中的类和方法来实现了观察者模式。事实上，Kotlin的标准库额外引入了可被观察的委托属性，
+也可以利用它来实现同样的场景。我们可以先用这一委托属性来改造以上的程序：  
 
 ```kotlin
 import kotlin.properties.Delegates
@@ -441,9 +460,13 @@ The latest stock price has risen to 100
 The latest stock price has fell to 98
 ```
 
-如果你仔细思考，会发现实现java.util.Observer接口的类只能覆写update方法来编写响应逻辑，也就是说如果存在多种不同的逻辑响应，我们也必须通过在该方法中进行区分实现，显然这会让订阅者的代码显得臃肿。换个角度，如果我们把发布者的事件推送看成一个第三方服务，那么它提供的API接口只有一个，API调用者必须承担更多的职责。
+如果你仔细思考，会发现实现java.util.Observer接口的类只能覆写update方法来编写响应逻辑，也就是说如果存在多种不同的逻辑响应，
+我们也必须通过在该方法中进行区分实现，显然这会让订阅者的代码显得冗余。换个角度，如果我们把发布者的事件推送看成一个第三方服务，
+那么它提供的API接口只有一个，API调用者必须承担更多的职责。
 
-显然，使用Delegates.observable()的方案更加灵活。它提供了三个参数，依次代表委托属性的元数据KProperty对象、旧值以及新值。通过额外定义一个StockUpdateListener接口，我们可以把上涨和下跌的不同响应逻辑封装成接口方法，从而在StockDisplay中实现该接口的onRise和onFall方法，实现了解耦。 
+显然，使用Delegates.observable()的方案更加灵活。它提供了三个参数，依次代表委托属性的元数据KProperty对象、旧值以及新值。
+通过额外定义一个StockUpdateListener接口，我们可以把上涨和下跌的不同响应逻辑封装成接口方法，从而在StockDisplay中
+实现该接口的onRise和onFall方法，实现了解耦。 
 
 
 
diff --git "a/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md" "b/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
index 23458c79..77f1b45e 100644
--- "a/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
+++ "b/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
@@ -1,23 +1,6 @@
-Kotlin之Lambda&内联函数(七)
+2.Kotlin_高阶函数&Lambda&内联函数
 ===
 
-
-
-函数式语言一个典型的特征就在于函数是头等公民-我们不仅可以像类一样在顶层直接定义一个函数，也可以在一个函数内部定义一个函数，例如:  
-
-```kotlin
-fun foo(x: Int) {
-    fun double(y: Int): Int {
-        return y * 2
-    }
-    println(double(x))
-}
-
-执行foo(1)结果为2
-```
-
-
-
 ## 高阶函数
 
 Kotlin天然支持了部分函数式特性。函数式语言一个典型的特征就在于函数是头等公民——我们不仅可以像类一样在底层直接定义一个函数，也可以在一个函数内部定义一个局部函数。 
@@ -33,7 +16,7 @@ fun foo(x: Int) {
 
 ### 抽象和高阶函数
 
-我们会善于对熟悉 或重复的事物进行抽象，比如2岁左右的小孩就会开始认识数字1、2、3....之后，我们总结除了一些公共的行为，如对数字做加减、求立方，这被称为过程，它接收的数字是一种数据，然后也可能产生另一种数据。
+我们会善于对熟悉或重复的事物进行抽象，比如2岁左右的小孩就会开始认识数字1、2、3....之后，我们总结除了一些公共的行为，如对数字做加减、求立方，这被称为过程，它接收的数字是一种数据，然后也可能产生另一种数据。
 
 过程也是一种抽象，几乎我们所熟悉的所有高级语言都包含了定义过程的能力，也就是函数。
 
@@ -131,6 +114,8 @@ class CountryTest {
     (errCode: Int, errMsg: String) -> Unit
     // ?表示可选，可在某种情况下为空
     ((errCode: Int, errMsg: String?) -> Unit)?
+    // 表示传入一个类型为Int的参数，然后返回另一个类型为（Int） -> Unit的函数
+    (Int) -> ((Int) -> Unit) 
     ```
 
     在学习了Kotlin函数类型知识之后，Shaw重新定义了filterCountries方法的参数声明:  
@@ -190,7 +175,19 @@ class Book(val name: String) {
 Book::name
 ```
 
-以上创建的Book::name的类型为(Book) -> String。
+以上创建的Book::name的类型为(Book) -> String。当我们再对Book类对象的集合应用一些函数式API的时候，这会显得格外有用，比如： 
+
+```kotlin
+fun main(args: Array<String>) {
+    val bookNames = listOf (
+        Book("Thinking in java")
+        Book("Dive into Kotlin")    
+    ).map(Book::name)
+    println(bookNames)
+}
+```
+
+
 
 
 
diff --git "a/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md" "b/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md"
index 44f17930..3cab6d55 100644
--- "a/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md"
+++ "b/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md"
@@ -1,4 +1,4 @@
-Kotlin学习教程(三)
+3.Kotlin_数字&字符串&数组&集合
 ===
 
 前面介绍了基本语法和编码规范后，接下来学习下基本类型。  
@@ -314,15 +314,26 @@ val list = listOf(1, 2, 3, 4, 5)
 list.filter {it > 2}.map {it * 2}
 ```
 
-上面的写法很简洁，在处理集合时，类似于上面的操作能够帮助我们解决大部分的问题。但是list中的元素非常多的时候(比如超过10万)，上面的操作在处理集合的时候就会显得比较低效。因为filter方法和map方法都会返回一个新的集合，也就是说上面的操作会产生两个临时集合，因为list会先调用filter方法，然后产生的集合会再次调用map方法。如果list中的元素非常多，这将会是一笔不小的开销。为了解决这一问题，序列(Sequence)就出现了。 
+上面的写法很简洁，在处理集合时，类似于上面的操作能够帮助我们解决大部分的问题。
+但是list中的元素非常多的时候(比如超过10万)，上面的操作在处理集合的时候就会显得比较低效。
+因为filter方法和map方法都会返回一个新的集合，也就是说上面的操作会产生两个临时集合，
+因为list会先调用filter方法，然后产生的集合会再次调用map方法。如果list中的元素非常多，
+这将会是一笔不小的开销。为了解决这一问题，序列(Sequence)就出现了。 
 
 ```kotlin
 list.asSequence().filter {it > 2}.map {it * 2}.toList()
 ```
 
-首先通过asSequence方法将一个列表转换为序列，然后在这个序列上进行相应的操作，最后通过toList方法将序列转为列表。将list转换为序列，在很大程度上就提高了上面操作集合的效率。因为在使用序列的时候filter方法和map方法的操作都没有创建额外的集合，这样当集合中的元素数量巨大的时候，就减少了大部分开销。在Kotlin中，序列中元素的求值是惰性的，这就意味着在利用序列进行链式求值的时候，不需要像操作普通集合那样，每进行一次求值操作，就产生一个新的集合保存中间数据。那么什么惰性又是什么意思呢？
+首先通过asSequence方法将一个列表转换为序列，然后在这个序列上进行相应的操作，最后通过
+toList方法将序列转为列表。将list转换为序列，在很大程度上就提高了上面操作集合的效率。
+因为在使用序列的时候filter方法和map方法的操作都没有创建额外的集合，这样当集合中的元素数量巨大的时候，
+就减少了大部分开销。在Kotlin中，序列中元素的求值是惰性的，这就意味着在利用序列进行链式求值的时候，
+不需要像操作普通集合那样，每进行一次求值操作，就产生一个新的集合保存中间数据。那么什么惰性又是什么意思呢？
 
-在编程语言理论中，惰性求值(Lazy Evaluation)表示一种在需要时才进行求值的计算方式。在使用惰性求值的时候，表达式不在它被绑定到变量之后就立即求值，而是在该值被取用时才去求值。通过这种方式，不仅能得到性能上的提升，还有一个重要的好处就是它可以构造出一个无限的数据类型。
+#### 惰性求值
+在编程语言理论中，惰性求值(Lazy Evaluation)表示一种在需要时才进行求值的计算方式。
+在使用惰性求值的时候，表达式不在它被绑定到变量之后就立即求值，而是在该值被取用时才去求值。
+通过这种方式，不仅能得到性能上的提升，还有一个重要的好处就是它可以构造出一个无限的数据类型。
 
 
 
@@ -351,11 +362,17 @@ list.asSequence().filter {it > 2}.map {it * 2}.toList()
     }
     ```
 
-    上面操作中的println方法根本没有被执行，这说明filter和map方法的执行被延迟了，这就是惰性求值的体现。惰性求值也被称为延迟求值，通过前面的定义我们知道，惰性求值仅仅在该值被需要的时候才会真正去求值。那么这个”被需要“的状态怎么去触发呢？这就需要另外一个操作了-末端操作。
+  上面操作中的println方法根本没有被执行，这说明filter和map方法的执行被延迟了，这就是惰性求值的体现。
+  惰性求值也被称为延迟求值，通过前面的定义我们知道，惰性求值仅仅在该值被需要的时候才会真正去求值。
+  那么这个”被需要“的状态怎么去触发呢？这就需要另外一个操作了-末端操作。
 
 - 末端操作
 
-    在对集合进行操作的时候，大部分情况下，我们在意的只是结果，而不是中间过程。末端操作就是一个返回结果的操作，它的返回值不能是序列，必须是一个明确的结果，比如列表、数字、对象等表意明确的结果。末端操作一般都放在链式操作的末尾，在执行末端操作的时候，会去触发中间操作的延迟计算，也就是将”被需要“这个状态打开了，我们给上面的例子加上末端操作: 
+    在对集合进行操作的时候，大部分情况下，我们在意的只是结果，而不是中间过程。
+  末端操作就是一个返回结果的操作，它的返回值不能是序列，必须是一个明确的结果，
+  比如列表、数字、对象等表意明确的结果。末端操作一般都放在链式操作的末尾，
+  在执行末端操作的时候，会去触发中间操作的延迟计算，也就是将”被需要“这个状态打开了，
+  我们给上面的例子加上末端操作: 
 
     ```kotlin
     list.asSequence().filter {
@@ -377,7 +394,11 @@ list.asSequence().filter {it > 2}.map {it * 2}.toList()
     [6, 8, 10]
     ```
 
-    可以看到，所有的中间操作都被执行了。从上面执行打印的结果我们发现，它的执行顺序与我们预想的不一样。普通集合在进行链式操作的时候会先在list上调用filter，然后产生一个结果列表，接下来map就在这个结果列表上进行操作。而序列则不一样，序列在执行链式操作的时候，会将所有的操作都应用在一个元素上，也就是说，第一个元素执行完所有的操作之后，第二个元素再去执行所有的操作，以此类推。放映到我们这个例子上面，就是第一个元素执行了filter之后再去执行map，然后第二个元素也是这样。
+    可以看到，所有的中间操作都被执行了。从上面执行打印的结果我们发现，它的执行顺序与我们预想的不一样。
+  普通集合在进行链式操作的时候会先在list上调用filter，然后产生一个结果列表，接下来map就在这个结果列表上进行操作。
+  而序列则不一样，序列在执行链式操作的时候，会将所有的操作都应用在一个元素上，也就是说，第一个元素执行完所有的操作之后，
+  第二个元素再去执行所有的操作，以此类推。放到我们这个例子上面，就是第一个元素执行了filter之后再去执行map，
+  然后第二个元素也是这样。
 
 #### 序列可以是无限的
 
@@ -385,13 +406,16 @@ list.asSequence().filter {it > 2}.map {it * 2}.toList()
 
 那接下来，该怎么去实现一个自然数数列呢？采用一般的列表肯定是不行的，因为构造一个列表必须列举出列表中的元素，而我们是没有办法将自然数全部列举出来的。 
 
-我们知道，自然数是有一定规律的，就是最后一个数永远是前一个数加1的结果，我们只需要实现一个列表，让这个列表描述这种规律，那么也就相当于实现了一个无限的自然数数列。好看Kotlin也给我们提供了这样一个方法，去创建无限的数列： 
+我们知道，自然数是有一定规律的，就是最后一个数永远是前一个数加1的结果，我们只需要实现一个列表，让这个列表描述这种规律，那么也就相当于实现了一个无限的自然数数列。
+好在Kotlin也给我们提供了这样一个方法，去创建无限的数列： 
 
 ```kotlin
 val naturalNumList = generateSequence(0) { it + 1}
 ```
 
-通过上面这一行代码，我们就非常简单的实现了自然数数列，上面我们调用了一个方法generateSequence来创建序列。我们知道序列是惰性求值的，所以上面创建的序列是不会把所有的自然数都列举出来的，只有在我们调用一个末端操作的时候，才去列举我们所需要的列表。比如我们要从这个自然数列表中取出前10个自然数：  
+通过上面这一行代码，我们就非常简单的实现了自然数数列，上面我们调用了一个方法generateSequence来创建序列。
+我们知道序列是惰性求值的，所以上面创建的序列是不会把所有的自然数都列举出来的，只有在我们调用一个末端操作的时候，
+才去列举我们所需要的列表。比如我们要从这个自然数列表中取出前10个自然数：  
 
 ```kotlin
 naturalNumList.takeWhile{it <= 9}.toList()
@@ -399,9 +423,6 @@ naturalNumList.takeWhile{it <= 9}.toList()
 ```
 
 
-
-
-
 ### 可`null`类型
 
 
@@ -480,7 +501,7 @@ val email = data["email"] ?: throw IllegalStateException("Email is missing!")
 val l = b!!.length
 ```
 
-因此，如果你想要一个 NPE，你可以得到它，但是你必须显式要求它，否则它不会不期而至。
+因此，如果你想要一个NPE，你可以得到它，但是你必须显式要求它，否则它不会不期而至。
 
 
 #### 安全的类型转换
@@ -540,9 +561,6 @@ loop@ for (i in 1..100) {
 ```
 
 
-
-
-
 [上一篇:Kotlin学习教程(二)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%BA%8C).md)         
 [下一篇:Kotlin学习教程(四)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E5%9B%9B).md)
 
diff --git "a/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md" "b/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md"
index 43178b4e..f2196189 100644
--- "a/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md"
+++ "b/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md"
@@ -1,4 +1,4 @@
-Kotlin学习教程(四)
+4.Kotlin_表达式&关键字
 ===
 
 ## `if`表达式
@@ -18,8 +18,8 @@ val max = if (a > b) {
 
 ## `when`表达式
 
-`when`表达式与`Java`中的`switch/case`类似，但是要强大得多。这个表达式会去试图匹配所有可能的分支直到找到满意的一项。然后它会运行右边的表达
-式。      
+`when`表达式与`Java`中的`switch/case`类似，但是要强大得多。这个表达式会去试图匹配所有可能的分支直到找到满意的一项。
+然后它会运行右边的表达式。      
 与`Java`的`switch/case`不同之处是参数可以是任何类型，并且分支也可以是一个条件。
 
 对于默认的选项，我们可以增加一个`else`分支，它会在前面没有任何条件匹配时再执行。条件匹配成功后执行的代码也可以是代码块:     
@@ -90,7 +90,8 @@ fun schedule(sunny: Boolean, day: Day) = when (day) {
 }
 ```
 
-一个完整的when表达式类似switch语句，由when关键字开始，用花括号包含多个逻辑分支，每个分支由-> 连接，不再需要switch的break(这真是一个恼人的关键字)，由上往下匹配，一直匹配完为止，否则执行else分支的逻辑，类似switch的default。
+一个完整的when表达式类似switch语句，由when关键字开始，用花括号包含多个逻辑分支，每个分支由-> 连接，
+不再需要switch的break(这真是一个恼人的关键字)，由上往下匹配，一直匹配完为止，否则执行else分支的逻辑，类似switch的default。
 
 到这里你可能会说上面的例子中，这样嵌套子when表达式，层次依旧比较深。要知道when表达式是很灵活的，我们很容易通过如下修改来解决这个问题:  
 
@@ -179,7 +180,7 @@ for(num in nums) {
 
 
 
-上面in、step、downTo、until这几个，他们可以不通过点号，而是通过中缀表达式来被调用，从而让语法变得更加简洁直观。
+上面in、step、downTo、until这几个，他们可以不通过点号，而是通过**中缀表达式**来被调用，从而让语法变得更加简洁直观。
 
 
 
@@ -187,8 +188,8 @@ for(num in nums) {
 
 - `var`：定义变量
 - `val`：定义常量
-- `fun`：定义方法
-- `Unit`：默认方法返回值，类似于`Java`中的`void`，可以理解成返回没什么用的值
+- `fun`：定义函数
+- `Unit`：默认方法返回值，类似于`Java`中的`void`，可以理解成返回没什么用的值类型
 - `vararg`：可变参数
 - `$`：字符串模板(取值)
 - 位运算符：`or`(按位或)，`and`(按位与)，`shl`(有符号左移)，`shr`(有符号右移)，
diff --git "a/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md" "b/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
index 4bcc58cc..d6ea8ce6 100644
--- "a/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
+++ "b/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
@@ -1,4 +1,4 @@
-Kotlin学习教程(五)
+5.Kotlin_内部类&密封类&枚举&委托
 ===
 
 
@@ -97,9 +97,11 @@ outter.Inner().execute()
 
 #### 内部类vs嵌套类
 
-在Java中，我们通过在内部类的语法上增加一个static关键词，把它变成一个嵌套类。然而，Kotlin则是相反的思路，默认是一个嵌套类，必须加上inner关键字才是一个内部类，也就是说可以把静态的内部类看成嵌套类。
+在Java中，我们通过在内部类的语法上增加一个static关键词，把它变成一个嵌套类。然而，Kotlin则是相反的思路，默认是一个嵌套类，
+必须加上inner关键字才是一个内部类，也就是说可以把静态的内部类看成嵌套类。
 
-内部类和嵌套类有明显的差别，具体体现在：内部类包含着对其外部类实例的引用，在内部类中我们可以使用外部类中的属性。而在嵌套类中不包含对其外部类实例的引用，所以它无法调用其外部类的属性。
+内部类和嵌套类有明显的差别，具体体现在：
+- 内部类包含着对其外部类实例的引用，在内部类中我们可以使用外部类中的属性。而在嵌套类中不包含对其外部类实例的引用，所以它无法调用其外部类的属性。
 
 
 
@@ -180,7 +182,8 @@ sealed class Bird {
 }
 ```
 
-Kotlin通过sealed关键字来修饰一个类为密封类，若要继承则需要将子类定义在同一个文件中，其他文件中的类将无法继承他。但这种方式也有它的局限性。即它不能被初始化，因为它背后是基于一个抽象类实现的，这一点可以从它转换后的Java代码看出:  
+Kotlin通过sealed关键字来修饰一个类为密封类，若要继承则需要将子类定义在同一个文件中，其他文件中的类将无法继承他。
+但这种方式也有它的局限性。即它不能被初始化，因为它背后是基于一个抽象类实现的，这一点可以从它转换后的Java代码看出:  
 
 ```java
 public abstract class Bird {
@@ -206,7 +209,6 @@ public abstract class Bird {
 ```
 
 
-
 密封类用来表示受限的类继承结构:当一个值为有限集中的
 类型、而不能有任何其他类型时。在某种意义上，他们是枚举类的扩展:枚举类型的值集合
 也是受限的，但每个枚举常量只存在一个实例，而密封类
@@ -279,9 +281,40 @@ val s = try { x as String } catch(e: ClassCastException) { null }
 
 ### 对象`(Object)`
 
-在Java中，static是非常重要的特性，它可以用来修饰类、方法或属性。然而static修饰的内容都属于类的，而不是某个具体对象的，但在定义时却与普通的变量和方法混杂在一起，显得格格不入。 
+在Java中，static是非常重要的特性，它可以用来修饰类、方法或属性。然而static修饰的内容都属于类的，而不是某个具体对象的，
+但在定义时却与普通的变量和方法混杂在一起，显得格格不入。 
+
+在Kotlin中，你将告别static这种语法，因为它引入了全新的关键字object，可以完美的代替使用static的所有场景。
+当然除了代替static的场景之外，它还能实现更多的功能，比如单例对象及简化匿名表达式等。 
+
+声明对象就如同声明一个类，你只需要用保留字`object`替代`class`，其他都相同。只需要考虑到对象不能有构造函数，因为我们不调用任何构造函数来访问
+它们。事实上，对象就是具有单一实现的数据类型。object声明的内容可以看成没有构造方法的类，它会在系统或者类加载时进行初始化。
+
+```kotlin
+object Resource {
+    val name = "Name"
+}
+```
+
+### 对象表达式
+
+对象也能用于创建匿名类实现。
+
+```java
+recycler.adapter = object : RecyclerView.Adapter() {
+    override fun onBindViewHolder(holder: RecyclerView.ViewHolder?, position: Int) {
+    }
+ 
+    override fun getItemCount(): Int {
+    }
+ 
+    override fun onCreateViewHolder(parent: ViewGroup?, viewType: Int): RecyclerView.ViewHolder {
+    }
+}
+```
+例如，每次想要创建一个接口的内联实现，或者扩展另一个类时，你将使用上面的符号。
 
-在Kotlin中，你将告别static这种语法，因为它引入了全新的关键字object，可以完美的代替使用static的所有场景。当然除了代替static的场景之外，它还能实现更多的功能，比如单例对象及简化匿名表达式等。 
+object表达式和匿名内部类很像，那对象表达式与Lambda表达式哪个更适合代替匿名内部类呢？  当你的匿名内部类使用的类接口只需要实现一个方法时，使用Lambda表达式更适合。当匿名内部类内有多个方法实现的时候，使用object表达式更适合。
 
 #### 伴生对象
 
@@ -313,11 +346,15 @@ public class Prize {
 }
 ```
 
-上面是很常见的Java代码，也许你已经习惯了，但是如果仔细思考，会发现这种语法其实并不是非常好。因为在一个类中既有静态变量、静态方法，也有普通变量、普通方法的声明。然而，静态变量和静态方法是属于一个类的，普通变量、普通方法是属于一个具体对象的。虽然有static作为区分，然而在代码结构上职能并不是区分得很清晰。 
+上面是很常见的Java代码，也许你已经习惯了，但是如果仔细思考，会发现这种语法其实并不是非常好。因为在一个类中既有静态变量、静态方法，
+也有普通变量、普通方法的声明。然而，静态变量和静态方法是属于一个类的，普通变量、普通方法是属于一个具体对象的。
+虽然有static作为区分，然而在代码结构上职能并不是区分得很清晰。 
 
-那么，有没有一种方式能将这两部分代码清晰的分开，但又不失语义化呢？Kotlin中引入了伴生对象的概念，简单来说，这是一种利用companion object两个关键字创造的语法。 
+那么，有没有一种方式能将这两部分代码清晰的分开，但又不失语义化呢？Kotlin中引入了伴生对象的概念，简单来说，
+这是一种利用companion object两个关键字创造的语法。 
 
-伴生对象：“伴生”是相较于一个类而言的，意为伴随某个类的对象，它属于这个类所有，因此伴生对象跟Java中static修饰效果性质一样，全局只有一个单例。它需要声明在类的内部，在类被装载时会被初始化。 
+伴生对象：“伴生”是相较于一个类而言的，意为伴随某个类的对象，它属于这个类所有，因此伴生对象跟Java中static修饰效果性质一样，
+全局只有一个单例。它需要声明在类的内部，在类被装载时会被初始化。 
 
 现在将上面的例子改写成伴生对象的版本:   
 
@@ -339,7 +376,8 @@ class Prize(val name: String, val count: Int, val type: Int) {
 }
 ```
 
-可以发现，该版本在语义上更清晰了。而且，companion object用花括号包裹了所有静态属性和方法，使得它可以与Prize类的普通方法和属性清晰的区分开来。最后，我们可以使用点号来对一个类的静态的成员进行调用。  
+可以发现，该版本在语义上更清晰了。而且，companion object用花括号包裹了所有静态属性和方法，使得它可以与Prize类的普通
+方法和属性清晰的区分开来。最后，我们可以使用点号来对一个类的静态的成员进行调用。  
 
 伴生对象的另一个作用是可以实现工厂方法模式。前面也说过如何从构造方法实现工厂方法模式，然而这种方法存在以下缺点:  
 
@@ -370,19 +408,28 @@ class Prize private constructor(val name: String, val count: Int, val type: Int)
 }
 ```
 
-总的来说，伴生对象是Kotlin中用来代替static关键字的一种方式，任何在Java类内部用static定义的内容都可以用Kotlin中的伴生对象来实现。然而，他们是类似的，一个类的伴生对象跟一个静态类一样，全局只能有一个。
+总的来说，伴生对象是Kotlin中用来代替static关键字的一种方式，任何在Java类内部用static定义的内容都可以用Kotlin中的伴生对象来实现。
+然而，他们是类似的，一个类的伴生对象跟一个静态类一样，全局只能有一个。
 
-
-
-声明对象就如同声明一个类，你只需要用保留字`object`替代`class`，其他都相同。只需要考虑到对象不能有构造函数，因为我们不调用任何构造函数来访问
-它们。事实上，对象就是具有单一实现的数据类型。object声明的内容可以看成没有构造方法的类，它会在系统或者类加载时进行初始化。
-
-```kotlin
-object Resource {
-    val name = "Name"
+每个类都可以实现一个伴生对象，它是该类的所有实例共有的对象。它将类似于`Java`中的静态字段。
+```java
+class App : Application() {
+    companion object {
+         lateinit var instance: App
+             private set
+     }
+ 
+     override fun onCreate() {
+         super.onCreate()
+         instance = this
+    }
 }
 ```
 
+在这例子中，创建一个由`Application`扩展的（派送）的类，并且在`companion object`中存储它的唯一实例。     
+`lateinit`表示这个属性开始是没有值得，但是，在使用前将被赋值（否则，就会抛出异常）。     
+`private set`用于说明外部类不能对其进行赋值。
+
 ### 单例
 
 因为一个类的伴生对象跟一个静态类一样，全局只能有一个。这让我们联想到了什么？ 没错，就是单例对象。
@@ -393,7 +440,8 @@ object Resource {
 }
 ```
 
-因为对象就是具有单一实现的数据类型，所以在`kotlin`中对象就是单例。   单例对象会在系统加载的时候初始化，当然全局只有一个，所以它是饿汉式的单例。
+因为对象就是具有单一实现的数据类型，所以在`kotlin`中对象就是单例。   
+单例对象会在系统加载的时候初始化，当然全局只有一个，所以它是饿汉式的单例。
 
 看一下自动生成的java代码: 
 
@@ -439,50 +487,6 @@ public static Instance getInstance() {
 
 具体可以看: [Kotlin Object Declarations Are Initialized in Static Block](https://hanru-yeh.medium.com/kotlin-object-declarations-are-initialized-in-static-block-5e1c2e1c3401)
 
-### 对象表达式
-
-对象也能用于创建匿名类实现。
-
-```java
-recycler.adapter = object : RecyclerView.Adapter() {
-    override fun onBindViewHolder(holder: RecyclerView.ViewHolder?, position: Int) {
-    }
- 
-    override fun getItemCount(): Int {
-    }
- 
-    override fun onCreateViewHolder(parent: ViewGroup?, viewType: Int): RecyclerView.ViewHolder {
-    }
-}
-```
-例如，每次想要创建一个接口的内联实现，或者扩展另一个类时，你将使用上面的符号。
-
-object表达式和匿名内部类很像，那对象表达式与Lambda表达式哪个更适合代替匿名内部类呢？  当你的匿名内部类使用的类接口只需要实现一个方法时，使用Lambda表达式更适合。当匿名内部类内有多个方法实现的时候，使用object表达式更适合。
-
-
-
-
-### 伴生对象`(Companion Object)`
-
-每个类都可以实现一个伴生对象，它是该类的所有实例共有的对象。它将类似于`Java`中的静态字段。
-```java
-class App : Application() {
-    companion object {
-         lateinit var instance: App
-             private set
-     }
- 
-     override fun onCreate() {
-         super.onCreate()
-         instance = this
-    }
-}
-```
-
-在这例子中，创建一个由`Application`扩展的（派送）的类，并且在`companion object`中存储它的唯一实例。     
-`lateinit`表示这个属性开始是没有值得，但是，在使用前将被赋值（否则，就会抛出异常）。     
-`private set`用于说明外部类不能对其进行赋值。   
-
 
 ### 委托(代理)
 
diff --git "a/KotlinCourse/6.Kotlin_\345\244\232\347\273\247\346\211\277\351\227\256\351\242\230.md" "b/KotlinCourse/6.Kotlin_\345\244\232\347\273\247\346\211\277\351\227\256\351\242\230.md"
index 7017a62f..29bd7403 100644
--- "a/KotlinCourse/6.Kotlin_\345\244\232\347\273\247\346\211\277\351\227\256\351\242\230.md"
+++ "b/KotlinCourse/6.Kotlin_\345\244\232\347\273\247\346\211\277\351\227\256\351\242\230.md"
@@ -1,4 +1,4 @@
-Kotlin学习教程之多继承问题
+6.Kotlin_多继承问题
 ===
 
 
@@ -191,16 +191,6 @@ fun main(args: Array<String>) {
 
 
 
-
-
-
-
-
-
-
-
-
-
 [上一篇:Kotlin学习教程(七)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%B8%83).md)         
 [下一篇:Kotlin学习教程(八)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E5%85%AB).md)
 
diff --git "a/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md" "b/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md"
index fdbd19e2..42330826 100644
--- "a/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md"
+++ "b/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md"
@@ -1,4 +1,4 @@
-Kotlin学习教程(六)
+7.Kotlin_注解&反射&扩展
 ===
 
 ### 注解  
@@ -79,9 +79,20 @@ val numbers = listOf(1, 2, 3)
 println(numbers.filter(::isOdd)) // 输出 [1, 3]
 ```
 
-### 扩展
+## 扩展
 
-扩展是`kotlin`中非常重要的一个特性，它能让我们对一些已有的类进行功能增加、简化，使他们更好的应对我们的需求。
+扩展是`kotlin`中非常重要的一个特性，扩展函数允许我们在不改变已有类的情况下，为类添加新的函数。
+扩展函数是指对类的方法进行扩展，写法和定义方法类似，但是要声明目标类，也就是对哪个类进行扩展，`kotlin`中称之为`Top Level`。
+扩展函数表现得就像是属于这个类的一样，而且我们可以使用`this`关键字和调用所有`public`方法。
+扩展函数可以在已有类中添加新的方法，不会对原类做修改，扩展函数定义形式:
+```kotlin
+fun receiverType.functionName(params){
+    body
+}
+receiverType：表示函数的接收者，也就是函数扩展的对象
+functionName：扩展函数的名称
+params：扩展函数的参数，可以为NULL
+```
 
 ```kotlin
 //  对Context的扩展，增加了toast方法。为了更好的看到效果，我还加了一段log日志
@@ -102,25 +113,10 @@ class MainActivity : AppCompatActivity() {
 Toast msg : hello, Extension
 ```
 
-按照通常的做法，会写一个`ToastUtils`工具类，或者在`BaseActivity`中实现`toast`。但是使用扩展函数就会简单很。 
-上面的例子就是在`Context`中添加新的方法，让我们以更简单的方式去显示`toast`，并且不用传入任何`context`参数，可以被任何`Context`或者
-它的子类调用。我们可以在任何地方(例如一个工具类文件中)声明这个函数，然后在`Activity`中将它作为普通方法来直接调用。当然了`Anko`中已经包括了
-自己的`toast`扩展函数。有关`Anko`后面会讲到。
-
-`Kotlin`扩展函数允许我们在不改变已有类的情况下，为类添加新的函数。
-扩展函数是指对类的方法进行扩展，写法和定义方法类似，但是要声明目标类，也就是对哪个类进行扩展，`kotlin`中称之为`Top Level`。
-扩展函数表现得就像是属于这个类的一样，而且我们可以使用`this`关键字和调用所有`public`方法。
-扩展函数可以在已有类中添加新的方法，不会对原类做修改，扩展函数定义形式:   
-```kotlin
-fun receiverType.functionName(params){
-    body
-}
-receiverType：表示函数的接收者，也就是函数扩展的对象
-functionName：扩展函数的名称
-params：扩展函数的参数，可以为NULL
-```
-
-在上面我们举的扩展的例子就是扩展函数.其中`Context`就是目标类`Top Level`，我们把它放到方法名前，用点`.`表示从属关系。在方法体中用关键字
+按照通常的做法，会写一个`ToastUtils`工具类，或者在`BaseActivity`中实现`toast`。但是使用扩展函数就会简单很多。 
+上面的例子就是在`Context`中添加新的方法，让我们以更简单的方式去显示`toast`，并且不用传入任何`context`参数，
+可以被任何`Context`或者它的子类调用。我们可以在任何地方(例如一个工具类文件中)声明这个函数，然后在`Activity`中将
+它作为普通方法来直接调用。其中`Context`就是目标类`Top Level`，我们把它放到方法名前，用点`.`表示从属关系。在方法体中用关键字
 `this`对本体进行调用。和普通方法一样，如果有返回值，在方法后面跟上返回类型，我这里没有返回值，所以直接省略了。
 
 扩展函数的原理: 通过查看对应的Java代码可以发现:  
@@ -135,8 +131,6 @@ fun MutableList<Int>.exchange(fromIndex: Int, toIndex: Int) {
 }
 ```
 
-
-
 ```java
 package com.st.stplayer.extension;
 
@@ -162,10 +156,8 @@ public final class ExtenndsKt {
 }
 ```
 
-通过上面的Java代码可以看出，我们可以将扩展函数理解为静态方法。而静态方法的特点是：它独立于该类的任何对象，且不依赖类的特定实例，被该类的所有实例共享。此外，被public修饰的静态方法本质上也就是全局方法。所以扩展函数不会带来额外的性能消耗。
-
-
-
+通过上面的Java代码可以看出，我们可以将扩展函数理解为静态方法。而静态方法的特点是：它独立于该类的任何对象，且不依赖类的特定实例，
+被该类的所有实例共享。此外，被public修饰的静态方法本质上也就是全局方法。所以扩展函数不会带来额外的性能消耗。
 
 
 ##### 扩展函数的作用域
@@ -175,7 +167,6 @@ public final class ExtenndsKt {
 ```kotlin
 package com.charon.ext
 
-...
 val View.isVisible: Boolean 
     get() = visibility == View.VISIBLE
 
@@ -204,7 +195,8 @@ fun View.toBitmap(): Bitmap? {
 }
 ```
 
-我们知道在同一个包内是可以直接调用exchange方法的。如果需要在其他包中调用，只需要import相应的方法即可，这与调用Java全局静态方法类似。除此之外，实际开发时我们也可能会将扩展函数定义在一个Class内部统一管理:  
+我们知道在同一个包内是可以直接调用exchange方法的。如果需要在其他包中调用，只需要import相应的方法即可，这与调用Java全局静态方法类似。
+除此之外，实际开发时我们也可能会将扩展函数定义在一个Class内部统一管理:  
 
 ```kotlin
 class Extends {
@@ -216,7 +208,8 @@ class Extends {
 }
 ```
 
-当扩展函数定义在Extends类内部时，情况就与之前不一样了，这个时候你会发现，之前的exchange方法无法调用了(之前调用位置在Extends类外部)。借助IDEA我们可以查看到它对应的Java代码，这里展示关键部分:  
+当扩展函数定义在Extends类内部时，情况就与之前不一样了，这个时候你会发现，之前的exchange方法无法调用了(之前调用位置在Extends类外部)。
+借助IDEA我们可以查看到它对应的Java代码，这里展示关键部分:  
 
 ```java
 public static final class Extends {
@@ -241,7 +234,7 @@ class Son {
 }
 ```
 
-它包含一个成员方法foo()，加入我们哪天心血来潮，想对这个方法做特殊实现，利用扩展函数可能会写出如下代码:  
+它包含一个成员方法foo()，假如哪天心血来潮，想对这个方法做特殊实现，利用扩展函数可能会写出如下代码:  
 
 ```kotlin
 fun Son.foo() = println("son called extension foo")
@@ -254,9 +247,11 @@ object Test {
 }
 ```
 
-在我们的预期中，我们希望调用的是扩展函数foo()，但是输出的结果为: son called member foo。这表明当扩展函数和现有类的成员方法同时存在时，Kotlin将会默认使用类的成员方法。看起来似乎不够合理，并且很容易引发一些问题：我定义了新的方法，为什么还是调用了旧的方法？
+在我们的预期中，我们希望调用的是扩展函数foo()，但是输出的结果为: son called member foo。这表明当扩展函数和现有类的成员方法同时存在时，
+Kotlin将会默认使用类的成员方法。看起来似乎不够合理，并且很容易引发一些问题：我定义了新的方法，为什么还是调用了旧的方法？
 
-但是换一个角度来思考，在多人开发的时候，如果每个人都对Son扩展了foo方法，是不是很容易造成混淆。对于第三方类库来说甚至是一场灾难：我们把不应该更改的方法改变了。所以在使用时，我们必须注意： 同名的类成员方法的优先级总高于扩展函数。
+但是换一个角度来思考，在多人开发的时候，如果每个人都对Son扩展了foo方法，是不是很容易造成混淆。对于第三方类库来说甚至是一场灾难：
+我们把不应该更改的方法改变了。所以在使用时，我们必须注意：**同名的类成员方法的优先级总高于扩展函数**。
 
 
 
@@ -293,7 +288,7 @@ fun ImageView.loadImage(url: String) {
 }
 ```
 
-这样在调用的时候，不仅省去了更多的参数，而且ImageView的声明周期也得到了保证。
+这样在调用的时候，不仅省去了更多的参数，而且ImageView的生命周期也得到了保证。
 
 在实际项目中，我们还需要考虑网络请求框架替换及维护的问题，一般会对图片的请求框架进行二次封装: 
 
@@ -411,7 +406,8 @@ fun testFoo() {
 
 这个范围函数本身似乎不是很有用。但是相比范围，还有一点不错的是，它返回范围内最后一个对象。
 
-例如现在有这么一个场景：用户点击领取新人奖励的按钮，如果用户此时没有登陆则弹出loginDialog，如果已经登录则弹出领取奖励的getNewAccountDialog。我们可以使用以下代码来处理这个逻辑： 
+例如现在有这么一个场景：用户点击领取新人奖励的按钮，如果用户此时没有登陆则弹出loginDialog，
+如果已经登录则弹出领取奖励的getNewAccountDialog。我们可以使用以下代码来处理这个逻辑： 
 
 ```kotlin
 run {
@@ -419,8 +415,6 @@ run {
 }.show()
 ```
 
-
-
 2. apply
 
 `apply`函数是这样的，调用某对象的`apply`函数，在函数范围内，可以任意调用该对象的任意方法，并返回该对象.
@@ -450,8 +444,6 @@ let函数和apply函数很像，唯一不同的是返回值。apply返回的是
 public inline fun <T, R> T.let(block: (T) -> R): R = block(this)
 ```
 
-
-
 如果对象的值不为空，则允许执行这个方法。返回值是函数里面最后一行，或者指定return，与run一样，它同样限制了变量的作用域。
 
 ```kotlin
@@ -513,7 +505,6 @@ class Kot {
 ```
 
 
-
 #### `sNullOrEmpty | isNullOrBlank`
 
 ```kotlin
@@ -591,18 +582,6 @@ Hello world
 Hello world
 ```
 
-#### also
-
-also是kotlin 1.1版本中新加入的内容，它像是let和apply函数的加强版:  
-
-```kotlin
-public inline fun <T> T.also(block: (T) -> Unit): T {
-    block(this); return this
-}
-```
-
-与apply一致，它的返回值是该函数的接收者。
-
 ### 调度方式对扩展函数的影响
 
 Kotlin是一种静态类型语言，我们创建的每个对象不仅具有运行时，还具有编译时类型。在使用扩展函数时，要清楚地了解静态和动态调度之间的区别。
@@ -649,10 +628,10 @@ public static void main(String[] args) {
 在这种情况下，即使base本质上是Extended的实例，最终还是会执行Base的方法。
 
 
-
 #### 扩展函数始终静态调度
 
-可能你会好奇，这和扩展有什么关系？我们知道，扩展函数都有一个接收器(receiver)，由于接收器实际上只是字节代码中编译方法的参数，因此你可以重载它。但不能覆盖它。这可能是成员和扩展函数之间最重要的区别：前者是动态调度的，后者总是静态调度的。
+可能你会好奇，这和扩展有什么关系？我们知道，扩展函数都有一个接收器(receiver)，由于接收器实际上只是字节代码中编译方法的参数，
+因此你可以重载它。但不能覆盖它。这可能是成员和扩展函数之间最重要的区别：前者是动态调度的，后者总是静态调度的。
 
 为了方便理解，举一个例子:  
 
@@ -675,12 +654,10 @@ I'm Extended.foo!
 由于只考虑了编译时类型，第一个打印将调用Base.foo()，而第二个打印将调用Extended.foo()。
 
 
-
-
-
 ## 用扩展函数封装Utils
 
-在Java中，我们习惯将常用的代码放到对应的工具类中，例如ToastUtils、NetworkUtils、ImageLoaderUtils等。以NetworkUtils为例，该类中我们通常会放入Android经常需要使用的网络相关方法。比如，我们现在有一个判断手机网络是否可用的方法:  
+在Java中，我们习惯将常用的代码放到对应的工具类中，例如ToastUtils、NetworkUtils、ImageLoaderUtils等。
+以NetworkUtils为例，该类中我们通常会放入Android经常需要使用的网络相关方法。比如，我们现在有一个判断手机网络是否可用的方法:  
 
 ```java
 public class NetworkUtils {
@@ -703,13 +680,16 @@ public class NetworkUtils {
 boolean isConnected = NetworkUtils.isMobileConnected(context);
 ```
 
-虽然用起来比没有封装之前优雅了很多，但是每次都要传入context，造成的烦琐我们先不计较，重要是可能会让调用者忽视context和mobileNetwork间的强关系。作为代码的使用者，我们更希望在调用时省略NetworkUtils类名，并且让isMobileConnected可以看起来像context的一个属性或方法。我们期望的是下面这样的使用方式: 
+虽然用起来比没有封装之前优雅了很多，但是每次都要传入context，造成的烦琐我们先不计较，重要是可能会让调用者忽视context
+和mobileNetwork间的强关系。作为代码的使用者，我们更希望在调用时省略NetworkUtils类名，并且让isMobileConnected可以
+看起来像context的一个属性或方法。我们期望的是下面这样的使用方式: 
 
 ```java
 boolean isConnected = context.isMobileConnected();
 ```
 
-由于Context是Android SDK自带的类，我们无法对其进行修改。在Java中目前只能通过继承Context新增静态成员方法来实现。但是在Kotlin中，我们通过扩展函数就能简单的实现:  
+由于Context是Android SDK自带的类，我们无法对其进行修改。在Java中目前只能通过继承Context新增静态成员方法来实现。
+但是在Kotlin中，我们通过扩展函数就能简单的实现:  
 
 ```kotlin
 fun Context.isMobileConnected(): Boolean {
@@ -727,23 +707,25 @@ fun Context.isMobileConnected(): Boolean {
 val isConnected = context.isMobileConnected();
 ```
 
-值得一提的是，在Android中对Context的生命周期需要进行很好的把控。这里我们应该使用ApplicationContext，防止出现声明周期不一致导致的内存泄露或者其他问题。
+值得一提的是，在Android中对Context的生命周期需要进行很好的把控。这里我们应该使用ApplicationContext，
+防止出现生命周期不一致导致的内存泄露或者其他问题。
 
 
 
 ## 运算符重载
 
-  Kotlin允许我们对所有的运算符(+ - * / % ++ --)，以及其他关键字进行重载，从而拓展这些运算符与关键字的用法。
+Kotlin允许我们对所有的运算符(+ - * / % ++ --)，以及其他关键字进行重载，从而拓展这些运算符与关键字的用法。
 
 语法：运算符重载使用的是operator关键字，在指定函数的前面加上operator关键字，就可以实现运算符重载了。
-指定函数，不同的运算符对应的重载函数是不同的，比如：+ 对应plus()  - 对应minus()
+指定函数，不同的运算符对应的重载函数是不同的，比如：+ 对应plus() 、 - 对应minus()
 可以在类中，对同一运算符进行多次重载，来满足不同的需求。
 
-运算符重载实际上是函数重载，本质上是对运算符函数的调用，从运算符到对应函数的映射过程由编译器完成。或者理解成是对已有的运算符赋予他们新的含义。重载的修饰符是operator。
+运算符重载实际上是函数重载，本质上是对运算符函数的调用，从运算符到对应函数的映射过程由编译器完成。
+或者理解成是对已有的运算符赋予他们新的含义。
 
 举例： 
 
-比如我们的+号，它的含义是两个数值相加：  1+1 = 2。 +号对应的函数名是plus。我们可以对+号这个函数进行重载，让它实现减法的效果。 
+比如我们的+号，它的含义是两个数值相加： 1 + 1 = 2。 +号对应的函数名是plus。我们可以对+号这个函数进行重载，让它实现减法的效果。 
 
 下面我们实现一个Person数据类，然后重载Int的 + 号运算符，让一个Int对象可以直接和Person对象相加。返回的结果是这个Int对象减去Person对象的age的值。
 
@@ -846,6 +828,243 @@ fun main() {
 
 
 
+#### 函数引用
+
+当我们有一个命名函数声明如下:   
+
+```kotlin
+fun isOdd(x: Int) = x % 2 != 0
+```
+
+我们可以很容易地直接调用它`(isOdd(5))`，但是我们也可以把它作为一个值传递。例如传给另一个函数。
+为此，我们使用`::`操作符:   
+
+```kotlin
+val numbers = listOf(1, 2, 3)
+println(numbers.filter(::isOdd)) // 输出 [1, 3]
+```
+
+这里`::isOdd`是函数类型`(Int) -> Boolean`的一个值。
+
+当上下文中已知函数期望的类型时`::`可以用于重载函数。
+
+例如:      
+
+```kotlin
+fun isOdd(x: Int) = x % 2 != 0
+fun isOdd(s: String) = s == "brillig" || s == "slithy" || s == "tove"
+
+val numbers = listOf(1, 2, 3)
+println(numbers.filter(::isOdd)) // 引用到 isOdd(x: Int)
+```
+
+或者，你可以通过将方法引用存储在具有显式指定类型的变量中来提供必要的上下文:   
+
+```kotlin
+val predicate: (String) -> Boolean = ::isOdd   // 引用到 isOdd(x: String)
+```
+
+如果我们需要使用类的成员函数或扩展函数，它需要是限定的。
+例如`String::toCharArray`为类型`String`提供了一个扩展函数:`String.() -> CharArray`。
+
+
+#### 属性引用
+
+要把属性作为`Kotlin`中的一等对象来访问，我们也可以使用`::`运算符:    
+
+```kotlin
+var x = 1
+
+fun main(args: Array<String>) {
+    println(::x.get()) // 输出 "1"
+    ::x.set(2)
+    println(x)         // 输出 "2"
+}
+```
+
+表达式`::x`求值为`KProperty<Int>`类型的属性对象，它允许我们使用
+`get()`读取它的值，或者使用`name`属性来获取属性名。更多信息请参见
+关于`KProperty`类的文档。
+
+对于可变属性，例如`var y = 1`，`::y`返回`KMutableProperty<Int>`类型的一个值，
+该类型有一个`set()`方法。
+
+属性引用可以用在不需要参数的函数处:   
+
+```kotlin
+val strs = listOf("a", "bc", "def")
+println(strs.map(String::length)) // 输出 [1, 2, 3]
+```
+
+要访问属于类的成员的属性，我们这样限定它:   
+
+```kotlin
+class A(val p: Int)
+
+fun main(args: Array<String>) {
+    val prop = A::p
+    println(prop.get(A(1))) // 输出 "1"
+}
+```
+
+
+## Kotlin类型别名
+
+类型别名为现有类型提供替代名称。
+如果类型名称太长，你可以另外引入较短的名称，并使用新的名称替代原类型名。
+
+它有助于缩短较长的泛型类型。
+例如，通常缩减集合类型是很有吸引力的:    
+
+```kotlin
+typealias NodeSet = Set<Network.Node>
+
+typealias FileTable<K> = MutableMap<K, MutableList<File>>
+```
+
+你可以为函数类型提供另外的别名:   
+
+```kotlin
+typealias MyHandler = (Int, String, Any) -> Unit
+
+typealias Predicate<T> = (T) -> Boolean
+```
+
+你可以为内部类和嵌套类创建新名称：
+
+```kotlin
+class A {
+    inner class Inner
+}
+class B {
+    inner class Inner
+}
+
+typealias AInner = A.Inner
+typealias BInner = B.Inner
+```
+
+
+类型别名不会引入新类型。
+它们等效于相应的底层类型。
+当你在代码中添加`typealias Predicate<T>`并使用`Predicate<Int>`时，`Kotlin`编译器总是把它扩展为`(Int) -> Boolean`。
+因此，当你需要泛型函数类型时，你可以传递该类型的变量，反之亦然:    
+
+```kotlin
+typealias Predicate<T> = (T) -> Boolean
+
+fun foo(p: Predicate<Int>) = p(42)
+
+fun main(args: Array<String>) {
+    val f: (Int) -> Boolean = { it > 0 }
+    println(foo(f)) // 输出 "true"
+
+    val p: Predicate<Int> = { it > 0 }
+    println(listOf(1, -2).filter(p)) // 输出 "[1]"
+}
+```
+
+
+## 文档
+
+用来编写`Kotlin`代码文档的语言(相当于`Java`的`JavaDoc`)称为`KDoc`。本质上`KDoc`是将`JavaDoc`的块标签`(block tags)`语法(
+扩展为支持`Kotlin`的特定构造)和`Markdown`的内联标记`(inline markup)`结合在一起。
+
+
+#### 生成文档    
+
+`Kotlin`的文档生成工具称为[Dokka](https://github.com/Kotlin/dokka)。
+
+`Dokka`有`Gradle`、`Maven`和`Ant`的插件，因此你可以将文档生成集成到你的构建过程中。
+
+
+像`JavaDoc`一样，`KDoc`注释也以`/**`开头、以`*/`结尾。注释的每一行可以以
+星号开头，该星号不会当作注释内容的一部分。
+
+按惯例来说，文档文本的第一段(到第一行空白行结束)是该元素的
+总体描述，接下来的注释是详细描述。
+
+每个块标签都以一个新行开始且以`@`字符开头。
+
+以下是使用`KDoc`编写类文档的一个示例:    
+
+```kotlin
+/**
+ * 一组*成员*。
+ *
+ * 这个类没有有用的逻辑; 它只是一个文档示例。
+ *
+ * @param T 这个组中的成员的类型。
+ * @property name 这个组的名称。
+ * @constructor 创建一个空组。
+ */
+class Group<T>(val name: String) {
+    /**
+     * 将 [member] 添加到这个组。
+     * @return 这个组的新大小。
+     */
+    fun add(member: T): Int { …… }
+}
+```
+
+`KDoc`目前支持以下块标签`(block tags)`:     
+
+- `@param` <名称>
+
+    用于函数的值参数或者类、属性或函数的类型参数。
+    为了更好地将参数名称与描述分开，如果你愿意，可以将参数的名称括在
+    方括号中。因此，以下两种语法是等效的:   
+
+    ```kotlin
+    @param name 描述。
+    @param[name] 描述。
+    ```
+
+- `@return`
+
+    用于函数的返回值。
+
+- `@constructor`
+
+    用于类的主构造函数。
+
+- `@receiver`
+
+    用于扩展函数的接收者。
+
+- `@property` <名称>
+
+    用于类中具有指定名称的属性。这个标签可用于在
+    主构造函数中声明的属性，当然直接在属性定义的前面放置`doc`注释会很别扭。
+
+- `@throws` <类>,`@exception` <类>     
+
+    用于方法可能抛出的异常。因为`Kotlin`没有受检异常，所以也没有期望所有可能的异常都写文档，但是当它会为类的用户提供有用的信息时，仍然可以使用这个标签。
+
+- `@sample` <标识符>    
+
+    将具有指定限定的名称的函数的主体嵌入到当前元素的文档中，以显示如何使用该元素的示例。
+
+- `@see` <标识符>     
+
+    将到指定类或方法的链接添加到文档的另请参见块。
+
+- @author
+
+    指定要编写文档的元素的作者。
+
+- `@since`    
+
+    指定要编写文档的元素引入时的软件版本。
+
+- `@suppress`     
+
+    从生成的文档中排除元素。可用于不是模块的官方`API`的一部分但还是必须在对外可见的元素。
+
+`KDoc`不支持`@deprecated`这个标签。作为替代，请使用`@Deprecated`注解。
+
+
+
 
 
 [上一篇:Kotlin学习教程(五)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%BA%94).md)          
diff --git "a/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md" "b/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
index d732bbaf..4826886f 100644
--- "a/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
+++ "b/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
@@ -3,20 +3,330 @@
 
 Kotlin引入了协程（Coroutine）来支持更好的异步操作，利用它我们可以避免在异步编程中使用大量的回调，同时相比传统多线程技术，它更容易提升系统的高并发处理能力。 
 
-一些`API`启动长时间运行的操作(例如网络`IO`、文件`IO`、`CPU`或`GPU`密集型任务等)，并要求调用者阻塞直到它们完成。协程提供了一种避免阻塞线程
-并用更廉价、更可控的操作替代线程阻塞的方法:协程挂起。     
-协程通过将复杂性放入库来简化异步编程。程序的逻辑可以在协程中顺序地表达，而底层库会为我们解决其异步性。该库可以将用户代码的相关部分包装为回调、
-订阅相关事件、在不同线程(甚至不同机器！)上调度执行，而代码则保持如同顺序执行一样简单。     
+### 起源
 
+协程是一个无优先级的子程序调用组件，允许子程序在特定的地方挂起恢复。线程包含于进程，协程包含于线程。只要内存足够，
+一个线程中可以有任意多个协程，但某一时刻只能有一个协程在运行，多个协程分享该线程分配到的计算机资源。
 
+线程是由操作系统来进行调度的，当操作系统切换线程的时候，会产生一定的消耗。而协程不一样，协程是包含于线程的，也就是说协程
+是工作在线程之上的，协程的切换可以由程序自己来控制，不需要操作系统进行调度。这样的话就大大降低了开销。
 
-### 起源
 
-协程是一个无优先级的子程序调用组件，允许子程序在特定的地方挂起恢复。线程包含于进程，协程包含于线程。只要内存足够，一个线程中可以有任意多个协程，但某一时刻只能有一个协程在运行，多个协程分享该线程分配到的计算机资源。
 
-线程是由操作系统来进行调度的，当操作系统切换线程的时候，会产生一定的消耗。而协程不一样，协程是包含于线程的，也就是说协程是工作在线程之上的，协程的切换可以由程序自己来控制，不需要操作系统进行调度。这样的话就大大降低了开销。
+## 使用
+
+如需在 Android 项目中使用协程，请将以下依赖项添加到应用的build.gradle文件中：
+
+```groovy
+dependencies {
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.9'
+}
+```
+
+## 示例
+
+```kotlin
+import kotlinx.coroutines.*
+
+fun main() {
+    GlobalScope.launch { // 在后台启动一个新的协程并继续
+        delay(1000L) // 非阻塞的等待 1 秒钟（默认时间单位是毫秒）
+        println("World!") // 在延迟后打印输出
+    }
+    println("Hello,") // 协程已在等待时主线程还在继续
+    Thread.sleep(2000L) // 阻塞主线程 2 秒钟来保证 JVM 存活
+}
+// 运行结果
+Hello,
+World!
+```
+
+本质上，协程是轻量级的线程。它们在某些CoroutineScope上下文中与launch协程构建器一起启动。
+这里我们在ClobalScope中启动了一个新的协程，这意味着新协程的生命周期只受整个应用程序的生命周期限制。
+
+```kotlin
+import kotlinx.coroutines.*
+
+fun main() {
+    GlobalScope.launch { // 在后台启动一个新的协程并继续
+        delay(1000L)
+        println("World!")
+    }
+    println("Hello,") // 主线程中的代码会立即执行
+    runBlocking {     // 但是这个表达式阻塞了主线程
+        delay(2000L)  // ……我们延迟 2 秒来保证 JVM 的存活
+    } 
+}
+```
+
+调用了runBlocking的主线程会一直阻塞直到runBlocking内部的协程执行完毕。
+
+这个示例可以使用更合乎惯用法的方式重写，使用runBlocking来包装main函数的执行：
+
+```kotlin
+import kotlinx.coroutines.*
+
+fun main() = runBlocking<Unit> { // 开始执行主协程
+    GlobalScope.launch { // 在后台启动一个新的协程并继续
+        delay(1000L)
+        println("World!")
+    }
+    println("Hello,") // 主协程在这里会立即执行
+    delay(2000L)      // 延迟 2 秒来保证 JVM 存活
+}
+```
+
+这里的runBlocking<Unit> { …… }作为用来启动顶层主协程的适配器。 我们显式指定了其返回类型Unit，
+因为在Kotlin中main函数必须返回Unit类型。runBlocking为最高级的协程，也就是主协程，launch创建的协程能够在
+runBlocking中运行（反过来是不行的）。所以上面的代码可以看做是在一个线程中创建了一个主协程，然后在主协程中创建了一个输出为“World！”的子协程。 
+
+### 等待一个作业
+
+上面我们使用delay(2000L)来让主线程延迟2秒，保证JVM的存活，但是这样并不是一个好的实现方案，因为在很多情况下我们并不知道耗时的任务要执行多久。
+
+```kotlin
+val job = GlobalScope.launch { // 启动一个新协程并保持对这个作业的引用
+    delay(1000L)
+    println("World!")
+}
+println("Hello,")
+job.join() // 等待直到子协程执行结束
+```
+
+加了job.join()后，程序就会一直等待，直到我们启动的协程结束。注意，这里的等待是非堵塞式的等待，不会将当前线程挂起。
+
+### 结构化的并发
+
+协程的实际使用还有一些需要改进的地方。 当我们使用 `GlobalScope.launch` 时，我们会创建一个顶层协程。虽然它很轻量，
+但它运行时仍会消耗一些内存资源。如果我们忘记保持对新启动的协程的引用，它还会继续运行。如果协程中的代码挂起了会怎么样
+（例如，我们错误地延迟了太长时间），如果我们启动了太多的协程并导致内存不足会怎么样？ 
+必须手动保持对所有已启动协程的引用并 [join](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-job/join.html) 之很容易出错。
+
+有一个更好的解决办法。我们可以在代码中使用结构化并发。 我们可以在执行操作所在的指定作用域内启动协程， 而不是像通常使用线程
+（线程总是全局的）那样在 [GlobalScope](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-global-scope/index.html) 中启动。
+
+在我们的示例中，我们使用 [runBlocking](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/run-blocking.html) 
+协程构建器将 `main` 函数转换为协程。 包括 `runBlocking` 在内的每个协程构建器都将 [CoroutineScope](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-coroutine-scope/index.html) 
+的实例添加到其代码块所在的作用域中。 我们可以在这个作用域中启动协程而无需显式 `join` 之，因为外部协程（示例中的 `runBlocking`）
+直到在其作用域中启动的所有协程都执行完毕后才会结束。因此，可以将我们的示例简化为：
+
+```kotlin
+import kotlinx.coroutines.*
+
+fun main() = runBlocking { // this: CoroutineScope
+    launch { // 在 runBlocking 作用域中启动一个新协程
+        delay(1000L)
+        println("World!")
+    }
+    println("Hello,")
+}
+```
+
+
+### 作用域构建器
+
+除了由不同的构建器提供协程作用域之外，还可以使用 [coroutineScope](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/coroutine-scope.html) 
+构建器声明自己的作用域。它会创建一个协程作用域并且在所有已启动子协程执行完毕之前不会结束。
+
+[runBlocking](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/run-blocking.html) 与 [coroutineScope](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/coroutine-scope.html) 
+可能看起来很类似，因为它们都会等待其协程体以及所有子协程结束。 
+主要区别在于，[runBlocking](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/run-blocking.html) 
+方法会*阻塞*当前线程来等待， 而 [coroutineScope](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/coroutine-scope.html) 
+只是挂起，会释放底层线程用于其他用途。 由于存在这点差异，
+[runBlocking](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/run-blocking.html) 是常规函数，
+而 [coroutineScope](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/coroutine-scope.html) 是挂起函数。
+
+可以通过以下示例来演示：
+
+```kotlin
+import kotlinx.coroutines.*
+
+fun main() = runBlocking { // this: CoroutineScope
+    launch { 
+        delay(200L)
+        println("Task from runBlocking")
+    }
+    
+    coroutineScope { // 创建一个协程作用域
+        launch {
+            delay(500L) 
+            println("Task from nested launch")
+        }
+    
+        delay(100L)
+        println("Task from coroutine scope") // 这一行会在内嵌 launch 之前输出
+    }
+    
+    println("Coroutine scope is over") // 这一行在内嵌 launch 执行完毕后才输出
+}
+// 执行结果
+Task from coroutine scope
+Task from runBlocking
+Task from nested launch
+Coroutine scope is over
+```
+
+### 提取函数重构
+
+我们来将 `launch { …… }` 内部的代码块提取到独立的函数中。当你对这段代码执行“提取函数”重构时，你会得到一个带有 `suspend` 修饰符的新函数。 
+这是你的第一个*挂起函数*。在协程内部可以像普通函数一样使用挂起函数， 不过其额外特性是，同样可以使用其他挂起函数（如本例中的 `delay`）来*挂起*协程的执行。
+
+```kotlin
+import kotlinx.coroutines.*
+
+fun main() = runBlocking {
+    launch { doWorld() }
+    println("Hello,")
+}
+
+// 这是你的第一个挂起函数
+suspend fun doWorld() {
+    delay(1000L)
+    println("World!")
+}
+
+// 执行结果
+Hello,
+World!
+```
+
+### 取消协程的执行
+
+在一个长时间运行的应用程序中，你也许需要对你的后台协程进行细粒度的控制。 比如说，一个用户也许关闭了一个启动了协程的界面，
+那么现在协程的执行结果已经不再被需要了，这时，它应该是可以被取消的。 
+该 [launch](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/launch.html) 
+函数返回了一个可以被用来取消运行中的协程的 [Job](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-job/index.html)：
+
+```kotlin
+val job = launch {
+    repeat(1000) { i ->
+        println("job: I'm sleeping $i ...")
+        delay(500L)
+    }
+}
+delay(1300L) // 延迟一段时间
+println("main: I'm tired of waiting!")
+job.cancel() // 取消该作业
+job.join() // 等待作业执行结束
+println("main: Now I can quit.")
+// 执行结果
+job: I'm sleeping 0 ...
+job: I'm sleeping 1 ...
+job: I'm sleeping 2 ...
+main: I'm tired of waiting!
+main: Now I can quit.
+```
+
+一旦main函数调用了 `job.cancel`，我们在其它的协程中就看不到任何输出，因为它被取消了。 这里也有一个可以使
+[Job](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-job/index.html) 
+挂起的函数 [cancelAndJoin](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/cancel-and-join.html) 
+它合并了对 [cancel](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-job/cancel.html) 
+以及 [join](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-job/join.html) 的调用。
+
+
+
+### 取消是协作的
+
+协程的取消是*协作*的。一段协程代码必须协作才能被取消。 所有 `kotlinx.coroutines` 中的挂起函数都是 *可被取消的* 。
+它们检查协程的取消，并在取消时抛出 [CancellationException](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-cancellation-exception/index.html)。
+然而，如果协程正在执行计算任务，并且没有检查取消的话，那么它是不能被取消的，就如如下示例代码所示：
+
+```kotlin
+val startTime = System.currentTimeMillis()
+val job = launch(Dispatchers.Default) {
+    var nextPrintTime = startTime
+    var i = 0
+    while (i < 5) { // 一个执行计算的循环，只是为了占用 CPU
+        // 每秒打印消息两次
+        if (System.currentTimeMillis() >= nextPrintTime) {
+            println("job: I'm sleeping ${i++} ...")
+            nextPrintTime += 500L
+        }
+    }
+}
+delay(1300L) // 等待一段时间
+println("main: I'm tired of waiting!")
+job.cancelAndJoin() // 取消一个作业并且等待它结束
+println("main: Now I can quit.")
+// 执行结果
+job: I'm sleeping 0 ...
+job: I'm sleeping 1 ...
+job: I'm sleeping 2 ...
+main: I'm tired of waiting!
+job: I'm sleeping 3 ...
+job: I'm sleeping 4 ...
+main: Now I can quit.
+```
+
+运行示例代码，并且我们可以看到它连续打印出了“I'm sleeping”，甚至在调用取消后， 作业仍然执行了五次循环迭代并运行到了它结束为止。
+
 
 
+### 使计算代码可取消
+
+我们有两种方法来使执行计算的代码可以被取消。第一种方法是定期调用挂起函数来检查取消。
+对于这种目的 [yield](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/yield.html) 是一个好的选择。
+另一种方法是显式的检查取消状态。让我们试试第二种方法。
+
+将前一个示例中的 `while (i < 5)` 替换为 `while (isActive)` 并重新运行它。
+
+```kotlin
+val startTime = System.currentTimeMillis()
+val job = launch(Dispatchers.Default) {
+    var nextPrintTime = startTime
+    var i = 0
+    while (isActive) { // 可以被取消的计算循环
+        // 每秒打印消息两次
+        if (System.currentTimeMillis() >= nextPrintTime) {
+            println("job: I'm sleeping ${i++} ...")
+            nextPrintTime += 500L
+        }
+    }
+}
+delay(1300L) // 等待一段时间
+println("main: I'm tired of waiting!")
+job.cancelAndJoin() // 取消该作业并等待它结束
+println("main: Now I can quit.")
+// 执行结果
+job: I'm sleeping 0 ...
+job: I'm sleeping 1 ...
+job: I'm sleeping 2 ...
+main: I'm tired of waiting!
+main: Now I can quit.
+```
+
+你可以看到，现在循环被取消了。[isActive](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/is-active.html) 
+是一个可以被使用在 [CoroutineScope](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-coroutine-scope/index.html) 中的扩展属性。
+
+
+### 在 `finally` 中释放资源
+
+我们通常使用如下的方法处理在被取消时抛出 [CancellationException](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-cancellation-exception/index.html) 
+的可被取消的挂起函数。比如说，`try {……} finally {……}` 表达式以及 Kotlin 的 `use` 函数一般在协程被取消的时候执行它们的终结动作：
+
+```kotlin
+val job = launch {
+    try {
+        repeat(1000) { i ->
+            println("job: I'm sleeping $i ...")
+            delay(500L)
+        }
+    } finally {
+        println("job: I'm running finally")
+    }
+}
+delay(1300L) // 延迟一段时间
+println("main: I'm tired of waiting!")
+job.cancelAndJoin() // 取消该作业并且等待它结束
+println("main: Now I can quit.")
+// 执行结果
+job: I'm sleeping 0 ...
+job: I'm sleeping 1 ...
+job: I'm sleeping 2 ...
+main: I'm tired of waiting!
+job: I'm running finally
+main: Now I can quit.
+```
 
 
 ### 阻塞 vs 挂起
@@ -29,7 +339,7 @@ Kotlin引入了协程（Coroutine）来支持更好的异步操作，利用它
 
 另一个区别是，协程不能在随机的指令中挂起，而只能在所谓的挂起点挂起，这会调用特别标记的函数。
 
-#### 挂起函数    
+#### 挂起函数
 
 当我们调用标记有特殊修饰符`suspend`的函数时，会发生挂起:    
 
@@ -38,7 +348,6 @@ suspend fun doSomething(foo: Foo): Bar {
     ……
 }
 ```
-
 这样的函数称为挂起函数，因为调用它们可能挂起协程(如果相关调用的结果已经可用，库可以决定继续进行而不挂起)。挂起函数能够以与普通函数相同的方式
 获取参数和返回值，但它们只能从协程和其他挂起函数中调用。事实上，要启动协程，
 必须至少有一个挂起函数，它通常是匿名的(即它是一个挂起`lambda`表达式)。让我们来看一个例子，一个简化的`async()`函数
@@ -68,7 +377,6 @@ async {
 
 ```
 
-更多关于`async/await`函数实际在`kotlinx.coroutines`中如何工作的信息可以在这里找到。
 
 请注意，挂起函数`await()`和`doSomething()`不能在像`main()`这样的普通函数中调用:    
 ```kotlin
@@ -76,7 +384,6 @@ fun main(args: Array<String>) {
     doSomething() // 错误：挂起函数从非协程上下文调用
 }
 ```
-
 还要注意的是，挂起函数可以是虚拟的，当覆盖它们时，必须指定`suspend`修饰符:    
 ```kotlin
 interface Base {
@@ -88,6 +395,379 @@ class Derived: Base {
 }
 ```
 
+### 默认顺序调用
+
+假设我们在不同的地方定义了两个进行某种调用远程服务或者进行计算的挂起函数。我们只假设它们都是有用的，但是实际上它们在这个示例中只是为了该目的而延迟了一秒钟：
+
+```kotlin
+suspend fun doSomethingUsefulOne(): Int {
+    delay(1000L) // 假设我们在这里做了一些有用的事
+    return 13
+}
+
+suspend fun doSomethingUsefulTwo(): Int {
+    delay(1000L) // 假设我们在这里也做了一些有用的事
+    return 29
+}
+```
+
+如果需要按 *顺序* 调用它们，我们接下来会做什么——首先调用 `doSomethingUsefulOne` *接下来* 调用 `doSomethingUsefulTwo`，并且计算它们结果的和吗？ 
+实际上，如果我们要根据第一个函数的结果来决定是否我们需要调用第二个函数或者决定如何调用它时，我们就会这样做。
+
+我们使用普通的顺序来进行调用，因为这些代码是运行在协程中的，只要像常规的代码一样 *顺序* 都是默认的。
+下面的示例展示了测量执行两个挂起函数所需要的总时间：
+
+```kotlin
+val time = measureTimeMillis {
+    val one = doSomethingUsefulOne()
+    val two = doSomethingUsefulTwo()
+    println("The answer is ${one + two}")
+}
+println("Completed in $time ms")
+```
+
+它的打印输出如下：
+
+```
+The answer is 42
+Completed in 2017 ms
+```
+
+### 使用 async 并发
+
+如果 `doSomethingUsefulOne` 与 `doSomethingUsefulTwo` 之间没有依赖，并且我们想更快的得到结果，让它们进行 *并发* 吗？
+这就是 [async](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/async.html) 可以帮助我们的地方。
+
+在概念上，[async](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/async.html) 
+就类似于 [launch](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/launch.html)。
+它启动了一个单独的协程，这是一个轻量级的线程并与其它所有的协程一起并发的工作。不同之处在于 `launch` 返回一个 
+[Job](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-job/index.html) 并且不附带任何结果值，
+而 `async` 返回一个 [Deferred](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-deferred/index.html) —— 
+一个轻量级的非阻塞可取消的future，这代表了一个将会在稍后提供结果的 promise。你可以使用 `.await()` 在一个延期的值上得到它的最终结果，
+但是 `Deferred` 也是一个 `Job`，所以如果需要的话，你可以取消它。
+
+```kotlin
+val time = measureTimeMillis {
+    val one = async { doSomethingUsefulOne() }
+    val two = async { doSomethingUsefulTwo() }
+    println("The answer is ${one.await() + two.await()}")
+}
+println("Completed in $time ms")
+```
+它的打印输出如下：
+
+```
+The answer is 42
+Completed in 1017 ms
+```
+
+这里快了两倍，因为两个协程并发执行。请注意，使用协程进行并发总是显式的。
+
+### 惰性启动的 async
+
+可选的，[async](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/async.html) 
+可以通过将 `start` 参数设置为 [CoroutineStart.LAZY](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-coroutine-start/-l-a-z-y.html) 而变为惰性的。
+在这个模式下，只有结果通过 [await](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-deferred/await.html) 获取的时候协程才会启动，
+或者在 `Job` 的 [start](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-job/start.html) 函数调用的时候。运行下面的示例：
+
+```kotlin
+val time = measureTimeMillis {
+    val one = async(start = CoroutineStart.LAZY) { doSomethingUsefulOne() }
+    val two = async(start = CoroutineStart.LAZY) { doSomethingUsefulTwo() }
+    // 执行一些计算
+    one.start() // 启动第一个
+    two.start() // 启动第二个
+    println("The answer is ${one.await() + two.await()}")
+}
+println("Completed in $time ms")
+```
+它的打印输出如下：
+
+```
+The answer is 42
+Completed in 1017 ms
+```
+
+因此，在先前的例子中这里定义的两个协程没有执行，但是控制权在于程序员准确的在开始执行时调用 
+[start](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-job/start.html)。
+我们首先 调用 `one`，然后调用 `two`，接下来等待这个协程执行完毕。
+
+注意，如果我们只是在 `println` 中调用 [await](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-deferred/await.html)，
+而没有在单独的协程中调用 [start](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-job/start.html)，这将会导致顺序行为，
+直到 [await](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-deferred/await.html) 启动该协程 执行并等待至它结束，
+这并不是惰性的预期用例。 在计算一个值涉及挂起函数时，这个 `async(start = CoroutineStart.LAZY)` 的用例用于替代标准库中的 `lazy` 函数。
+
+
+
+## 协程上下文与调度器
+
+协程总是运行在一些以 [CoroutineContext](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.coroutines/-coroutine-context/) 
+类型为代表的上下文中，它们被定义在了 Kotlin 的标准库里。
+
+协程上下文是各种不同元素的集合。其中主元素是协程中的 [Job](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-job/index.html)， 
+我们在前面的文档中见过它以及它的调度器，而本文将对它进行介绍。
+
+### 调度器与线程
+
+协程上下文包含一个 *协程调度器* （参见 [CoroutineDispatcher](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-coroutine-dispatcher/index.html)）
+它确定了相关的协程在哪个线程或哪些线程上执行。协程调度器可以将协程限制在一个特定的线程执行，或将它分派到一个线程池，亦或是让它不受限地运行。
+
+所有的协程构建器诸如 [launch](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/launch.html) 
+和 [async](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/async.html) 接收一个可选的
+[CoroutineContext](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.coroutines/-coroutine-context/) 参数，它可以被用来显式的为一个新协程或其它上下文元素指定一个调度器。
+
+尝试下面的示例：
+
+```kotlin
+launch { // 运行在父协程的上下文中，即 runBlocking 主协程
+    println("main runBlocking      : I'm working in thread ${Thread.currentThread().name}")
+}
+launch(Dispatchers.Unconfined) { // 不受限的——将工作在主线程中
+    println("Unconfined            : I'm working in thread ${Thread.currentThread().name}")
+}
+launch(Dispatchers.Default) { // 将会获取默认调度器
+    println("Default               : I'm working in thread ${Thread.currentThread().name}")
+}
+launch(newSingleThreadContext("MyOwnThread")) { // 将使它获得一个新的线程
+    println("newSingleThreadContext: I'm working in thread ${Thread.currentThread().name}")
+}
+```
+
+```
+Unconfined            : I'm working in thread main
+Default               : I'm working in thread DefaultDispatcher-worker-1
+newSingleThreadContext: I'm working in thread MyOwnThread
+main runBlocking      : I'm working in thread main
+```
+
+当调用 `launch { …… }` 时不传参数，它从启动了它的 [CoroutineScope](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-coroutine-scope/index.html) 
+中承袭了上下文（以及调度器）。在这个案例中，它从 `main` 线程中的 `runBlocking` 主协程承袭了上下文。
+
+[Dispatchers.Unconfined](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-dispatchers/-unconfined.html) 
+是一个特殊的调度器且似乎也运行在 `main` 线程中，但实际上， 它是一种不同的机制，这会在后文中讲到。
+
+当协程在 [GlobalScope](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-global-scope/index.html) 中启动时，
+使用的是由 [Dispatchers.Default](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-dispatchers/-default.html) 代表的默认调度器。 
+默认调度器使用共享的后台线程池。 所以 `launch(Dispatchers.Default) { …… }` 与 `GlobalScope.launch { …… }` 使用相同的调度器。
+
+[newSingleThreadContext](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/new-single-thread-context.html) 
+为协程的运行启动了一个线程。 一个专用的线程是一种非常昂贵的资源。 在真实的应用程序中两者都必须被释放，当不再需要的时候，
+使用 [close](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-executor-coroutine-dispatcher/close.html) 函数，
+或存储在一个顶层变量中使它在整个应用程序中被重用。
+
+
+
+### 非受限调度器 vs 受限调度器
+
+[Dispatchers.Unconfined](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-dispatchers/-unconfined.html) 
+协程调度器在调用它的线程启动了一个协程，但它仅仅只是运行到第一个挂起点。挂起后，它恢复线程中的协程，而这完全由被调用的挂起函数来决定。
+非受限的调度器非常适用于执行不消耗 CPU 时间的任务，以及不更新局限于特定线程的任何共享数据（如UI）的协程。
+
+另一方面，该调度器默认继承了外部的 [CoroutineScope](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-coroutine-scope/index.html)。
+[runBlocking](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/run-blocking.html) 协程的默认调度器，
+特别是， 当它被限制在了调用者线程时，继承自它将会有效地限制协程在该线程运行并且具有可预测的 FIFO 调度。
+
+```
+launch(Dispatchers.Unconfined) { // 非受限的——将和主线程一起工作
+    println("Unconfined      : I'm working in thread ${Thread.currentThread().name}")
+    delay(500)
+    println("Unconfined      : After delay in thread ${Thread.currentThread().name}")
+}
+launch { // 父协程的上下文，主 runBlocking 协程
+    println("main runBlocking: I'm working in thread ${Thread.currentThread().name}")
+    delay(1000)
+    println("main runBlocking: After delay in thread ${Thread.currentThread().name}")
+}
+```
+
+执行后的输出：
+
+```
+Unconfined      : I'm working in thread main
+main runBlocking: I'm working in thread main
+Unconfined      : After delay in thread kotlinx.coroutines.DefaultExecutor
+main runBlocking: After delay in thread main
+```
+
+所以，该协程的上下文继承自 `runBlocking {...}` 协程并在 `main` 线程中运行，
+当 [delay](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/delay.html) 函数调用的时候，
+非受限的那个协程在默认的执行者线程中恢复执行。
+
+> 非受限的调度器是一种高级机制，可以在某些极端情况下提供帮助而不需要调度协程以便稍后执行或产生不希望的副作用， 因为某些操作必须立即在协程中执行。 非受限调度器不应该在通常的代码中使用。
+
+
+
+### 命名协程以用于调试
+
+当协程经常打印日志并且你只需要关联来自同一个协程的日志记录时， 
+则自动分配的 id 是非常好的。然而，当一个协程与特定请求的处理相关联时或做一些特定的后台任务，
+最好将其明确命名以用于调试目的。 [CoroutineName](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-coroutine-name/index.html) 
+上下文元素与线程名具有相同的目的。当[调试模式](http://www.kotlincn.net/docs/reference/coroutines/coroutine-context-and-dispatchers.html#调试协程与线程)开启时，
+它被包含在正在执行此协程的线程名中。
+
+下面的例子演示了这一概念：
+
+```kotlin
+log("Started main coroutine")
+// 运行两个后台值计算
+val v1 = async(CoroutineName("v1coroutine")) {
+    delay(500)
+    log("Computing v1")
+    252
+}
+val v2 = async(CoroutineName("v2coroutine")) {
+    delay(1000)
+    log("Computing v2")
+    6
+}
+log("The answer for v1 / v2 = ${v1.await() / v2.await()}")
+```
+
+程序执行使用了 `-Dkotlinx.coroutines.debug` JVM 参数，输出如下所示：
+
+```
+[main @main#1] Started main coroutine
+[main @v1coroutine#2] Computing v1
+[main @v2coroutine#3] Computing v2
+[main @main#1] The answer for v1 / v2 = 42
+```
+
+
+### 组合上下文中的元素
+
+有时我们需要在协程上下文中定义多个元素。我们可以使用 `+` 操作符来实现。 比如说，我们可以显式指定一个调度器来启动协程
+并且同时显式指定一个命名：
+
+```kotlin
+launch(Dispatchers.Default + CoroutineName("test")) {
+    println("I'm working in thread ${Thread.currentThread().name}")
+}
+```
+
+这段代码使用了 `-Dkotlinx.coroutines.debug` JVM 参数，输出如下所示：
+
+```
+I'm working in thread DefaultDispatcher-worker-1 @test#2
+```
+
+
+
+### 协程作用域
+
+让我们将关于上下文，子协程以及作业的知识综合在一起。假设我们的应用程序拥有一个具有生命周期的对象，但这个对象并不是一个协程。
+举例来说，我们编写了一个 Android 应用程序并在 Android 的 activity 上下文中启动了一组协程来使用异步操作拉取并更新数据以及执行动画等等。
+所有这些协程必须在这个 activity 销毁的时候取消以避免内存泄漏。当然，我们也可以手动操作上下文与作业，以结合 activity 的生命周期与它的协程，
+但是 `kotlinx.coroutines` 提供了一个封装：[CoroutineScope](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-coroutine-scope/index.html) 的抽象。 
+你应该已经熟悉了协程作用域，因为所有的协程构建器都声明为在它之上的扩展。
+
+我们通过创建一个 [CoroutineScope](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-coroutine-scope/index.html) 实例来管理协程的生命周期，
+并使它与 activity 的生命周期相关联。`CoroutineScope` 可以通过 [CoroutineScope()](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-coroutine-scope.html) 
+创建或者通过[MainScope()](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-main-scope.html) 工厂函数。
+前者创建了一个通用作用域，而后者为使用 [Dispatchers.Main](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-dispatchers/-main.html) 
+作为默认调度器的 UI 应用程序 创建作用域：
+
+```
+class Activity {
+    private val mainScope = MainScope()
+
+    fun destroy() {
+        mainScope.cancel()
+    }
+    // 继续运行……
+```
+
+现在，我们可以使用定义的 `scope` 在这个 `Activity` 的作用域内启动协程。 
+对于该示例，我们启动了十个协程，它们会延迟不同的时间：
+
+```
+// 在 Activity 类中
+    fun doSomething() {
+        // 在示例中启动了 10 个协程，且每个都工作了不同的时长
+        repeat(10) { i ->
+            mainScope.launch {
+                delay((i + 1) * 200L) // 延迟 200 毫秒、400 毫秒、600 毫秒等等不同的时间
+                println("Coroutine $i is done")
+            }
+        }
+    }
+} // Activity 类结束
+```
+
+在 main 函数中我们创建 activity，调用测试函数 `doSomething`，并且在 500 毫秒后销毁这个 activity。 
+这取消了从 `doSomething` 启动的所有协程。我们可以观察到这些是由于在销毁之后， 即使我们再等一会儿，activity 也不再打印消息。
+
+```
+val activity = Activity()
+activity.doSomething() // 运行测试函数
+println("Launched coroutines")
+delay(500L) // 延迟半秒钟
+println("Destroying activity!")
+activity.destroy() // 取消所有的协程
+delay(1000) // 为了在视觉上确认它们没有工作
+```
+
+这个示例的输出如下所示：
+
+```
+Launched coroutines
+Coroutine 0 is done
+Coroutine 1 is done
+Destroying activity!
+```
+
+你可以看到，只有前两个协程打印了消息，而另一个协程在 `Activity.destroy()` 中单次调用了 `job.cancel()`。
+
+
+## 通道
+
+延期的值提供了一种便捷的方法使单个值在多个协程之间进行相互传输。 通道提供了一种在流中传输值的方法。
+
+### 通道基础
+
+一个 [Channel](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.channels/-channel/index.html) 
+是一个和 `BlockingQueue` 非常相似的概念。其中一个不同是它代替了阻塞的 `put` 操作并提供了挂起的 
+[send](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.channels/-send-channel/send.html)，
+还替代了阻塞的 `take` 操作并提供了挂起的 [receive](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.channels/-receive-channel/receive.html)。
+
+```
+val channel = Channel<Int>()
+launch {
+    // 这里可能是消耗大量 CPU 运算的异步逻辑，我们将仅仅做 5 次整数的平方并发送
+    for (x in 1..5) channel.send(x * x)
+}
+// 这里我们打印了 5 次被接收的整数：
+repeat(5) { println(channel.receive()) }
+println("Done!")
+```
+这段代码的输出如下：
+
+```
+1
+4
+9
+16
+25
+Done!
+```
+
+### 关闭与迭代通道
+
+和队列不同，一个通道可以通过被关闭来表明没有更多的元素将会进入通道。 在接收者中可以定期的使用 `for` 循环来从通道中接收元素。
+
+从概念上来说，一个 [close](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.channels/-send-channel/close.html) 
+操作就像向通道发送了一个特殊的关闭指令。 这个迭代停止就说明关闭指令已经被接收了。所以这里保证所有先前发送出去的元素都在通道关闭前被接收到。
+
+```
+val channel = Channel<Int>()
+launch {
+    for (x in 1..5) channel.send(x * x)
+    channel.close() // 我们结束发送
+}
+// 这里我们使用 `for` 循环来打印所有被接收到的元素（直到通道被关闭）
+for (y in channel) println(y)
+println("Done!")
+```
+
 
 
 
diff --git "a/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\344\271\235).md" b/KotlinCourse/9.Kotlin_androidktx.md
similarity index 56%
rename from "KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\344\271\235).md"
rename to KotlinCourse/9.Kotlin_androidktx.md
index 1a484128..aaef520a 100644
--- "a/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\344\271\235).md"
+++ b/KotlinCourse/9.Kotlin_androidktx.md
@@ -1,139 +1,6 @@
-Kotlin学习教程(九)
+9.Kotlin_androidktx
 ===
 
-
-`Kotlin`团队为`Android`开发提供了一套超越标准语言功能的工具:    
-
-- `Kotlin Android Extensions`是一个编译器扩展，可以让您摆脱代码中的`findViewById()`调用，并将其替换为合成编译器生成的属性。
-- `Anko`是一个提供围绕`Android API`和`DSL`的一组`Kotlin`友好的包装器，可以用`Kotlin`代码替换`layout .xml`文件。
-
-
-### `Anko`
-
-[Anko](https://github.com/Kotlin/anko)是`Kotlin`官方出品用于`Android`开发的库。
-
-
-> `Anko is a Kotlin library which makes Android application development faster and easier. It makes your code clean and 
-> easy to read, and lets you forget about rough edges of the Android SDK for Java.`
-
-
-> Anko consists of several parts:
->
-> Anko Commons: a lightweight library full of helpers for intents, dialogs, logging and so on;
-    > Intents;
-    > Dialogs and toasts;
-    > Logging;
-    > Resources and dimensions;
-> Anko Layouts: a fast and type-safe way to write dynamic Android layouts;
-> Anko SQLite: a query DSL and parser collection for Android SQLite;
-> Anko Coroutines: utilities based on the kotlinx.coroutines library.
-
-`Anko`使用`DSL`提供了很多便捷的功能，可以直接用代码去写布局，不过我还是接受不了，感觉用`xml`写布局把布局和逻辑区分开挺好，这里就不介绍了，想用的可以去看看。 
-
-这里就用几个简单的`commons`中的例子，平时想要启动另一个`activity`我们经常这样写:   
-```kotlin
-val intent = Intent(this, SomeOtherActivity::class.java)
-intent.putExtra("id", 5)
-intent.setFlag(Intent.FLAG_ACTIVITY_SINGLE_TOP)
-startActivity(intent)
-```
-这里要四行代码，太多了，`anko`提供了更简单的方式:   
-```kotlin
-startActivity(intentFor<SomeOtherActivity>("id" to 5).singleTop())
-```
-如果不设置`flag`的话还可以这样写:   
-```kotlin
-startActivity<SomeOtherActivity>("id" to 5)
-```
-
-而且`anko`还提供了一些常用的`intent`的封装功能:   
-
-- 打电话`makeCall(number) without tel`
-- 发短信`sendSMS(number, [text]) without sms`
-- 浏览网页`browse(url)`
-- 分享`share(text, [subject])`
-- 发邮件`email(email, [subject], [text])`
-
-进行`toast`和`snakebar`提示:    
-```kotlin
-toast("Hi there!")
-toast(R.string.message)
-longToast("Wow, such duration")
-
-snackbar(view, "Hi there!")
-snackbar(view, R.string.message)
-longSnackbar(view, "Wow, such duration")
-snackbar(view, "Action, reaction", "Click me!") { doStuff() }
-```
-
-对话框:   
-```kotlin
-alert("Hi, I'm Roy", "Have you tried turning it off and on again?") {
-    yesButton { toast("Oh…") }
-    noButton {}
-}.show()
-
-// 列表对话框
-val countries = listOf("Russia", "USA", "Japan", "Australia")
-selector("Where are you from?", countries, { dialogInterface, i ->
-    toast("So you're living in ${countries[i]}, right?")
-})
-
-// 进度对话框
-val dialog = progressDialog(message = "Please wait a bit…", title = "Fetching data")
-```
-
-`log`：  
-```kotlin
-class SomeActivity : Activity(), AnkoLogger {
-    private fun someMethod() {
-        info("London is the capital of Great Britain")
-        debug(5) // .toString() method will be executed
-        warn(null) // "null" will be printed
-    }
-}
-```
-或者:   
-```kotlin
-class SomeActivity : Activity() {
-    private val log = AnkoLogger<SomeActivity>(this)
-    private val logWithASpecificTag = AnkoLogger("my_tag")
-
-    private fun someMethod() {
-        log.warning("Big brother is watching you!")
-    }
-}
-```
-
-`dimens`: 
-
-可以直接使用`px2dip`和`px2sp`来进行尺寸转换。  
-
-
-异步操作:   
-```kotlin
-doAsync {
-    // Long background task
-    uiThread {
-        result.text = "Done"
-    }
-}
-```
-
-使用`anko`:    
-```kotlin
-// 创建一个verticallayout并且添加edittext和button，并给button设置点击事件
-verticalLayout {
-    val name = editText()
-    button("Say Hello") {
-        onClick { toast("Hello, ${name.text}!") }
-    }
-}
-```
-
-
-### Kotlin Android Extensions
-
 相信每一位安卓开发人员对`findViewById()`这个方法再熟悉不过了，毫无疑问，潜在的`bug`和脏乱的代码令后续开发无从下手的。 尽管存在一系列的
 开源库能够为这个问题带来解决方案，然而对于运行时依赖的库，需要为每一个`View`注解变量字段。
 
@@ -227,31 +94,6 @@ public class ForecastRequest(val zipCode: String) {
 ```
 
 
-### 创建Application 
-
-```kotlin
-class App : Application() {
-    companion object {
-        private var instance: Application? = null
-        fun instance() = instance!!
-    }
-    override fun onCreate() {
-        super.onCreate()
-        instance = this
-    }
-}
-
-```
-
-
-
-
-- with() 
-
-```kotlin
-inline fun <T> with(t: T, body: T.() -> Unit) { t.body() }
-```
-
 
 
 [上一篇:Kotlin学习教程(八)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E5%85%AB).md)         
diff --git "a/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\345\205\253).md" "b/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\345\205\253).md"
deleted file mode 100644
index 6ed5d235..00000000
--- "a/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\345\205\253).md"
+++ /dev/null
@@ -1,460 +0,0 @@
-Kotlin学习教程(八)
-===
-
-`Kotlin`协程
----
-
-Kotlin引入了协程（Coroutine）来支持更好的异步操作，利用它我们可以避免在异步编程中使用大量的回调，同时相比传统多线程技术，它
-
-一些`API`启动长时间运行的操作(例如网络`IO`、文件`IO`、`CPU`或`GPU`密集型任务等)，并要求调用者阻塞直到它们完成。协程提供了一种避免阻塞线程
-并用更廉价、更可控的操作替代线程阻塞的方法:协程挂起。     
-协程通过将复杂性放入库来简化异步编程。程序的逻辑可以在协程中顺序地表达，而底层库会为我们解决其异步性。该库可以将用户代码的相关部分包装为回调、
-订阅相关事件、在不同线程(甚至不同机器！)上调度执行，而代码则保持如同顺序执行一样简单。     
-
-
-### 阻塞 vs 挂起
-
-基本上，协程计算可以被挂起而无需阻塞线程。线程阻塞的代价通常是昂贵的，尤其在高负载时，因为只有相对少量线程实际可用，因此阻塞其中一个会导致一些
-重要的任务被延迟。
-
-另一方面，协程挂起几乎是无代价的。不需要上下文切换或者`OS`的任何其他干预。最重要的是，挂起可以在很大程度上由用户库控制:   
-作为库的作者，我们可以决定挂起时发生什么并根据需求优化/记日志/截获。
-
-另一个区别是，协程不能在随机的指令中挂起，而只能在所谓的挂起点挂起，这会调用特别标记的函数。
-
-#### 挂起函数    
-
-当我们调用标记有特殊修饰符`suspend`的函数时，会发生挂起:    
-
-```kotlin
-suspend fun doSomething(foo: Foo): Bar {
-    ……
-}
-```
-
-这样的函数称为挂起函数，因为调用它们可能挂起协程(如果相关调用的结果已经可用，库可以决定继续进行而不挂起)。挂起函数能够以与普通函数相同的方式
-获取参数和返回值，但它们只能从协程和其他挂起函数中调用。事实上，要启动协程，
-必须至少有一个挂起函数，它通常是匿名的(即它是一个挂起`lambda`表达式)。让我们来看一个例子，一个简化的`async()`函数
-(源自`kotlinx.coroutines`库):    
-
-```kotlin
-fun <T> async(block: suspend () -> T)
-```
-
-这里的`async()`是一个普通函数(不是挂起函数)，但是它的`block`参数具有一个带`suspend`修饰符的函数类型:`suspend() -> T`。
-所以，当我们将一个`lambda`表达式传给`async()`时，它会是挂起`lambda`表达式，于是我们可以从中调用挂起函数:    
-
-```kotlin
-async {
-    doSomething(foo)
-    ……
-}
-```
-
-继续该类比,`await()`可以是一个挂起函数(因此也可以在一个`async {}`块中调用)，该函数挂起一个协程，直到一些计算完成并返回其结果:   
-```kotlin
-async {
-    ……
-    val result = computation.await()
-    ……
-}
-
-```
-
-更多关于`async/await`函数实际在`kotlinx.coroutines`中如何工作的信息可以在这里找到。
-
-请注意，挂起函数`await()`和`doSomething()`不能在像`main()`这样的普通函数中调用:    
-```kotlin
-fun main(args: Array<String>) {
-    doSomething() // 错误：挂起函数从非协程上下文调用
-}
-```
-
-还要注意的是，挂起函数可以是虚拟的，当覆盖它们时，必须指定`suspend`修饰符:    
-```kotlin
-interface Base {
-    suspend fun foo()
-}
-
-class Derived: Base {
-    override suspend fun foo() { …… }
-}
-```
-
-`Kotlin`解构声明    
----
-
-
-有时把一个对象解构成很多变量会很方便:   
-
-```kotlin
-val (name, age) = person
-```
-
-这种语法称为解构声明。 一个解构声明可以同时创建多个变量。    
-
-我们已经声明了两个新变量:`name`和`age`，并且可以独立使用它们:    
-```kotlin
-println(name)
-println(age)
-```
-
-一个解构声明会被编译成以下代码:    
-```kotlin
-val name = person.component1()
-val age = person.component2()
-```
-
-其中的`component1()`和`component2()`函数是在`Kotlin`中广泛使用的约定原则的另一个例子。
-
-任何表达式都可以出现在解构声明的右侧，只要可以对它调用所需数量的`component`函数即可。
-当然，可以有`component3()`和`component4()`等等。
-
-请注意，`componentN()`函数需要用`operator`关键字标记，以允许在解构声明中使用它们。
-
-解构声明也可以用在`for{: .keyword }`循环中:    
-```kotlin
-for ((a, b) in collection) { …… }
-```
-变量`a`和`b`的值取自对集合中的元素上调用`component1()`和`component2()`的返回值。
-
-例:从函数中返回两个变量
-让我们假设我们需要从一个函数返回两个东西。例如，一个结果对象和一个某种状态。
-在`Kotlin`中一个简洁的实现方式是声明一个数据类并返回其实例:    
-```kotlin
-data class Result(val result: Int, val status: Status)
-fun function(……): Result {
-    // 各种计算
-    return Result(result, status)
-}
-// 现在，使用该函数：
-val (result, status) = function(……)
-```
-因为数据类自动声明`componentN()`函数，所以这里可以用解构声明。
-
-注意：我们也可以使用标准类`Pair`并且让`function()`返回`Pair<Int, Status>`，
-但是让数据合理命名通常更好。
-
-例：解构声明和映射
-可能遍历一个映射`(map)`最好的方式就是这样：
-```kotlin
-for ((key, value) in map) {
-   // 使用该 key、value 做些事情
-}
-```
-为使其能用，我们应该
-通过提供一个`iterator()`函数将映射表示为一个值的序列，
-通过提供函数`component1()`和`component2()`来将每个元素呈现为一对。
-当然事实上，标准库提供了这样的扩展:   
-```kotlin
-operator fun <K, V> Map<K, V>.iterator(): Iterator<Map.Entry<K, V>> = entrySet().iterator()
-operator fun <K, V> Map.Entry<K, V>.component1() = getKey()
-operator fun <K, V> Map.Entry<K, V>.component2() = getValue()
-```
-因此你可以在`for{: .keyword }`-循环中对映射(以及数据类实例的集合等)自由使用解构声明。
-
-
-`Kotlin`反射
----
-
-
-最基本的反射功能是获取`Kotlin`类的运行时引用。要获取对
-静态已知的`Kotlin`类的引用，可以使用类字面值语法：
-```kotlin
-val c = KClass::class
-```
-
-该引用是`KClass`类型的值。
-
-请注意，`Kotlin`类引用与`Java`类引用不同。要获得`Java`类引用，
-请在`KClass`实例上使用`.java`属性，也就是`KClass::class.java`
-
-
-#### 函数引用
-
-当我们有一个命名函数声明如下:   
-```kotlin
-fun isOdd(x: Int) = x % 2 != 0
-```
-
-我们可以很容易地直接调用它`(isOdd(5))`，但是我们也可以把它作为一个值传递。例如传给另一个函数。
-为此，我们使用`::`操作符:   
-```kotlin
-val numbers = listOf(1, 2, 3)
-println(numbers.filter(::isOdd)) // 输出 [1, 3]
-```
-这里`::isOdd`是函数类型`(Int) -> Boolean`的一个值。
-
-当上下文中已知函数期望的类型时`::`可以用于重载函数。
-
-例如:      
-```kotlin
-fun isOdd(x: Int) = x % 2 != 0
-fun isOdd(s: String) = s == "brillig" || s == "slithy" || s == "tove"
-
-val numbers = listOf(1, 2, 3)
-println(numbers.filter(::isOdd)) // 引用到 isOdd(x: Int)
-```
-
-或者，你可以通过将方法引用存储在具有显式指定类型的变量中来提供必要的上下文:   
-```kotlin
-val predicate: (String) -> Boolean = ::isOdd   // 引用到 isOdd(x: String)
-```
-如果我们需要使用类的成员函数或扩展函数，它需要是限定的。
-例如`String::toCharArray`为类型`String`提供了一个扩展函数:`String.() -> CharArray`。
-
-
-#### 属性引用
-
-要把属性作为`Kotlin`中的一等对象来访问，我们也可以使用`::`运算符:    
-
-```kotlin
-var x = 1
-
-fun main(args: Array<String>) {
-    println(::x.get()) // 输出 "1"
-    ::x.set(2)
-    println(x)         // 输出 "2"
-}
-```
-表达式`::x`求值为`KProperty<Int>`类型的属性对象，它允许我们使用
-`get()`读取它的值，或者使用`name`属性来获取属性名。更多信息请参见
-关于`KProperty`类的文档。
-
-对于可变属性，例如`var y = 1`，`::y`返回`KMutableProperty<Int>`类型的一个值，
-该类型有一个`set()`方法。
-
-属性引用可以用在不需要参数的函数处:   
-```kotlin
-val strs = listOf("a", "bc", "def")
-println(strs.map(String::length)) // 输出 [1, 2, 3]
-```
-要访问属于类的成员的属性，我们这样限定它:   
-```kotlin
-class A(val p: Int)
-
-fun main(args: Array<String>) {
-    val prop = A::p
-    println(prop.get(A(1))) // 输出 "1"
-}
-```
-
-
-Kotlin类型别名
----
-
-类型别名为现有类型提供替代名称。
-如果类型名称太长，你可以另外引入较短的名称，并使用新的名称替代原类型名。
-
-它有助于缩短较长的泛型类型。
-例如，通常缩减集合类型是很有吸引力的:    
-```kotlin
-typealias NodeSet = Set<Network.Node>
-
-typealias FileTable<K> = MutableMap<K, MutableList<File>>
-```
-
-你可以为函数类型提供另外的别名:   
-```kotlin
-typealias MyHandler = (Int, String, Any) -> Unit
-
-typealias Predicate<T> = (T) -> Boolean
-```
-你可以为内部类和嵌套类创建新名称：
-
-```kotlin
-class A {
-    inner class Inner
-}
-class B {
-    inner class Inner
-}
-
-typealias AInner = A.Inner
-typealias BInner = B.Inner
-```
-
-
-类型别名不会引入新类型。
-它们等效于相应的底层类型。
-当你在代码中添加`typealias Predicate<T>`并使用`Predicate<Int>`时，`Kotlin`编译器总是把它扩展为`(Int) -> Boolean`。
-因此，当你需要泛型函数类型时，你可以传递该类型的变量，反之亦然:    
-
-```kotlin
-typealias Predicate<T> = (T) -> Boolean
-
-fun foo(p: Predicate<Int>) = p(42)
-
-fun main(args: Array<String>) {
-    val f: (Int) -> Boolean = { it > 0 }
-    println(foo(f)) // 输出 "true"
-
-    val p: Predicate<Int> = { it > 0 }
-    println(listOf(1, -2).filter(p)) // 输出 "[1]"
-}
-```
-
-
-
-文档
----
-
-
-用来编写`Kotlin`代码文档的语言(相当于`Java`的`JavaDoc`)称为`KDoc`。本质上`KDoc`是将`JavaDoc`的块标签`(block tags)`语法(
-扩展为支持`Kotlin`的特定构造)和`Markdown`的内联标记`(inline markup)`结合在一起。
-
-
-#### 生成文档    
-
-`Kotlin`的文档生成工具称为[Dokka](https://github.com/Kotlin/dokka)。
-
-`Dokka`有`Gradle`、`Maven`和`Ant`的插件，因此你可以将文档生成集成到你的构建过程中。
-
-
-像`JavaDoc`一样，`KDoc`注释也以`/**`开头、以`*/`结尾。注释的每一行可以以
-星号开头，该星号不会当作注释内容的一部分。
-
-按惯例来说，文档文本的第一段(到第一行空白行结束)是该元素的
-总体描述，接下来的注释是详细描述。
-
-每个块标签都以一个新行开始且以`@`字符开头。
-
-以下是使用`KDoc`编写类文档的一个示例:    
-```kotlin
-/**
- * 一组*成员*。
- *
- * 这个类没有有用的逻辑; 它只是一个文档示例。
- *
- * @param T 这个组中的成员的类型。
- * @property name 这个组的名称。
- * @constructor 创建一个空组。
- */
-class Group<T>(val name: String) {
-    /**
-     * 将 [member] 添加到这个组。
-     * @return 这个组的新大小。
-     */
-    fun add(member: T): Int { …… }
-}
-```
-
-`KDoc`目前支持以下块标签`(block tags)`:     
-
-- `@param` <名称>
-
-    用于函数的值参数或者类、属性或函数的类型参数。
-    为了更好地将参数名称与描述分开，如果你愿意，可以将参数的名称括在
-    方括号中。因此，以下两种语法是等效的:   
-	```kotlin
-	@param name 描述。
-	@param[name] 描述。
-	```
-
-- `@return`
-
-    用于函数的返回值。
-
-- `@constructor`
-
-    用于类的主构造函数。
-
-- `@receiver`
-
-    用于扩展函数的接收者。
-
-- `@property` <名称>
-
-    用于类中具有指定名称的属性。这个标签可用于在
-    主构造函数中声明的属性，当然直接在属性定义的前面放置`doc`注释会很别扭。
-
-- `@throws` <类>,`@exception` <类>     
-
-    用于方法可能抛出的异常。因为`Kotlin`没有受检异常，所以也没有期望所有可能的异常都写文档，但是当它会为类的用户提供有用的信息时，仍然可以使用这个标签。
-
-- `@sample` <标识符>    
-
-    将具有指定限定的名称的函数的主体嵌入到当前元素的文档中，以显示如何使用该元素的示例。
-
-- `@see` <标识符>     
-
-    将到指定类或方法的链接添加到文档的另请参见块。
-
-- @author
-
-    指定要编写文档的元素的作者。
-
-- `@since`    
-
-    指定要编写文档的元素引入时的软件版本。
-
-- `@suppress`     
-
-    从生成的文档中排除元素。可用于不是模块的官方`API`的一部分但还是必须在对外可见的元素。
-
-`KDoc`不支持`@deprecated`这个标签。作为替代，请使用`@Deprecated`注解。
-
-
-#### 内联标记   
-
-对于内联标记，`KDoc`使用常规`Markdown`语法，扩展了支持用于链接到代码中其他元素的简写语法。
-
-链接到元素
-要链接到另一个元素(类、方法、属性或参数)，只需将其名称放在方括号中：
-```
-为此目的，请使用方法 [foo]。
-```
-如果要为链接指定自定义标签(label)，请使用 Markdown 引用样式语法：
-```
-为此目的，请使用[这个方法][foo]。
-```
-你还可以在链接中使用限定的名称。请注意，与 JavaDoc 不同，限定的名称总是使用点字符
-来分隔组件，即使在方法名称之前：
-```
-使用 [kotlin.reflect.KClass.properties] 来枚举类的属性。
-```
-链接中的名称与正写文档的元素内使用该名称使用相同的规则解析。
-特别是，这意味着如果你已将名称导入当前文件，那么当你在`KDoc`注释中使用它时，
-不需要再对其进行完整限定。
-
-请注意`KDoc`没有用于解析链接中的重载成员的任何语法。因为`Kotlin`文档生成
-工具将一个函数的所有重载的文档放在同一页面上，标识一个特定的重载函数
-并不是链接生效所必需的。
-
-
-
-### Any
-
-我们都知道，Java并不能在真正意义上被称为一门“ 纯面向对象”语言，因为它的原始类型(如int)的值与函数等并不能被视作对象。
-
-但是Kotlin不同，在Kotlin的类型系统中，并不区分原始类型（基本数据类型）和包装类型，我们使用的始终是同一个类型。虽然从严格意义上，我们不能说Kotlin是一门纯面向对象的语言，但它显然比Java有更纯的设计。
-
-
-
-#### Any：非空类型的跟类型
-
-与Object作为Java类层级结构的顶层类似，Any类型是Kotlin中所有非空类型（如String、Int）的超类，如:  
-
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/kotlin_any.png?raw=true)
-
-与Java不同的是，Kotlin不区分“原始类型”(primitive type)和其他的类型，他们都是同一类型层级结构的一部分。 如果定义了一个没有指定父类型的类型，则该类型将是Any的直接子类型。如:  
-
-```kotlin
-class Animal(val weight: Double)
-```
-
-#### Any?：所有类型的根类型
-
-如果说Any是所有非空类型的根类型，那么Any?才是所有类型（可空和非空类型）的根类型。这也就是说?Any?是?Any的父类型。 
-
-
-
-
-[上一篇:Kotlin学习教程(七)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%B8%83).md)         
-[下一篇:Kotlin学习教程(八)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E5%85%AB).md)
-
-
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
diff --git "a/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\345\215\201).md" "b/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\345\215\201).md"
deleted file mode 100644
index 7e4012f9..00000000
--- "a/KotlinCourse/Kotlin\345\255\246\344\271\240\346\225\231\347\250\213(\345\215\201).md"
+++ /dev/null
@@ -1,13 +0,0 @@
-Kotlin学习教程(十)
-===
-
-- 
-
-
-[上一篇:Kotlin学习教程(九)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%B9%9D).md)
-
-
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
diff --git "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
index 4e733af8..7964053a 100644
--- "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
+++ "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
@@ -47,8 +47,9 @@
 
 - 比特率(码率)
   
+
 码率就是数据传输时单位时间传送的数据位数,一般我们用的单位是`kbps`即千位(bit)每秒，也就是每秒钟传送多少个千位的信息。 通俗一点的理解就是取样率，单位时间内取样率越大，精度就越高，处理出来的文件就越接近原始文件，但是文件体积与取样率是成正比的，所以几乎所有的编码格式重视的都是如何用最低的码率达到最少的失真。但是因为编码算法不一样，所以也不能用码率来统一衡量音质或者画质.小写的b表示bit(位)，大写的B表示byte(字节)，一个字节=8个位，即1B=8b；前面的k表示1024的意思，即1024个位(Kb)或者1024个字节(KB)，表示文件的大小单位，一般使用KB。1KB/s=8Kbps。码率(kbps)=文件大小(KB)*8/时间(秒)。     
-  
+
 - 动态码率(VBR: Variable Bit Rate)
   
    比特率可以随着图像复杂程度的不同而随之变化。图像内容简单的片段采用较小的码率，图像
@@ -61,9 +62,10 @@
   
 - 帧率(Frame Rate)
   
+
 帧/秒(`frames per second`)的缩写帧率即每秒显示帧数，帧率表示图形处理器处理场时每秒钟能够更新的次数。高的帧率可以得到更流畅、更逼真的动画。一般来说`30fps`就是可以接受的，但是将性能提升至`60fps`则可以明显提升交互感和逼真感，但是一般来说超过`75fps`一般就不容易察觉到有明显的流畅度提升了。如果帧率超过屏幕刷新率只会浪费图形处理的能力，因为监视器不能以这么快的速度更新，这样超过新率的帧率就浪费掉了。
   ![image](https://github.com/CharonChui/Pictures/blob/master/fps.gif?raw=true)
-  
+
 - 关键帧
 
     相当于二维动画中的原画，指角色或者物体运动或变化中的关键动作所处的那一帧，它包含了图像的所有信息，后来帧仅包含了改变了的信息。如果你没有足够的关键帧，你的影片品质可能比较差，因为所有的帧从别的帧处产生。对于一般的用途，一个比较好的原则是每5秒设一个关键键。但如果时那种实时传输的流文件，那么要考虑传输网络的可靠度，所以要1到2秒增加一个关键帧。
@@ -210,7 +212,7 @@
 YUV
 ---
 
-YUV(也成YCbCr)是电视系统所采用的一种颜色编码方法，他是一种亮度与色度分离的色彩格式。其中Y表示明亮度也就是灰阶值，它是基础信号。U和V表示的则是色度，UV的作用是描述影像色彩及饱和度，它们用于指定像素的颜色。U和V不是基础信号，他俩都是被正交调制的。早期的电视都是黑白的，即只有亮度值(Y)，有了彩色电视之后，加入了UV两种色度，形成现在的YUV，也叫YCbCr。人眼对亮度敏感，对色度不敏感，因此减少部分UV的数据量，人眼也无法感知出来，这样就可以通过压缩UV的分辨率，在不影响观感的前提下，减少视频的体积。
+YUV(也成YCbCr)是电视系统所采用的一种颜色编码方法，他是一种亮度与色度分离的色彩格式。其中Y表示明亮度也就是灰阶值，它是基础信号。U表示色度，V表示浓度，UV的作用是描述影像色彩及饱和度，它们用于指定像素的颜色。U和V不是基础信号，他俩都是被正交调制的。早期的电视都是黑白的，即只有亮度值(Y)，有了彩色电视之后，加入了UV两种色度，形成现在的YUV，也叫YCbCr。人眼对亮度敏感，对色度不敏感，因此减少部分UV的数据量，人眼也无法感知出来，这样就可以通过压缩UV的分辨率，在不影响观感的前提下，减少视频的体积。
 
 YUV和RGB视频信号相比，最大的优点在于只需要占用极少的带宽，YUV只需要占用RGB一般的带宽。
 
diff --git "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/11.\346\222\255\346\224\276\347\273\204\344\273\266\345\260\201\350\243\205.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/11.\346\222\255\346\224\276\347\273\204\344\273\266\345\260\201\350\243\205.md"
new file mode 100644
index 00000000..16479a5f
--- /dev/null
+++ "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/11.\346\222\255\346\224\276\347\273\204\344\273\266\345\260\201\350\243\205.md"
@@ -0,0 +1,45 @@
+11.播放组件封装
+===
+
+通常播放器的开发都设计成一定程度的分层，将视频帧的显示、进度条、控制键、音量调节、预览图、字幕、弹幕、频道列表、后续播放推荐等截面功能与音视频播放进行剥离，以使代码模块化，架构清晰。
+
+为连接播放器截面和音视频播放，通常需设计一套状态机机制，音视频播放层需要负责包括解码器在内的软硬件初始化，搭建Pipeline以及进行播放控制。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/VideoDevelopment/\346\222\255\346\224\276\345\231\250\346\200\247\350\203\275\344\274\230\345\214\226.md" "b/VideoDevelopment/\346\222\255\346\224\276\345\231\250\346\200\247\350\203\275\344\274\230\345\214\226.md"
index aebda409..b64ab96e 100644
--- "a/VideoDevelopment/\346\222\255\346\224\276\345\231\250\346\200\247\350\203\275\344\274\230\345\214\226.md"
+++ "b/VideoDevelopment/\346\222\255\346\224\276\345\231\250\346\200\247\350\203\275\344\274\230\345\214\226.md"
@@ -101,6 +101,41 @@ IP竞速
 
 DNS解析加快，通常，DNS解析，意味着要把一个域名为xxx.com解析成ip过程，平时请求网页，网络差，就会打开网页半天。
 
+### 播放的关键指标：QOS
+QOS(Quality of Service，服务质量)主要指网络环境下服务满足用户的程度，在视频服务的语境下也可认为是Quality of Streaming，即流媒体服务的质量。通常，QOS可以由一系列指标表达，如传输速度、响应时间、发送顺序、正确率等。就视频服务来说，QOS由多项约定俗成的技术指标构成，包括播放成功率、错误率、Re-buffer（卡顿）次数和时间、起始时间、快进响应时间、视频码率、延迟等。
+通行的QOS指标大致可分为两类:  
+- 一类用于衡量用户可在多大概率上得到服务，如播放成功率和错误率。
+- 另一类描述了用户所获取到服务的水平，如卡顿次数、时间、起始时间、快进时间、视频码率和延迟。
+
+播放成功率描述了用户在尝试播放视频时启动成功的比率，可由所有成功开始播放的次数除以用户尝试的总数，常见于后端视频失效的情形。
+播放错误率意在针对播放过程中至少单个视频或音频帧被播放的情况下发生的错误，可能的原因包括播放器崩溃、硬件关闭、网络断开等，需要用户干预才能恢复播放。
+在视频服务质量日渐提升的今天，播放错误率出现的概率通常在千分之一以下甚至更低，用户最常见且容易不满的当属视频卡顿（也有人称之为缓冲率），即播放器无法即时得到流媒体传输的视频片段而需等待下载的情形。
+卡顿可能短程的发生，也可能持续很长时间，根据一些公司的研究，用户在观看视频点播时遇到一次以上的卡顿，会导致观看时间缩短一半，对直播用户的影响还要更甚于此。卡顿指标即包含单位时间内的卡顿次数也包含卡顿累计时间的维度，优化卡顿时间的最常见的方式是利用CDN和码率自适应算法。
+
+视频卡顿的一类特殊情形是起始播放时的卡顿，通常计算从用户点击播放到第一帧呈现在屏幕上为止的时间长度，因为获取最初可用的视频片段需要一定时间，包括后台服务准备资源、下载视频开始的片段、初始化软硬件等。 
+与播放过程中的卡顿不同，用户有等待数秒的心理预期，据调研2007年的大部分用户能接受10s以内的播放起始时间，但在2017年，5s的视频起始等待已被认为是非常糟糕的体验，中国许多视频服务商都提出了“秒开”的概念，力图将用户习以为常的起始时间固定在1s以内。另一类情形是快进时间，与起始时间非常类似，意指用户在点击快进后到视频呈现在屏幕之间的时间长度。
+优化起始时间可以通过将起始视频片段预先置于CDN的边缘节点，降低起始码率，增加播放器初始化并行度，预先建立网络连接等方式。此外，播放器还可以通过插入片头动画，持续播放快进前的视频片段直至快进后的视频帧准备好等手段降低用户的主观等待时间。 
+
+用户观看视频的平均码率也是一项核心指标，用于反馈视频的清晰度程度，针对直播服务，节目延迟时间也是核心指标，没有人原因在观看足球比赛时，隔壁已经为进球欢呼，而自己的电视上球员尚未开始射门，通常的计算标准是节目应播出的时间与实际屏幕上播放时间的间隔。带来延迟的除软件处理速度、网络传输速度外，编码器，源服务器及CDN服务器带来的缓存队列，播放器中解码器和渲染硬件均会引入大小不同的延迟。
+
+QOS数据由后台服务整合后将被应用于图表呈现、统计报告、分析优化、监控报警等用途，是产品、开发、运维、数据分析等团队依靠的基础。
+
+为更好的分析特定问题，收集关于某一用户播放过程的全部信息并按时序加以呈现，可以有效地帮助理解因果关系，信息将包括用户行为、执行时间、下载计时、码率切换记录、错误类型、CDN节点位置、服务器日志甚至一些计算的中间结果，将可有效地推断例如开始播放较为缓慢或者某次卡顿如何发生的原因。例如:  
+```
+xx:xx  Player Seek Start
+xx:xx Player Seek End
+xx:xx New State: Buffering
+....
+```
+
+Conviva在2011年的分享中提到以下观点，缓冲次数始终是最主要的影响用户体验的因素，在观看90分钟长度的OTT直播中，增加1%的缓冲比率将使用户减少3分钟的观看时间，同时认为，在直播过程中，平均码率的影响要比点播中更大。
+在2016年的一篇文章中，研究者利用YouSlow的数据分析得到的看法是，缓冲对退出观看的影响比启动时间要高六倍。
+### QOE
+视频公司在编码和传输上进行的优化，其指向的目标无疑是提升用户体验，或严格来讲，是获取更多的收入和利润。衡量编码或传输的优化表现，除了直接使用QOS指标如观看码率、启动时间、缓冲次数等，将其余QOE(Quality of Experience)指标连接则更可以直观地反应出成效。
+不断优化表现直接与收入关联的主要原因是，收入统计通常计出多门且较为滞后，可采用的替代指标包括注册用户数、活跃用户数、视频观察市场、观看次数、播放占比、付费率、留存率、分享率、满意度等。
+
+
+
 
 
 ### 监控
diff --git "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HLS.md" "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HLS.md"
index 707b4758..b2f222a2 100644
--- "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HLS.md"
+++ "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HLS.md"
@@ -198,6 +198,14 @@ live m3u8文件列表需要不断更新，更新规则：
 
 
 
+## TS相比MP4的劣势
+
+TS文件虽然适于优先电视领域的应用，但在带宽使用上与DASH所使用的扩展格式MP4相比有巨大的劣势。首先TS包按188字节分割过于细小，其包头虽然仅占4字节，累积起来仍嫌浪费。其次，重复插入的PSI包对持续的视频播放而言颇显肿余（虽然HLS协议的后期版本通过EXT-X-MAP标签支持独立的仅含PSI包的TS文件，但将引入兼容问题）。更重要的是，由于TS包的字节数限制，当视频或音频包不足字节数时，需要加上许多无用的填充字节。据不同来源统计，三项合计，TS文件平均要浪费4%~13%的带宽，设计较好的封装格式，在寸带宽寸金的互联网世界中，意味着节约千万甚至上亿美元。
+
+
+
+
+
 
 
 #### 测试地址:

From 63cf2e444cbae7c637aa8fabb4bfd594e477555b Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 8 Apr 2021 19:26:22 +0800
Subject: [PATCH 051/213] update README

---
 ...&\347\261\273&\346\216\245\345\217\243.md" |  5 ++-
 ...76\350\256\241\346\250\241\345\274\217.md" |  8 ++++
 ...05\350\201\224\345\207\275\346\225\260.md" |  4 +-
 ...0\347\273\204&\351\233\206\345\220\210.md" |  4 +-
 ...7&\345\205\263\351\224\256\345\255\227.md" |  6 +++
 ...2\344\270\276&\345\247\224\346\211\230.md" |  4 +-
 ...47\346\211\277\351\227\256\351\242\230.md" |  4 +-
 ...5\345\260\204&\346\211\251\345\261\225.md" |  4 +-
 .../8.Kotlin_\345\215\217\347\250\213.md"     |  2 +
 KotlinCourse/9.Kotlin_androidktx.md           | 12 +-----
 README.md                                     | 40 +++++++++----------
 11 files changed, 52 insertions(+), 41 deletions(-)

diff --git "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md" "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
index 995523d5..526cfff2 100644
--- "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
+++ "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
@@ -1087,7 +1087,10 @@ class Person(
 
 
 
-[下一篇:Kotlin学习教程(二)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%BA%8C).md)
+
+
+
+- [下一篇:2.Kotlin_高阶函数&Lambda&内联函数](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/2.Kotlin_%E9%AB%98%E9%98%B6%E5%87%BD%E6%95%B0%26Lambda%26%E5%86%85%E8%81%94%E5%87%BD%E6%95%B0.md)
 
 
 ---
diff --git "a/KotlinCourse/10.Kotlin_\350\256\276\350\256\241\346\250\241\345\274\217.md" "b/KotlinCourse/10.Kotlin_\350\256\276\350\256\241\346\250\241\345\274\217.md"
index fc6a644e..e7afcfdc 100644
--- "a/KotlinCourse/10.Kotlin_\350\256\276\350\256\241\346\250\241\345\274\217.md"
+++ "b/KotlinCourse/10.Kotlin_\350\256\276\350\256\241\346\250\241\345\274\217.md"
@@ -470,9 +470,17 @@ The latest stock price has fell to 98
 
 
 
+- [上一篇:9.Kotlin_androidktx](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/9.Kotlin_androidktx.md)       
 
 
 
+参考
+===
+
+- [Kotlin for Android Developers](https://leanpub.com/kotlin-for-android-developers)
+- [Resources to Learn Kotlin](https://developer.android.com/kotlin/resources.html)
+- [Kotlin语言中文站](https://www.kotlincn.net/docs/reference/coding-conventions.html)
+
 
 
 ---
diff --git "a/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md" "b/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
index 77f1b45e..8be83bb9 100644
--- "a/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
+++ "b/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
@@ -729,8 +729,8 @@ startActivity<DetailActivity>()
 
 
 
-[上一篇:Kotlin学习教程(六)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E5%85%AD).md)         
-[下一篇:Kotlin学习教程(八)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E5%85%AB).md)
+- [上一篇:1.Kotlin_简介&变量&类&接口](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/1.Kotlin_%E7%AE%80%E4%BB%8B%26%E5%8F%98%E9%87%8F%26%E7%B1%BB%26%E6%8E%A5%E5%8F%A3.md)         
+- [下一篇:3.Kotlin_数字&字符串&数组&集合](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/3.Kotlin_%E6%95%B0%E5%AD%97%26%E5%AD%97%E7%AC%A6%E4%B8%B2%26%E6%95%B0%E7%BB%84%26%E9%9B%86%E5%90%88.md)
 
 
 ---
diff --git "a/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md" "b/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md"
index 3cab6d55..f7eb5bf6 100644
--- "a/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md"
+++ "b/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md"
@@ -561,8 +561,8 @@ loop@ for (i in 1..100) {
 ```
 
 
-[上一篇:Kotlin学习教程(二)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%BA%8C).md)         
-[下一篇:Kotlin学习教程(四)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E5%9B%9B).md)
+- [上一篇:2.Kotlin_高阶函数&Lambda&内联函数](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/2.Kotlin_%E9%AB%98%E9%98%B6%E5%87%BD%E6%95%B0%26Lambda%26%E5%86%85%E8%81%94%E5%87%BD%E6%95%B0.md)    
+- [下一篇:4.Kotlin_表达式&关键字](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/4.Kotlin_%E8%A1%A8%E8%BE%BE%E5%BC%8F%26%E5%85%B3%E9%94%AE%E5%AD%97.md)
 
 
 ---
diff --git "a/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md" "b/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md"
index f2196189..7c3921ea 100644
--- "a/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md"
+++ "b/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md"
@@ -218,6 +218,12 @@ for(num in nums) {
 - `object`对象声明并且它总是在`object{: .keyword }`关键字后跟一个名称。对象表达式：在要创建一个继承自某个(或某些)类型的匿名类的对象会
     用到
 
+
+
+
+- [上一篇:3.Kotlin_数字&字符串&数组&集合](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/3.Kotlin_%E6%95%B0%E5%AD%97%26%E5%AD%97%E7%AC%A6%E4%B8%B2%26%E6%95%B0%E7%BB%84%26%E9%9B%86%E5%90%88.md)       
+- [下一篇:5.Kotlin_内部类&密封类&枚举&委托](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/5.Kotlin_%E5%86%85%E9%83%A8%E7%B1%BB%26%E5%AF%86%E5%B0%81%E7%B1%BB%26%E6%9E%9A%E4%B8%BE%26%E5%A7%94%E6%89%98.md)    
+
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
diff --git "a/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md" "b/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
index d6ea8ce6..0f50c432 100644
--- "a/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
+++ "b/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
@@ -670,8 +670,8 @@ class MutableUser(val map: MutableMap<String, Any?>) {
 ```
 
 
-[上一篇:Kotlin学习教程(四)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E5%9B%9B).md)       
-[下一篇:Kotlin学习教程(六)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E5%85%AD).md)
+- [上一篇:4.Kotlin_表达式&关键字](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/4.Kotlin_%E8%A1%A8%E8%BE%BE%E5%BC%8F%26%E5%85%B3%E9%94%AE%E5%AD%97.md)       
+- [下一篇:6.Kotlin_多继承问题](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/6.Kotlin_%E5%A4%9A%E7%BB%A7%E6%89%BF%E9%97%AE%E9%A2%98.md)
 
 
 ---
diff --git "a/KotlinCourse/6.Kotlin_\345\244\232\347\273\247\346\211\277\351\227\256\351\242\230.md" "b/KotlinCourse/6.Kotlin_\345\244\232\347\273\247\346\211\277\351\227\256\351\242\230.md"
index 29bd7403..3dbf5fe7 100644
--- "a/KotlinCourse/6.Kotlin_\345\244\232\347\273\247\346\211\277\351\227\256\351\242\230.md"
+++ "b/KotlinCourse/6.Kotlin_\345\244\232\347\273\247\346\211\277\351\227\256\351\242\230.md"
@@ -191,8 +191,8 @@ fun main(args: Array<String>) {
 
 
 
-[上一篇:Kotlin学习教程(七)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%B8%83).md)         
-[下一篇:Kotlin学习教程(八)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E5%85%AB).md)
+- [上一篇:5.Kotlin_内部类&密封类&枚举&委托](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/5.Kotlin_%E5%86%85%E9%83%A8%E7%B1%BB%26%E5%AF%86%E5%B0%81%E7%B1%BB%26%E6%9E%9A%E4%B8%BE%26%E5%A7%94%E6%89%98.md)         
+- [下一篇:7.Kotlin_注解&反射&扩展](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/7.Kotlin_%E6%B3%A8%E8%A7%A3%26%E5%8F%8D%E5%B0%84%26%E6%89%A9%E5%B1%95.md)
 
 
 ---
diff --git "a/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md" "b/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md"
index 42330826..8bd40753 100644
--- "a/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md"
+++ "b/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md"
@@ -1067,8 +1067,8 @@ class Group<T>(val name: String) {
 
 
 
-[上一篇:Kotlin学习教程(五)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%BA%94).md)          
-[下一篇:Kotlin学习教程(七)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%B8%83).md)
+- [上一篇:6.Kotlin_多继承问题](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/6.Kotlin_%E5%A4%9A%E7%BB%A7%E6%89%BF%E9%97%AE%E9%A2%98.md)    
+- [下一篇:8.Kotlin_协程](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/8.Kotlin_%E5%8D%8F%E7%A8%8B.md)
 
 
 ---
diff --git "a/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md" "b/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
index 4826886f..04243795 100644
--- "a/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
+++ "b/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
@@ -769,6 +769,8 @@ println("Done!")
 ```
 
 
+- [上一篇:7.Kotlin_注解&反射&扩展](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/7.Kotlin_%E6%B3%A8%E8%A7%A3%26%E5%8F%8D%E5%B0%84%26%E6%89%A9%E5%B1%95.md)       
+- [下一篇:9.Kotlin_androidktx](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/9.Kotlin_androidktx.md)
 
 
 ---
diff --git a/KotlinCourse/9.Kotlin_androidktx.md b/KotlinCourse/9.Kotlin_androidktx.md
index aaef520a..5316334e 100644
--- a/KotlinCourse/9.Kotlin_androidktx.md
+++ b/KotlinCourse/9.Kotlin_androidktx.md
@@ -96,19 +96,11 @@ public class ForecastRequest(val zipCode: String) {
 
 
 
-[上一篇:Kotlin学习教程(八)](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E5%85%AB).md)         
-[下一篇:Kotlin学习教程](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E5%8D%81).md)
+- [上一篇:8.Kotlin_协程](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/8.Kotlin_%E5%8D%8F%E7%A8%8B.md)         
+- [下一篇:10.Kotlin_设计模式](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/10.Kotlin_%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F.md)
 
 
 
-参考
-===
-
-- [Kotlin for Android Developers](https://leanpub.com/kotlin-for-android-developers)
-- [Resources to Learn Kotlin](https://developer.android.com/kotlin/resources.html)
-- [Kotlin语言中文站](https://www.kotlincn.net/docs/reference/coding-conventions.html)
-
-
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
diff --git a/README.md b/README.md
index 1a456b7f..78f801b2 100644
--- a/README.md
+++ b/README.md
@@ -144,16 +144,16 @@ Android学习笔记
     - [Icon制作][223]
 
 - [Kotlin学习][48]
-    - [Kotlin学习教程(一)][180]
-    - [Kotlin学习教程(二)][181]
-    - [Kotlin学习教程(三)][182]
-    - [Kotlin学习教程(四)][183]
-    - [Kotlin学习教程(五)][184]
-    - [Kotlin学习教程(六)][185]
-    - [Kotlin学习教程(七)][186]
-    - [Kotlin学习教程(八)][187]
-    - [Kotlin学习教程(九)][188]
-    - [Kotlin学习教程(十)][197]
+    - [1.Kotlin_简介&变量&类&接口][180]
+    - [2.Kotlin_高阶函数&Lambda&内联函数][181]
+    - [3.Kotlin_数字&字符串&数组&集合][182]
+    - [4.Kotlin_表达式&关键字][183]
+    - [5.Kotlin_内部类&密封类&枚举&委托][184]
+    - [6.Kotlin_多继承问题][185]
+    - [7.Kotlin_注解&反射&扩展][186]
+    - [8.Kotlin_协程][187]
+    - [9.Kotlin_androidktx][188]
+    - [10.Kotlin_设计模式][197]
 
 
 
@@ -492,15 +492,15 @@ Android学习笔记
 [179]: https://github.com/CharonChui/AndroidNote/blob/master/BasicKnowledge/XmlPullParser.md   "XmlPullParser"
 
 
-[180]: https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%B8%80).md "Kotlin学习教程(一)"
-[181]: https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%BA%8C).md "Kotlin学习教程(二)"
-[182]: https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%B8%89).md "Kotlin学习教程(三)"
-[183]: https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E5%9B%9B).md "Kotlin学习教程(四)"
-[184]: https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%BA%94).md "Kotlin学习教程(五)"
-[185]: https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E5%85%AD).md "Kotlin学习教程(六)"
-[186]: https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%B8%83).md "Kotlin学习教程(七)"
-[187]: https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E5%85%AB).md "Kotlin学习教程(八)"
-[188]: https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E4%B9%9D).md "Kotlin学习教程(九)"
+[180]: https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/1.Kotlin_%E7%AE%80%E4%BB%8B%26%E5%8F%98%E9%87%8F%26%E7%B1%BB%26%E6%8E%A5%E5%8F%A3.md "1.Kotlin_简介&变量&类&接口"
+[181]: https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/2.Kotlin_%E9%AB%98%E9%98%B6%E5%87%BD%E6%95%B0%26Lambda%26%E5%86%85%E8%81%94%E5%87%BD%E6%95%B0.md "2.Kotlin_高阶函数&Lambda&内联函数.md"
+[182]: https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/3.Kotlin_%E6%95%B0%E5%AD%97%26%E5%AD%97%E7%AC%A6%E4%B8%B2%26%E6%95%B0%E7%BB%84%26%E9%9B%86%E5%90%88.md "3.Kotlin_数字&字符串&数组&集合"
+[183]: https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/4.Kotlin_%E8%A1%A8%E8%BE%BE%E5%BC%8F%26%E5%85%B3%E9%94%AE%E5%AD%97.md "4.Kotlin_表达式&关键字"
+[184]: https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/5.Kotlin_%E5%86%85%E9%83%A8%E7%B1%BB%26%E5%AF%86%E5%B0%81%E7%B1%BB%26%E6%9E%9A%E4%B8%BE%26%E5%A7%94%E6%89%98.md "5.Kotlin_内部类&密封类&枚举&委托"
+[185]: https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/6.Kotlin_%E5%A4%9A%E7%BB%A7%E6%89%BF%E9%97%AE%E9%A2%98.md "6.Kotlin_多继承问题"
+[186]: https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/7.Kotlin_%E6%B3%A8%E8%A7%A3%26%E5%8F%8D%E5%B0%84%26%E6%89%A9%E5%B1%95.md "7.Kotlin_注解&反射&扩展"
+[187]: https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/8.Kotlin_%E5%8D%8F%E7%A8%8B.md "8.Kotlin_协程"
+[188]: https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/9.Kotlin_androidktx.md "9.Kotlin_androidktx"
 [189]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E5%85%AB%E7%A7%8D%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95.md "八种排序算法"
 [190]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E7%BA%BF%E7%A8%8B%E6%B1%A0%E7%AE%80%E4%BB%8B.md "线程池简介"
 [191]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F.md "设计模式"
@@ -509,7 +509,7 @@ Android学习笔记
 [194]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/ConstraintLaayout%E7%AE%80%E4%BB%8B.md "ConstraintLaayout简介"
 [195]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/Http%E4%B8%8EHttps%E7%9A%84%E5%8C%BA%E5%88%AB.md "Http与Https的区别"
 [196]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/Top-K%E9%97%AE%E9%A2%98.md "Top-K问题"
-[197]: https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/Kotlin%E5%AD%A6%E4%B9%A0%E6%95%99%E7%A8%8B(%E5%8D%81).md "Kotlin学习教程(十)"
+[197]: https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/10.Kotlin_%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F.md "10.Kotlin_设计模式"
 [198]: https://github.com/CharonChui/AndroidNote/blob/master/AppPublish/%E4%BD%BF%E7%94%A8Jenkins%E5%AE%9E%E7%8E%B0%E8%87%AA%E5%8A%A8%E5%8C%96%E6%89%93%E5%8C%85.md "使用Jenkins实现自动化打包"
 [199]: https://github.com/CharonChui/AndroidNote/tree/master/Dagger2 "Dagger2"
 [200]: https://github.com/CharonChui/AndroidNote/blob/master/Dagger2/1.Dagger2%E7%AE%80%E4%BB%8B(%E4%B8%80).md  "1.Dagger2简介(一).md"

From 096b5da5a9def2ac9e7953213e6f6f7f71ba9f3d Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Fri, 9 Apr 2021 15:54:50 +0800
Subject: [PATCH 052/213] update kotlin notes

---
 ...&\347\261\273&\346\216\245\345\217\243.md" | 134 ++++++++++++++++--
 ...05\350\201\224\345\207\275\346\225\260.md" |  72 ++++++++++
 ...0\347\273\204&\351\233\206\345\220\210.md" | 126 ++++++++++++++--
 ...2\344\270\276&\345\247\224\346\211\230.md" |  58 +++++++-
 .../8.Kotlin_\345\215\217\347\250\213.md"     |  19 +++
 5 files changed, 385 insertions(+), 24 deletions(-)

diff --git "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md" "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
index 526cfff2..c4e3454b 100644
--- "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
+++ "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
@@ -204,6 +204,20 @@ var weight = 70.5 // double
 	}
 	```
 
+
+
+### 变量保存了指向对象的引用
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/variable.jpg?raw=true)        
+
+当该对象被赋值给变量时，这个对象本身并不会被直接赋值给当前的变量。相反，该对象的引用会被赋值给该变量。因为当前的变量存储的是对象的引用，因此它可以访问该对象。
+
+如果你使用val来声明一个变量，那么该变量所存储的对象的引用将不可修改。然而如果你使用var声明了一个变量，你可以对该变量重新赋值。例如，如果我们使用代码： `x = 6`，将x的值赋为6，此时会创建一个值为6的新Int对象，并且x会存放该对象的引用。下面新的引用会替代原有的引用值被存放在x中： 
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/var_chage.jpg?raw=true)        
+
+**注意: 在Java中，数字类型是原生类型，所以变量存储的是实际数值。但是在Kotlin中的数字也是对象，而变量仅仅存储该数字对象的引用，并非对象本身。**
+
 ### 优先使用val来避免副作用
 
 在很多Kotlin的学习资料中，都会传递一个原则：优先使用val来声明变量。这相当正确，但更好的理解可以是：尽可能采用val、不可变对象及纯函数来设计程序。关于纯函数的概念，其实就是没有副作用的函数，具备引用透明性。
@@ -267,7 +281,7 @@ var size: Int = 2
 这个例子中就会内存溢出。   
 
 `kotlin`为此提供了一种我们要说的后端变量，也就是`field`。编译器会检查函数体，如果使用到了它，就会生成一个后端变量，否则就不会生成。
-我们在使用的时候，用`field`代替属性本身进行操作。按照惯例`set`参数的名称是`value`，但是如果你喜欢你可以选择一个不同的名称。
+我们在使用的时候，用`field`代替属性本身进行操作。按照惯例`set`参数的名称是`value`，但是如果你喜欢你可以选择一个不同的名称。setter通过field标识更新变量属性值。field指的是属性的支持字段，你可以将其视为对属性的底层值的引用。在getter和setter中使用field代替属性名称很重要，因为这样可以阻止你陷入无限循环中。
 
 ```kotlin
 class A {
@@ -289,7 +303,17 @@ fun main() {
 1
 ```
 
+如果我们不手动写getter和setter方法，编译器会在编译代码时添加以下代码段： 
+
+```kotlin
+var myProperty: String
+    get() = field
+    set(value) {
+        field = value
+    }
+```
 
+这意味着无论何时当你使用点操作符来获取或设置属性值时，实际上你总是调用了属性的getter或是setter。那么，为什么编译器要这么做呢？为属性添加getter和setter意味着有访问该属性的标准方法。getter处理获取值的所有请求，而setter处理所有属性值设置的请求。因此，如果你想要改变处理这些请求的方式，你可以在不破坏任何人代码的前提下进行。通过将其包装在getter和setter中来输出对属性的直接访问称为数据隐藏。
 
 ## 延迟初始化
 
@@ -375,7 +399,20 @@ val sex: String by lazy(LazyThreadSafetyMode.NONE) {
 
 ## 类的定义:使用`class`关键字
 
+当你在定义类的时候，你需要想想该类所创建的对象需要什么。你需要考虑：
+
+- 每个对象自身的特点
+
+    对象自身的特点称为属性（properties）。它们代表了对象自身的状态（数据），并且该类中的每一个对象都有自己独特的数值。例如，一个狗（Dog）类可能有名字（name）、体重（weight）和品种（breed）属性。一个歌曲（Song）类可能有标题（title）和演唱者（artist）属性。
+
+- 每个对象的行为
+
+    对象的行为是它们的函数（functions）。它们决定了对象的行为，并且可能回使用对象的属性。例如，之前提到的Dog类，可能具有吠叫（bark）函数；Song这个类可能会有播放（play）函数。
+
+
+
 类可以包含:  
+
 - 构造函数和初始化块
 - 函数
 - 属性
@@ -383,29 +420,67 @@ val sex: String by lazy(LazyThreadSafetyMode.NONE) {
 - 对象声明
 
 
-```kotlin
-class MainActivity{
 
+你可以将类想象成一个对象的模板，因为它告诉编译器如何创建该特定类的对象。它还将告诉编译器每个对象应该具有哪些属性，并且从该类生成的每个对象都可以拥有自己独有的属性值。例如，每个Dog对象都有自己的名称、重量和品种属性，每个Dog的属性值都可以是不同的。
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/kotlin_class_1.jpg?raw=true)        
+
+
+
+
+```kotlin
+class Dog(val name: String, var weight: Int, val breed: String){
+	fun bark() {
+        
+    }
 }
 ```
 
 如果有参数的话你只需要在类名后面写上它的参数，如果这个类没有任何内容可以省略大括号：
 ```kotlin
-class Person(name: String, age: Int)
+class Dog(val name: String, var weight: Int, val breed: String)
 ```
 
 ### 创建类的实例
 
 ```kotlin
-val person = Person("charon", 18)
+val myDog = Dog("Fido", 70, "Mixed" )
 ```
 
 上面的类有一个默认的构造函数。
 
 注意:创建类的实例不用`new`了啊。
 
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/kotlin_class_dog_sample.jpg?raw=true)        
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/kotlin_class_dog.jpg?raw=true)        
+
+类中所定义的函数又称为成员函数。有时也被称为方法。
+
+#### 创建对象的执行过程
+
+```kotlin
+var myDog = Dog("Fido", 70, "Mixed")
+```
+
+1. 系统会为每个传入Dog构造函数的参数创建一个对象。它会创建一个值为“Fido”的String，一个值为70的Int，以及一个值为“Mixed”的String。
+2. 系统会为一个新的Dog对象分配空间，并且Dog构造函数会被调用。
+3. Dog构造函数定义了三个属性：名称、重量以及品种。在这个现象背后，每一个属性实际上是一个变量。对于构造函数中定义的每个属性，都会有一个相应类型的变量被创建。
+4. 相应的变量的引用将会被赋值给Dog的属性。例如，值为“Fido”的String将会被赋值给name属性。
+5. 最后，这个新的Dog对象的引用将会被赋值给名为myDog的Dog变量。
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/kotlin_dog_new.jpg?raw=true)        
+
+
+
+
+
+
+
 ### 构造函数
 
+构造函数包含了初始化对象所需的代码。它在对象被分配给引用之前运行，这意味着你有机会对对象进行一些内部操作以便其被使用。大多人使用构造函数来定义对象的属性，并且给这些属性赋值。每当你创建一个新的对象，该对象所属的类的构造函数将会被调用。构造函数在你初始化对象时被调用。它通常被用于定义对象的属性，并且对属性赋值。
+
 在`Kotlin`中的一个类可以有一个主构造函数和一个或多个次构造函数。
 
 #### 主构造函数
@@ -616,6 +691,8 @@ data class Artist(
     var mbid: String)
 ```
 
+数据类自动覆盖它们的equals方法以改变==操作符的行为，由此通过检查对象的每个属性值来判断是否相等。例如，假设你创建了两个属性值完全相同的Recipe对象，使用==操作符对它们进行比较将返回true，因为它们存放了相同的数据：除了提供从Any父类继承的equals方法的新实现，数据类还覆盖了hashCode和toString方法。
+
 通过数据类，会自动提供以下函数：
 
 - 所有属性的`get() set()`方法
@@ -649,7 +726,13 @@ val charon2 = charon.copy(age = 19)
 - data class之前不能用abstract、open、sealed或者inner进行修饰
 - 在Kotlin 1.1版本前数据类只允许实现接口，之后的版本既可以实现接口也可以继承类
 
-## 多声明
+
+
+与任何其他类一样，你可以向数据类添加属性和方法，只需要将它们包含在类主体中。但是有一个大问题。在编译器生成数据类的方法实现时，比如覆盖equals方法和创建copy方法，它仅包含在主构造函数中定义的属性。因此如果你在数据类主体中定义添加的属性，则它们不会被包含到任何编译器生成的方法中。
+
+### 数据类定义了componentN方法
+
+定义数据类时，编译器会自动向该类添加一组方法，你可以将其作为访问对象属性值的替代方法。它们被称为componentN方法，其中N表示被访问属性的编号（按声明排序）。
 
 多声明，也可以理解为变量映射，这就是编译器自动生成的`componentN()`方法。
 
@@ -689,6 +772,10 @@ open class Person(num: Int)
 class SuperPerson(num: Int) : Person(num)
 ```
 
+冒号后面的Person(num)会调用Person类的构造函数，以确保所有的初始化代码（例如给属性赋值）能够被执行。调用父类构造函数是强制性的：如果父类有主构造函数，你必须在子类头中调用它，否则代码将无法通过编译。请记住，即使你没有在父类中显式地添加构造函数，编译器也会在编译代码的时候自动创建一个空构造函数。假如我们不想为Person类添加构造函数，因此编译器在编译代码的时候创建了一个空构造函数。该构造函数通过使用Person()被调用。
+
+
+
 如果该类有一个主构造函数，其基类必须用基类型的主构造函数参数就地初始化。
 如果类没有主构造函数，那么每个次构造函数必须使用`super`关键字初始化其基类型，或委托给另一个构造函数做到这一点。
 注意，在这种情况下，不同的次构造函数可以调用基类型的不同的构造函数:   
@@ -849,7 +936,7 @@ open class SuperPerson(num: Int) : Person(num) {
 }
 ```
 
-每个声明的属性可以由具有初始化器的属性或者具有`get`方法的属性覆盖，你也可以用一个`var`属性覆盖一个`val`属性，但反之则不行。
+每个声明的属性可以由具有初始化器的属性或者具有`get`方法的属性覆盖，如果某个属性在父类中被定义为val，你可以在子类中使用var属性覆盖它。只需要覆盖该属性并将其声明为var即可。请注意，这只适用于这一种方式。如果尝试使用val覆盖var属性，编译器将会感到沮丧并拒绝编译你的代码。
 
 
 
@@ -886,9 +973,10 @@ abstract class Derived : Base() {
 
 
 
-
 ## 接口:使用`interface`关键字
 
+接口可以让你在父类层次结构之外定义共同的行为接口用于为共同行为定义协议，使你可以不依赖严格的继承结构却又可以利用多态。与抽象类类似，接口不能被实例化且可以定义抽象或具体的方法和属性，但两者有一个关键的不同点：类可以实现多个接口，但是只能继承于一个直接父类。所以接口不仅拥有抽象类的优点，而且使用起来更加灵活。
+
 ```kotlin
 interface FlyingAnimal {
     fun fly()
@@ -964,6 +1052,26 @@ toast("Hello")
 toast("Hello", Toast.LENGTH_LONG)
 ```
 
+### 无参主函数
+
+如果你使用的是Kotlin1.2或更早的版本，若想正常运行程序，你的主函数必须写成如下形式:   
+
+```kotlin
+fun main(args: Array<String>) {
+    // ...
+}
+```
+
+从Kotlin1.3版本器，你可以忽略main函数的参数，写成如下形式:   
+
+```kotlin
+fun main() {
+    // ...
+}
+```
+
+
+
 
 
 ### 可变长参数函数:使用`vararg`关键字
@@ -981,6 +1089,16 @@ fun main(args: Array<String>) {
 }
 ```
 
+如果你有一个现有的值数组，则可以通过在数组名前加上`*`来将这些值传递给该函数。星号`（*）`被称为扩展运算符，以下是它的一些使用示例：
+
+```kotlin
+vval myArray = arrayOf(1, 2, 3, 4, 5)
+val mList = vars(*myArray)
+val mList2 = vars(0, *myArray, 6, 7)
+```
+
+
+
 
 
 ### `Unit`:让函数调用皆为表达式
diff --git "a/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md" "b/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
index 8be83bb9..78f38efb 100644
--- "a/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
+++ "b/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
@@ -252,6 +252,8 @@ val foo = { x: Int ->
 > “Lambda 表达式”(lambda expression)其实就是匿名函数，`Lambda`表达式基于数学中的`λ`演算得名，直接对应于其中的`lambda`抽象
 > `(lambda abstraction)`，是一个匿名函数，即没有函数名的函数。`Lambda`表达式可以表示闭包（注意和数学传统意义上的不同）。
 
+
+
 `Java 8`的一个大亮点是引入`Lambda`表达式，使用它设计的代码会更加简洁。
 
 ```java
@@ -327,6 +329,50 @@ val sum: (Int, Int) -> Int = { x, y -> x + y }
 则此`Lambda`表达式变成`val sum = { x: Int, y: Int -> x + y }`，此时`Lambda`表达式会根据主体中的最后一个（或可能是单个）表达式会视为
 返回值。当然，在某些特定情况下，`x`、`y`的类型了是可以推断的，所以`val sum = { x, y -> x + y }`。
 
+
+
+通过调用lambda来执行它的代码你可以使用invoke函数调用lambda，并传入参数的值。例如，以下代码定义了变量addInts，并将用于将两个Int参数相加的lambda赋值给它。然后代码调用了该lambda，传入参数值6和7，并将结果赋值给变量result：
+
+```kotlin
+val addInts = { x: Int, y: Int -> x + y }
+val result = addInts.invoke(6, 7)
+// 还可以使用如下快捷方式调用lambda：
+val result = addInts(6, 7)
+
+```
+
+### lambda表达式类型
+
+就像任何其他类型的对象一样，lambda也具有类型。然而，lambda类型的不同点在于，它不会为lambda的实现指定类名，而是指定lambda的参数和返回值的类型。lambda类型的格式如下：
+
+```kotlin
+(parameters) -> return_type
+```
+
+因此，如果你的lambda具有单独的Int参数并返回一个字符串，如下代码所示：
+
+```kotlin
+val msg = { x: Int -> "xxx" }
+```
+
+其类型为: 
+
+```kotlin
+(Int) -> String
+```
+
+如果将lambda赋值给一个变量，编译器会根据该lambda来推测变量的类型，如上例所示。然而，就像任何其他类型的对象一样，你可以显式地定义该变量的类型。例如，以下代码定义了一个变量add，该变量可以保存对具有两个Int参数并返回Int类型的lambda的引用：
+
+```kotlin
+val add: (Int, Int) -> Int
+
+add = { x: Int, y: Int -> x + y }
+```
+
+Lambda类型也被认为是函数类型。
+
+
+
 ## Lambda开销
 
 ```kotlin
@@ -344,6 +390,32 @@ listOf(1, 2, 3).forEach { item -> foo(item) }
 
 默认情况下，我们可以直接用it来代表item，而不需要用item -> 进行声明。
 
+你可以将单独的参数替换为it。
+
+如果lambda具有一个单独的参数，而且编译器能够推断其类型，你可以省略该参数，并在lambda的主体中使用关键字it指代它。
+
+要了解它是如何工作的，如前所述，假设使用以下代码将lambda赋值给变量：
+
+```kotlin
+val addFive: (Int) -> Int = { x -> x + 5 }
+```
+
+由于lambda具有单独的参数x，而且编译器能够推断出x为Int类型，因此我们可以省略该x参数，并在lambda的主体中使用it替换它：
+
+```kotlin
+val addFive: (Int) - Int = { it + 5 }
+```
+
+在上述代码中，{it+5}等价于{x->x+5}，但更加简洁。请注意，你只能在编译器能够推断该参数类型的情况下使用it语法。例如，以下代码将无法编译，因为编译器不知道it应该是什么类型：
+
+```kotlin
+val addFive = { it + 5 } // 该代码无法编译，因为编译器不能推断其类型
+```
+
+
+
+
+
 我们看一下foo函数用IDE转换后的Java代码:  
 
 ```java
diff --git "a/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md" "b/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md"
index f7eb5bf6..2a31cef7 100644
--- "a/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md"
+++ "b/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md"
@@ -27,6 +27,7 @@ Byte    8
 注意在`Kotlin`中字符不是数字,字符用`Char`类型表示。它们不能直接当作数字
 
 
+
 ### 字面常量
 
 数值常量字面值有以下几种:   
@@ -87,6 +88,40 @@ toDouble(): Double
 toChar(): Char
 ```
 
+#### 数值类型转换背后发生了什么
+
+```kotlin
+var x = 5 // 这行代码创建了一个Int类型的变量x以及一个Int类型值为5的对象。x保存了该对象的引用
+var z : Long = x.toLong() // 这行代码创建了一个新的Long变量z。x对象的toLong()函数被调用并且创建了一个值为5的Long对象，该Long对象的引用被存储在z中
+```
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/var_type_change.jpg?raw=true)        
+
+该方法可以较好地应用于从存储小数据的类型转换为能存储较大数据的类型。那么，如果该数值超出了新对象所能存储的范围该怎么办？
+
+试图将一个大的数值放入一个容量较小的变量中就好比试图将桶装咖啡倒入小茶杯中。有些咖啡会被倒入茶杯中，但是有些会溢出。
+
+假如你想将Long的值放入Int中。正如我们之前所提到的，Long可以容纳比Int更大的数字。
+
+因此如果Long的值在Int可存储的范围之内，那么从Long转换为Int是没有问题的。例如，将一个值为42的Long转换为Int将得到一个值为42的Int: 
+
+```kotlin
+var x = 42L
+var y: Int = x.toInt() // 值为42
+```
+
+但是如果Long的值超出了Int能容纳的范围，那么编译器将会舍弃超出的部分，此时你会得到一个奇怪（仍可计算）的数值。例如:  
+
+```kotlin
+var x = 1234567890123
+var y: Int = x.toInt()
+println(y) // 1912276171
+```
+
+这设计数值正负、位运算、二进制等其他一些计算机知识。这里不再细说。
+
+
+
 ### 运算
 
 这是完整的位运算列表(只用于`Int`和`Long`):
@@ -231,12 +266,23 @@ print(boxedA == anotherBoxedA) // 输出“true”
 
 ### 数组
 
+你可以将数组想象成一托盘的杯子，其中每个杯子都是一个变量。
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/array.jpg?raw=true)        
+
+
+
 数组用类`Array`实现，并且还有一个`size`属性及`get`和`set`方法，由于使用`[]`重载了`get`和`set`方法，所以我们可以通过下标很方便的获取或者
 设置数组对应位置的值。       
 `Kotlin`标准库提供了`arrayOf()`创建数组和`xxArrayOf`创建特定类型数组      
 
 ```kotlin
-val array = arrayOf(1, 2, 3)
+val myArray = arrayOf(1, 2, 3)
+```
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/array_myarray.jpg?raw=true)        
+
+```kotlin
 val countries = arrayOf("UK", "Germany", "Italy")
 val numbers = intArrayOf(10, 20, 30)
 val array1 = Array(10, { k -> k * k })
@@ -250,6 +296,30 @@ studentArray[0] = Student("james")
 
 ### 集合 
 
+Kotlin有三个主要的集合类型（List、Set和Map），每一个都有不同的用途。
+
+- List——当顺序很重要
+
+    List知道而且在意索引的位置。它知道List中的元素在哪里，而且你可以使多个元素指向同一个对象。
+
+- Set——当唯一性很重要
+
+    Set不允许重复，而且不在意值的存放顺序。你不可以使多个元素指向同一个对象，或是被认为相等的两个对象。
+
+    ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/kotlin_list_set.jpg?raw=true)        
+
+- Map——当键检索很重要
+
+    Map使用键值对，它知道与给定键相关联的值。你可以使两个键指向同一个对象，但不可以有重复的键。键通常为String类型（因此你可以创建例如键值对属性列表），但它也可以是任意对象。
+
+    ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/kotlin_map.jpg?raw=true)        
+
+    
+
+简单的List、Set和Map是不可变的，这意味着集合被初始化后不能再添加或移除元素。如果想要添加或移除元素，Kotlin提供了可变的子类型作为替代方案：MutableList、MutableSet和MutableMap。因此，如果想要利用List的所有优势，并希望能够更新其内容，请使用MutableList。
+
+
+
 `Kotlin`的`List<out T>`类型是一个提供只读操作如`size`、`get`等的接口。和`Java`类似，它继承自`Collection<T>`进而继承自`Iterable<T>`。
 改变`list`的方法是由`MutableList<T>`加入的。这一模式同样适用于`Set<out T>/MutableSet<T>`及`Map<K, out V>/MutableMap<K, V>`。
 
@@ -503,16 +573,6 @@ val l = b!!.length
 
 因此，如果你想要一个NPE，你可以得到它，但是你必须显式要求它，否则它不会不期而至。
 
-
-#### 安全的类型转换
-
-如果对象不是目标类型，那么常规类型转换可能会导致`ClassCastException`。
-另一个选择是使用安全的类型转换，如果尝试转换不成功则返回`null{: .keyword }`:    
-
-```kotlin
-val aInt: Int? = a as? Int
-```
-
 #### 可空类型的集合
 
 如果你有一个可空类型元素的集合，并且想要过滤非空元素，你可以使用`filterNotNull`来实现。
@@ -526,7 +586,7 @@ val intList: List<Int> = nullableList.filterNotNull()
 
 ### 使用类型检测及自动类型转换
 
-`is`运算符检测一个表达式是否某类型的一个实例。 如果一个不可变的局部变量或属性已经判断出为某类型，那么检测后的分支中可以直接当作该类型使用，
+`is`运算符检测一个表达式是否某类型的一个实例。 如果一个不可变的局部变量或属性已经判断出为某类型，那么检测后的分支中可以直接当作该类型使用，在大多数情况下，is操作符会进行智能转换。转换表示编译器将变量当作与其声明的类型不同的类型，而智能转换是说编译器替你自动地进行转换。
 无需显式转换:   
 
 ```kotlin
@@ -540,6 +600,48 @@ fun getStringLength(obj: Any): Int? {
 }
 ```
 
+
+
+只要编译器能够保证在介于判断对象类型和被使用之间不能修改变量，is操作符就会进行智能转换。
+
+例如，在上面的代码中，编译器知道在介于调用is操作符和调用String的某个方法之间，item变量不能被赋予另一类型的引用。但是在一些特殊情况下，智能转换不会生效。例如，is操作符不会对类中的var属性进行智能转换，那是因为编译器无法保证别的代码不会溜进来更新该属性。这意味着如下代码将不能编译，因为编译器不能将r变量智能转换为一个Wolf对象：
+
+```kotlin
+class MyRomable {
+    var r: Roamable = Wolf()
+    
+    fun myFunction() {
+        if (r is Wolf) {
+            r.eat() // 编译器无法智能的将Roamable的r属性转换成一个Wolf对象，这事因为编译器不能保证在判断r属性类型和使用它的器件，其它代码不会更新该属性，因此这段代码不能编译成功。
+        }
+    }
+}
+```
+
+那么遇到这种情况我们应该如何处理呢？你无须记住所有不能使用智能转换的场景。如果你尝试使用智能转换的方式不合理，编译器会提醒你。编译器会提醒你。
+
+#### 安全的类型转换
+
+如果对象不是目标类型，那么常规类型转换可能会导致`ClassCastException`。
+另一个选择是使用安全的类型转换，如果尝试转换不成功则返回`null{: .keyword }`:    
+
+```kotlin
+val aInt: Int? = a as? Int
+```
+
+如果你想要访问某个潜在对象的行为，但编译器无法对其进行智能转换，你可以显式地将该对象转换成合适的类型。假设你能够确定名为r的Roamable类型变量保存的是Wolf对象的引用。在这种情况下，你可以使用as操作符去复制一份Roamable类型变量中保存的引用，并强制地将该引用赋给一个新的Wolf类型变量。然后你就可以使用该Wolf类型变量去访问Wolf的行为。具体代码如下：
+
+```kotlin
+if (r is Wolf) {
+    var wolf = r as Wolf // 这段代码显式地将对象转换为Wolf类型，使你可以调用它的方法
+    wolf.eat()
+}
+```
+
+
+
+
+
 ### 返回和跳转
 
 `Kotlin`有三种结构化跳转表达式:    
diff --git "a/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md" "b/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
index 0f50c432..1d18d2c4 100644
--- "a/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
+++ "b/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
@@ -171,9 +171,60 @@ val searchName: String = Icon.SEARCH.name()
 val searchPosition: Int = Icon.SEARCH.ordinal()
 ```
 
-### 密封类     
 
-Kotlin除了可以利用final来限制类的继承之外，还可以通过密封类的语法来限制一个类的继承，比如: 
+
+枚举可以让你创建受限制的一组值，但在某些情况下，你需要更多的灵活性。假设你希望能在应用程序中使用两种不同的消息类型：一种用于”成功“，另一种用于”失败“，并且你希望能够将邮件限制为这两种类型。
+
+如果你用枚举类对此进行建模，代码会如下:  
+
+```kotlin
+enum class MessageType(var msg: String) {
+    SUCCESS("Yay!"),
+    FAILURE("Boo!")
+}
+```
+
+但是使用这种方法存在两个问题： 
+
+- 每个值都是一个常量，并且仅作为单个实例存在。
+
+    例如，你无法只在特定情况下修改SUCCESS的msg属性--因为一旦更改，代码中其他SUCCESS出现的地方也会被相应更改。
+
+- 每个值必须有相同的属性和函数。
+
+    向FAILURE值中添加Exception属性十分有用，它可以帮助你检查哪里出错了。但是枚举类不允许你这么做。
+
+那么有其他的方法吗？ 密封类可以拯救你。
+
+### 密封类
+
+Kotlin除了可以利用final来限制类的继承之外，还可以通过密封类的语法来限制一个类的继承。密封类就像枚举类的加强版本。它允许你将类层次结构限制为一组特定的子类型，每个子类型都可以定义自己的属性和函数。与枚举类不同，你可以创建每种类型的多个实例。 你可以通过使用sealed前缀类名来创建密封类。例如，以下代码创建一个名为MessageType的密封类，其中包含名为MessageSuccess和MessageFailure的子类型。每个子类型都有一个名为msg的String属性，并且MessageFailure子类型中有一个额外的名为e的Exception属性：
+
+```kotlin
+sealed class MessageType
+// MessageSuccess和MessageFailure从MessageType继承而来，并且它们自己的类型是在自己的构造函数中定义的
+class MessageSuccess(var msg: String) : MessageType()
+class MessageFailure(var msg: String, var e: Exception) : MessageType()
+```
+
+由于MessageType是一个有限子类的密封类。你可以使用when来检查每个子类型，这样可以避免使用额外的else子句，如以下代码所示:  
+
+```kotlin
+fun main(args: Array<String>) {
+    val messageSuccess = MessageSuccess("Yay!")
+    val messageSuccess2 = MessageSuccess("It worked!")
+    val messageFailure = MessageFailure("Boo!", Exception("Gone wrong."))
+    
+    var myMessageType: MessageType = messageFailure
+    val myMessage = when(myMessageType) {
+        is MessageSuccess -> myMessageType.msg
+        is MessageFailure -> myMessageType.msg + myMessageType.e.message
+    }
+    println(myMessage)
+}
+```
+
+Kotlin通过sealed关键字来修饰一个类为密封类，若要继承则需要将子类定义在同一个文件中，其他文件中的类将无法继承他。但这种方式也有它的局限性。即它不能被初始化，因为它背后是基于一个抽象类实现的。
 
 ```kotlin
 sealed class Bird {
@@ -182,8 +233,7 @@ sealed class Bird {
 }
 ```
 
-Kotlin通过sealed关键字来修饰一个类为密封类，若要继承则需要将子类定义在同一个文件中，其他文件中的类将无法继承他。
-但这种方式也有它的局限性。即它不能被初始化，因为它背后是基于一个抽象类实现的，这一点可以从它转换后的Java代码看出:  
+这一点可以从它转换后的Java代码看出:  
 
 ```java
 public abstract class Bird {
diff --git "a/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md" "b/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
index 04243795..727998d8 100644
--- "a/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
+++ "b/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
@@ -13,6 +13,8 @@ Kotlin引入了协程（Coroutine）来支持更好的异步操作，利用它
 
 
 
+协程就像一个轻量级的线程在幕后，启动协程就像启动一个单独的执行线程。线程在其他语言中很常见，例如Java，协程和线程可以并行运行，并互相通信。然而，不同点在于使用协程比使用线程更加高效。在性能方面，启动一个线程并使其保持运行是非常昂贵的。处理器通常只能同时运行有限数量的线程，并且运行尽可能少的线程会更高效。而另一方面，协程默认运行在共享的线程池中，同一个线程可以运行多个协程。由于使用的线程较少，当你想要运行异步任务时，使用协程会更加高效。
+
 ## 使用
 
 如需在 Android 项目中使用协程，请将以下依赖项添加到应用的build.gradle文件中：
@@ -25,6 +27,8 @@ dependencies {
 
 ## 示例
 
+在代码中，我们使用GlobalScope.launch在后台运行一个新的协程。在幕后，它创建了一个新的线程使协程在其中运行，
+
 ```kotlin
 import kotlinx.coroutines.*
 
@@ -44,6 +48,21 @@ World!
 本质上，协程是轻量级的线程。它们在某些CoroutineScope上下文中与launch协程构建器一起启动。
 这里我们在ClobalScope中启动了一个新的协程，这意味着新协程的生命周期只受整个应用程序的生命周期限制。
 
+
+
+使用runBlocking在相同作用域内运行协程如果希望代码在相同线程、不同协程中运行，你可以使用runBlocking函数。runBlocking是一个高阶函数，它会阻塞当前线程，直到传入其中的代码运行完成。runBlocking函数定义了一个作用域，传入其中的代码继承该作用域。在本例中，我们可以使用该作用域在同一线程中运行不同的协程。
+
+
+
+delay函数暂停当前协程在这种情况下，更好的解决方案是使用协程的delay函数取而代之。该函数与Thread.sleep有相似的效果，除了它会暂停当前协程而不是当前线程。它将协程挂起指定的时长，这允许运行该线程中的其他代码。delay函数可用于以下两种情况：
+
+- 在协程中使用。
+- 在某个编译器知道将会暂停或挂起的函数中使用，在函数中调用可挂起的函数时（例如delay），该函数必须被标记为suspend。
+
+例如，以下代码将协程延迟1秒：
+
+
+
 ```kotlin
 import kotlinx.coroutines.*
 

From 79db2bf48778f9b04c4beed7405ce4a8b819e6cb Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 12 Apr 2021 14:39:23 +0800
Subject: [PATCH 053/213] add os notes

---
 ...MaterialDesign\344\275\277\347\224\250.md" | 281 +++++++++++++++++-
 .../Parcelable\345\217\212Serializable.md"    |   2 +
 ...73\347\273\237\347\256\200\344\273\213.md" |  96 +++++-
 ...13\344\270\216\347\272\277\347\250\213.md" |  37 ++-
 ...05\345\255\230\347\256\241\347\220\206.md" |  40 ++-
 5 files changed, 441 insertions(+), 15 deletions(-)

diff --git "a/AdavancedPart/MaterialDesign\344\275\277\347\224\250.md" "b/AdavancedPart/MaterialDesign\344\275\277\347\224\250.md"
index c6f3788d..549c18e9 100644
--- "a/AdavancedPart/MaterialDesign\344\275\277\347\224\250.md"
+++ "b/AdavancedPart/MaterialDesign\344\275\277\347\224\250.md"
@@ -26,8 +26,9 @@ Material Design Theme
 ---
 
 - 禁止Action Bar                  
-    可以通过使用`Material theme`来让应用使用`Material Design`。想要使用`ToolBar`需要先禁用`ActionBar`。
-    可以通过自定义`theme`继承`Theme.AppCompat.Light.NoActionBar`或者在`theme`中通过以下配置来进行。
+    ToolBar相当于是ActionBar的替代版，因此需要制定一个不带ActionBar的主题，
+    可以通过自定义`theme`继承`Theme.AppCompat.Light.NoActionBar`或者在`theme`中通过以下配置来进行禁用`ActionBar`。
+    
     ```xml
     <item name="windowActionBar">false</item>
     <item name="android:windowNoTitle">true</item>
@@ -59,8 +60,8 @@ Material Design Theme
     
     配置的这几种颜色分别如下图所示:    
     ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/material_color.png?raw=true)	       
-    里面没有`colorAccent`的颜色，这个颜色是设置`Checkbox`等控件选中时的颜色。
-
+里面没有`colorAccent`的颜色，唯独colorAccent这个属性比较难理解，它不是用来指定Checkbox`等某一个按钮的颜色，而是更多表达了一个强调的意思，比如一些控件的选中状态也会使用colorAccent的颜色。
+    
     在`values-v21`中的`style.xml`中同样自定义`AppTheme`主题: 
     ```xml
     <style name="AppTheme" parent="AppTheme.Base">
@@ -166,7 +167,11 @@ Material Design Theme
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/ToolBar_content.jpg?raw=true)	              
 
 我们可以通过对应的方法来修改他们的属性:                 
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/toolbarCode.png?raw=true)	           
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/toolbarCode.png?raw=true)
+
+ToolBar最左侧的这个按钮就叫做HomeAsUp按钮，它默认的图标是一个返回的箭头，含义是返回上一个活动，可以通过setDisplayHomeAsUpEnabled来让导航按钮显示出来。 可以在onOptionsItemSelected()方法中对HomeAsUp安阿牛的点击事件进行处理，HomeAsUp按钮的id永远都是android.R.id.home。
+
+​	           
 
 对于`ToolBar`中的`Menu`部分我们可以通过一下方法来设置:     
 ```java
@@ -540,6 +545,272 @@ public class DrawerFragment extends Fragment {
 
 [Demo地址](https://github.com/CharonChui/MaterialLibrary)
 
+### NavigationView
+
+NavigationView包含两个部分：menu和headerLayout。menu是用来在NavigationView中显示具体的菜单项的，headerLayout则是用来在NavigationView中显示头部布局的。
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/navigator_view.png?raw=true)        
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<android.support.v4.widget.DrawerLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:id="@+id/drawer_layout"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
+
+    <RelativeLayout
+        android:layout_width="match_parent"
+        android:layout_height="match_parent">
+
+        <android.support.v7.widget.Toolbar
+            android:id="@+id/toolbar"
+            android:layout_width="match_parent"
+            android:layout_height="?attr/actionBarSize"
+            android:background="@color/colorPrimary" />
+
+    </RelativeLayout>
+
+    <android.support.design.widget.NavigationView
+        android:id="@+id/navigation_view"
+        android:layout_width="wrap_content"
+        android:layout_height="match_parent"
+        android:layout_gravity="start"
+        app:headerLayout="@layout/drawer_header"
+        app:menu="@menu/drawer_view" />
+</android.support.v4.widget.DrawerLayout>
+```
+
+
+
+drawer_header.xml 如下
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content">
+
+    <ImageView
+        android:scaleType="fitXY"
+        android:src="@drawable/image"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content" />
+
+    <TextView
+        android:textStyle="bold"
+        android:textColor="@android:color/white"
+        android:textSize="20sp"
+        android:text="Header View"
+        android:layout_marginTop="50dp"
+        android:layout_marginLeft="25dp"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content" />
+
+</RelativeLayout>
+```
+
+
+
+drawer_view.xml 如下： 
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<menu xmlns:android="http://schemas.android.com/apk/res/android">
+    <group android:checkableBehavior="single">
+
+        <item
+            android:id="@+id/menu_home"
+            android:icon="@drawable/ic_home"
+            android:title="Home" />
+
+        <item
+            android:id="@+id/menu_settings"
+            android:icon="@drawable/ic_settings"
+            android:title="Settings" />
+
+        <item android:title="Other">
+            <menu>
+                <item
+                    android:id="@+id/menu_share"
+                    android:icon="@drawable/ic_share"
+                    android:title="Share" />
+                <item
+                    android:id="@+id/menu_about"
+                    android:icon="@drawable/ic_info_outline"
+                    android:title="About" />
+            </menu>
+        </item>
+    </group>
+</menu>
+```
+
+
+
+我们给 Header 和 Menu 添加点击事件： 
+
+```java
+final NavigationView navigationView = (NavigationView) findViewById(R.id.navigation_view);
+        navigationView.getHeaderView(0).setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                drawerLayout.closeDrawer(navigationView);
+                Toast.makeText(MainActivity.this, "Header View is clicked!", Toast.LENGTH_SHORT).show();
+            }
+        });
+        navigationView.setNavigationItemSelectedListener(new NavigationView.OnNavigationItemSelectedListener() {
+            @Override
+            public boolean onNavigationItemSelected(@NonNull MenuItem item) {
+                switch (item.getItemId()) {
+                    case R.id.menu_home:
+                        Toast.makeText(MainActivity.this, "Home is clicked!", Toast.LENGTH_SHORT).show();
+                        break;
+                    case R.id.menu_settings:
+                        Toast.makeText(MainActivity.this, "Settings is clicked!", Toast.LENGTH_SHORT).show();
+                        break;
+                    case R.id.menu_share:
+                        Toast.makeText(MainActivity.this, "Share is clicked!", Toast.LENGTH_SHORT).show();
+                        break;
+                    case R.id.menu_about:
+                        Toast.makeText(MainActivity.this, "About is clicked!", Toast.LENGTH_SHORT).show();
+                        break;
+                }
+                drawerLayout.closeDrawer(navigationView);
+                return false;
+            }
+        });
+```
+
+
+
+### CoordinatorLayout
+
+**一、CoordinatorLayout 的作用**
+
+从名字可以看出，这个ViewGroup是用来协调它的子View的，CoordinatorLayout 作为一个 **“super-powered FrameLayout”**，主要有以下两个作用：
+
+1. 作为顶层布局；
+2. 作为协调子 View 之间交互的容器。
+
+CoordinatorLayout也是在`com.android.support.design`包中的组件。 
+
+#### CoordinatorLayout与FloadingActionButton
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout     
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/contentView"
+    android:orientation="vertical"     
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
+    <android.support.design.widget.FloatingActionButton
+        android:id="@+id/fab"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_alignParentBottom="true"
+        android:layout_alignParentRight="true"
+        android:onClick="onClick"
+        android:layout_marginRight="10dp"
+        android:layout_marginBottom="10dp"/>
+</RelativeLayout>
+```
+
+
+
+```java
+public void onClick(View v) {
+    switch (v.getId()) {
+        case R.id.fab:
+            Snackbar.make(findViewById(R.id.contentView), "Snackbar", Snackbar.LENGTH_SHORT).show();
+            break;
+    }
+}
+```
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/smacker_floatingbutton.webp?raw=true)        
+
+可以看到FloatingActionButton会被SmackBar遮挡，为了解决遮挡的问题，就需要使用到CoordinatorLayout。CoordinatorLayout可以说是一个加强版的FrameLayout，这个布局也是由Design Support库提供的。它在普通情况下的作用和FrameLayout基本一致，不过既然是Design Support库中提供的布局，那么就必然有一些Material Design的魔力了。
+事实上，CoordinatorLayout可以监听其所有子控件的各种事件，然后自动帮助我们做出最为合理的响应。举个简单的例子，刚才弹出的Snackbar提示将悬浮按钮遮挡住了，而如果我们能让CoordinatorLayout监听到Snackbar的弹出事件，那么它会自动将内部的FloatingActionButton向上偏移，从而确保不会被Snackbar遮挡到。
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<android.support.design.widget.CoordinatorLayout 
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:id="@+id/contentView"
+    android:orientation="vertical" 
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
+    <LinearLayout
+        android:id="@+id/anchorView"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:orientation="vertical"/>
+    <android.support.design.widget.FloatingActionButton
+        android:id="@+id/fab"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        app:layout_anchor="@id/anchorView"
+        app:layout_anchorGravity="bottom|right"
+        android:onClick="onClick"
+        android:layout_marginRight="10dp"
+        android:layout_marginBottom="10dp"/>
+</android.support.design.widget.CoordinatorLayout>
+```
+
+
+
+悬浮按钮自动向上偏移了Snackbar的同等高度，从而确保不会被遮挡住，当Snackbar消失的时候，悬浮按钮会自动向下偏移回到原来位置。
+另外悬浮按钮的向上和向下偏移也是伴随着动画效果的，且和Snackbar完全同步，整体效果看上去特别赏心悦目。
+
+
+
+或者我们也可以不把不过FloatingActionButton放到布局中，只是make()方法时传入的view是在布局中即可，我们回过头来再思考一下，刚才说的是CoordinatorLayout可以监听其所有子控件的各种事件，但是Snackbar好像并不是CoordinatorLayout的子控件吧，为什么它却可以被监听到呢？
+
+其实道理很简单，还记得我们在Snackbar的make()方法中传入的第一个参数吗？这个参数就是用来指定Snackbar是基于哪个View来触发的，刚才我们传入的是FloatingActionButton本身，而FloatingActionButton是CoordinatorLayout中的子控件，因此这个事件就理所应当能被监听到了。你可以自己再做个试验，如果给Snackbar的make()方法传入一个DrawerLayout，那么Snackbar就会再次遮挡住悬浮按钮，因为DrawerLayout不是CoordinatorLayout的子控件，CoordinatorLayout也就无法监听到Snackbar的弹出和隐藏事件了。
+
+
+
+#### CollapsingToolbarLayout
+
+可折叠式标题栏，CollapsingToolbarLayout是一个作用于Toolbar基础之上的布局，它也是由Design Support库提供的。CollapsingToolbarLayout可以让Toolbar的效果变得更加丰富，不仅仅是展示一个标题栏，而是能够实现非常华丽的效果。
+
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/CollapsingToolbarLayout.gif?raw=true)        
+
+
+
+可以看到，我们在CollapsingToolbarLayout中定义了一个ImageView和一个Toolbar，也就意味着，这个高级版的标题栏将是由普通的标题栏加上图片组合而成的。这里定义的大多数属性我们都是见过的，就不再解释了，只有一个app:layout_collapseMode比较陌生。它用于指定当前控件在CollapsingToolbarLayout折叠过程中的折叠模式，其中Toolbar指定成pin，表示在折叠的过程中位置始终保持不变，ImageView指定成parallax，表示会在折叠的过程中产生一定的错位偏移，这种模式的视觉效果会非常好。
+
+### NestedScrollView
+
+NestedScrollView 即 支持嵌套滑动的ScrollView。
+
+因此，我们可以简单的把NestedScrollView类比为ScrollView，其作用就是作为控件父布局，从而具备（嵌套）滑动功能。
+
+NestedScrollView与ScrollView的区别就在于NestedScrollView支持 *嵌套滑动*，无论是作为父控件还是子控件，嵌套滑动都支持，且默认开启。
+
+因此，在一些需要支持嵌套滑动的情景中，比如一个ScrollView内部包裹一个RecyclerView，那么就会产生滑动冲突，这个问题就需要你自己去解决。而如果使用NestedScrollView包裹RecyclerView，嵌套滑动天然支持，你无需做什么就可以实现前面想要实现的功能了。
+
+我们通常为RecyclerView增加一个Header和Footer的方法是通过定义不同的viewType来区分的，而如果使用NestedScrollView，我们完全可以把RecyclerView当成一个单独的控件，然后在其上面增加一个控件作为Header，在其下面增加一个控件作为Footer。
+
+虽然NestedScrollView内嵌RecyclerView和其他控件可以实现Header和Footer，但还是不推荐上面这种做法（建议还是直接使用RecyclerView自己添加Header和Footer），因为虽然NestedScrollView支持嵌套滑动，但是在实际应用中，嵌套滑动可能会带来其他的一些奇奇怪怪的副作用，Google 也推荐我们能不使用嵌套滑动就尽量不要使用。
+
+
+
+作者：Whyn
+链接：https://www.jianshu.com/p/f55abc60a879
+来源：简书
+著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
+
+
+
+
+
+
+
 
 Ripple效果
 ---
diff --git "a/BasicKnowledge/Parcelable\345\217\212Serializable.md" "b/BasicKnowledge/Parcelable\345\217\212Serializable.md"
index 1a77bc21..73a927a1 100644
--- "a/BasicKnowledge/Parcelable\345\217\212Serializable.md"
+++ "b/BasicKnowledge/Parcelable\345\217\212Serializable.md"
@@ -9,6 +9,8 @@ Parcelable及Serializable
 如`activity`间传输数据，而`Serializable`可将数据持久化方便保存，所以在需要保存或网络传输数据时选择
 `Serializable`，因为`android`不同版本`Parcelable`可能不同，所以不推荐使用`Parcelable`进行数据持久化。
 
+Parcelable不同于将对象进行序列化，Parcelable方式的实现原理是将一个完整的对象进行分解，而分解后的每一部分都是Intent所支持的数据类型，这样也就实现传递对象的功能了。
+
 区别:    
 - Parcelable is faster than serializable interface
 - Parcelable interface takes more time for implemetation compared to serializable interface
diff --git "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md" "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
index d7e13d3a..e3d5aeb9 100644
--- "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
+++ "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
@@ -19,6 +19,14 @@
 
 
 
+操作系统这个术语听上去稀松平常，并不给人任何兴奋的感觉，甚至有点俗气。原因在于中文的“操作”这个词：提到操作员，通常让人想起操作车床、磨床和起重机的穿着油腻工作服的工人，这自然让人兴奋不起来。将英文的Operating翻译为中文的“操作”，是因为翻译的人没有理解英文Operating Systems（OS，操作系统）这个名字所蕴涵的精髓。那么英文的Operating Systems意味着什么呢？各位见过手术过程吗？在手术室里，主刀大夫称为Operating Surgeon。在整个手术过程中，主刀大夫具有至高无上的权威：他说要打麻药，麻醉师便要赶紧打麻药；他说需要手术钳，助理大夫就赶忙递给他手术钳；他说需要止血，护士就要忙不迭地拿止血药棉来止血。整个手术最关键的部分，切开皮肤、拿掉器官、安装移植器官等均由主刀大夫完成。当然，主刀大夫有时候也会将某些任务，如缝合创口，交给助理大夫或护士来做，但整个手术的过程皆由其主控。一句话，Operating Surgeon就是掌控整个手术过程、具有精湛技术和敏锐判断力的医师。
+
+引申至非医学领域，Operating Person意思是操刀手，就是掌控事情的人。再将Person这个词换成System，则Operating Systems指的就是掌控局势的一种系统。也就是说计算机里面的一切事情均由Operating Systems来掌控。那么，我们现在面临两个问题：第一个问题是，操作系统到底是什么东西？第二个问题是，操作系统到底操控什么事情？我们先回答第一个问题。既然操作系统是掌控计算机局势的一个系统，自然很重要。但这个说法并不能帮助读者理解操作系统，也无法形成有形的概念。如果我们换个说法：操作系统是介于计算机和应用软件之间的一个软件系统，则概念就具体多了。从这个定义出发，我们知道操作系统的上面和下面都有别的对象存在：下面是硬件平台，上面是应用软件，现在回答第二个问题。我们知道操作系统代表的是掌控事情的系统，掌控什么事情呢？当然是计算机上或计算机里发生的一切事情。最原始的计算机并没有操作系统，而是直接由人来掌控事情，即所谓的单一控制终端、单一操作员模式。但是随着计算机复杂性的增长，人已经不能胜任直接掌控计算机了。于是我们编写出操作系统这个“软件”来掌控计算机，将人类从日益复杂的掌控任务中解脱出来。这个掌控有着多层深远的意义。首先，由于计算机的功能和复杂性不断发生变化（趋向更加复杂），操作系统所掌控的事情也就越来越多，越来越复杂。同时，操作系统本身能够使用的资源也不断增多（如内存容量）。这是早期驱动操作系统不断改善的根本原因。其次，既然操作系统是专门掌控计算机的，那么计算机上发生的所有事情自然需要操作系统的知晓和许可，未经操作系统同意的任何事情均视为非法的，也就是病毒和入侵攻击所试图运作的事情。作为操作系统的设计人员，我们当然要确保计算机不发生任何我们不知情或不同意的事情。但是人的能力是有限的，人的思维也是有缺陷的，我们设计出的系统自然不会十全十美，也会有缺陷，这就给了攻击者可乘之机。操作系统设计人员和攻击者之间的博弈是当前驱动操作系统改善的一个重要动力。再次，掌控事情的水平有高低之分，有效率不同之分。就像手术大夫之间也有水平高低之分。为了更好地掌控事情，同时也为了更好地满足人类永不知足的各种越来越苛刻的要求，操作系统自然需要不断改善。这种改善在过去、现在和将来都会继续下去的。最后，我们可以给操作系统下定义了：操作系统是一个软件系统；操作系统使计算机变得好用（将人类从繁琐、复杂的对机器掌控的任务中解脱）；操作系统使计算机运作变得有序（操作系统掌控计算机上所有的事情）。总结起来就是：操作系统是掌控计算机上所有事情的软件系统。
+
+
+
+
+
 ### 以现代标准而言，一个标准PC的操作系统应该提供以下功能
 
 
@@ -77,10 +85,20 @@
 计算机中的设备分为输入和输出设备。以 CPU 为中心，凡是向 CPU 输送数据的设备统称为输入设备，例如鼠标、键盘、摄像头等；同样以 CPU 为中心，凡是从 CPU 获取数据的设备统称为输出设备，如显示器等。有些设备既是输入设备也是输入设备，比如网卡等。 
 一个比较常见的场景是当我们将 U盘插进电脑的 USB 插孔时，电脑能实时识别出 U 盘设备，那计算机为啥能实时识别出这些设备呢？之后会有章节讨论一下这个话题。
 
+## 操作系统的基本特征
+
+并发和共享是操作系统的两个最基本的特征，它们又互为存在条件。一方面，资源共享是以程序（进程）的并发执行为条件的，若系统部允许程序并发执行，自然不存在资源共享问题。另一方面，若系统部能对资源共享实施有效管理，也必将影响程序的并发执行，甚至根本无法并发执行。
+
 
 
 ## 计算机的组成
 
+### 计算机硬件
+
+从概念上讲，计算机的结构非常简单：首先布置一根总线，然后将各种硬件设备挂在总线上。所有的这些设备都有一个控制设备，外部设备都由这些控制器与CPU通信。而所有设备之间的通信均需通过总线： 
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/computer_hardware.jpg?raw=true)        
+
 
 
 计算机由处理器、存储器和输入/输出部件组成，每类部件都有一个或多个模块。这些部件以某种方式互连，以实现计算机执行程序的主要功能。因此，计算机有4个主要的结构化部件: 
@@ -184,6 +202,34 @@ Android平台的基础是Linux内核，比如ART虚拟机最终调用底层Linux
 
  
 
+## 虚拟化
+
+### 程序运行时会发生什么？
+
+首先，当然得进行编程，而编程需要计算机程序设计语言作为基础。对于绝大多数编写程序的人来说，使用的编程语言称为高级程序设计语言，如C、C++、Java等。但由于计算机并不认识高级语言编写的程序，编好的程序需要进行编译变成计算机能够识别的机器语言程序，而这需要编译器和汇编器的帮助。其次，机器语言程序需要加载到内存，形成一个运动中的程序，即进程，而这需要操作系统的帮助。进程需要在计算机芯片CPU上执行才算是真正在执行，而将进程调度到CPU上运行也由操作系统完成。最后，在CPU上执行的机器语言指令需要变成能够在一个个时钟脉冲里执行的基本操作，这需要指令集结构和计算机硬件的支持，而整个程序的执行过程还需要操作系统提供的服务和程序语言提供的执行环境（runtime environment）。这样，一个从程序到微指令执行的过程就完成了。
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/app_process.jpg?raw=true)        
+
+简单的来说一个正在运行的程序会做一件非常简单的事情：执行指令。处理器从内存中获取（fetch）一条指令，对其进行解码（decode）（弄清楚这是哪条指令），然后执行（execute）它（做它应该做的事情，如两个数相加、访问内存、检查条件、跳转到函数等）。完成这条指令后，处理器继续执行下一条指令，依此类推，直到程序最终完成。
+
+这样，我们就描述了冯·诺依曼（Von Neumann）计算模型的基本概念。听起来很简单，对吧？但在这门课中，我们将了解到在一个程序运行的同时，还有很多其他疯狂的事情也在同步进行——主要是为了让系统易于使用。
+
+实际上，有一类软件负责让程序运行变得容易（甚至允许你同时运行多个程序），允许程序共享内存，让程序能够与设备交互，以及其他类似的有趣的工作。这些软件称为操作系统（Operating System，OS），因为它们负责确保系统既易于使用又正确高效地运行。
+
+要做到这一点，操作系统主要利用一种通用的技术，我们称之为虚拟化（virtualization）。也就是说，操作系统将物理（physical）资源（如处理器、内存或磁盘）转换为更通用、更强大且更易于使用的虚拟形式。因此，我们有时将操作系统称为虚拟机（virtual machine）。
+
+
+
+### 什么是虚拟化？
+
+假设我们有一个桃子，我们称之为物理（physical）的桃子。但有很多想吃这个桃子的人，我们希望向每个想吃的人提供一个属于他的桃子，这样才能皆大欢喜。我们把给每个人的桃子称为虚拟（virtual）桃子。我们通过某种方式，从这个物理桃子创造出许多虚拟桃子。重要的是，在这种假象中，每个人看起来都有一个物理桃子，但实际上不是。每个人都不知道他在和别人一起分享这个桃子，但是如果我和别人分享同一个桃子我一定会发现这个问题。但是只有吃的人多才有这样的问题。多数时间他们都在打盹或者做其他事情，所以，你可以在他们打盹的时候把他手中的桃子拿过来分给其他人，这样我们就创造了有许多虚拟桃子的假象，每个人有一个桃子。
+
+以最基本的计算机资源CPU为例，假设一个计算机只有一个CPU(尽管现在计算机一班拥有2个、4个或更多CPU)，虚拟化要做的就是将这个CPU虚拟成多个虚拟CPU并分给每一个进程使用，因此，每个应用都以为自己在独占CPU，但实际上只有一个CPU。这样操作系统就创造了美丽的假象--它虚拟化了CPU。
+
+操作系统通过进程抽象让每一个用户感觉有一台自己独享的CPU；通过虚拟内存抽象，让用户感觉物理内存空间具有无限扩张性，这就是把少变多。当然，操作系统的把少变多不是无中生有，变多也不是无限多，只是针对磁盘容量的大小。
+
+
+
 ## CPU(Central Processing Unit)
 
 CPU(中央处理器)是计算机的大脑，它主要和内存进行交互，从内存中提取指令并执行它。它是一块超大规模的集成电路(Integrated Circuit)，是信息处理、程序运行的最终执行单元。其功能主要是解释计算机指令以及处理计算机软件中的数据。由于访问内存获取执行或数据要比执行指令花费的时间长，因此所有的 CPU 内部都会包含一些寄存器来保存关键变量和临时结果。因此，在指令集中通常会有一些指令用于把关键字从内存中加载到寄存器中，以及把关键字从寄存器存入到内存中。从功能方面来看，CPU的内部主要由寄存器，控制器，运算器构成，各部分之间由电流信号相互连通。其中运算器负责算术运算和逻辑运算，控制器负责计算指令的解析，产生各种控制指令，寄存器组用来临时存放参加运算的数据和计算的中间结果。CPU计算结果最终需要写到内存中，内存的存取速度远低于CPU，为提升数据交换速率，CPU内部一般还集成了高速缓存（CACHE）,其中缓存分为一级缓存和二级缓存，一级缓存和CPU速率相当，二级缓存次之。
@@ -224,7 +270,7 @@ CPU 的内部由**寄存器、控制器、运算器和时钟**四部分组成，
 
 
 
-***计算机执行的原理是: 取指执行***
+### 计算机执行的原理是: 取指执行
 
 处理器执行的程序是由一组保存在存储器中的指令组成的。最简单的指令处理包括两步: 处理器从存储器中一次读(取)一条指令，然后执行每条指令。程序执行是由不断重复的取指令和执行指令的过程组成的。指令执行可能涉及很多操作，具体取决于指令本身。 
 
@@ -243,6 +289,8 @@ CPU 的内部由**寄存器、控制器、运算器和时钟**四部分组成，
 
 几乎所有的冯·诺伊曼型计算机的CPU，其工作都可以分为5个阶段：**取指令、指令译码、执行指令、访存取数、结果写回**。
 
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/cpu_process.jpg?raw=true)        
+
 - 取指令阶段是将内存中的指令读取到CPU中寄存器的过程，程序寄存器用于存储下一条指令所在的地址
 - 指令译码阶段，在取指令完成后，立马进入指令译码阶段，在指令译码阶段，指令译码器按照预定的指令格式，对取回的指令进行拆分和解释，识别区分出不同的指令类别以及各种获取操作数的方法。
 - 执行指令阶段，译码完成后，就需要执行这一条指令了，此阶段的任务是完成指令所规定的各种操作，具体实现指令的功能。
@@ -270,13 +318,32 @@ CPU 的内部由**寄存器、控制器、运算器和时钟**四部分组成，
 5. 接着读下一个指令，现在PC是302了，从302的存储单元中读取下一个指令为2941，PC同时加1.前四位操作码对应的是2，转换成二进制也就是0010 = 将AC存储到内存。后十二位对应的地址是941。所以这条指令的意思就是将AC中的内容存储到地址为941的存储单元中。
 6. 执行指令，将AC中的内容存储到地址为941的存储单元中。现在941存储单元的内容变成了5.
 
+为了进一步提高计算机的效率，在流水线的基础上，人们又发明了多流水线、超标量计算和超长指令字等多指令发射机制。这些机制的发明在提升计算机效率（主要是吞吐量）的同时，也极大地增加计算机结构的复杂度，并对操作系统和编译器提出了更高的要求。下图描述的是一个超标量发射的体系结构。这个结构有两队指令读取和译码单元，以及三个执行单元。通过一个指令保持缓冲区，就可以实现多路复用（Multiplex）和反多路复用（de-Multiplex），从而提高系统每个功能单元的利用率和整个系统的吞吐量。
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/cpu_process_multi.jpg?raw=true)        
+
+
 
+## 操作系统的两种CPU状态
 
-#### 操作系统的两种CPU状态
+就像世界上的人并不平等一样，并不是所有的程序都是平等的。世界上有的人占有资源多，有的人占有资源少，有的人来了，别人得让出资源，有的人则专门为别人让出资源。程序也是这样的，有的程序可以访问计算机的任何资源，有的程序则只能访问少量受限资源。操作系统作为计算机的管理者，自然不能和被管理者享受一样的待遇。它应该享有更多的方便或权限。为了区分不同的程序的不同权限，人们发明了内核态和用户态的概念。
 
 - 内核态(Kernel Mode):运行操作系统程序
+
+    内核态就是拥有资源多的状态，或者说访问资源多的状态，称为特权态。
+
 - 用户态(User Mode):运行用户程序
 
+    用户态就是非特权态，在此种状态下访问的资源将受到限制。
+
+如果一个程序运行在特权态，则该程序就可以访问计算机的任何资源，即它的资源访问不受限制。如果一个程序运行在用户态，则其资源需求将受到各种限制。很显然，内核态和用户态各有优势：运行在内核态的程序可以访问的资源多，但可靠性、安全性要求高，维护管理都较复杂；用户态程序程序访问的资源有限，但可靠性、安全性要求低，自然编写维护起来比较简单。一个程序到底应该运行在内核态还是用户态则取决于其对资源和效率的需求。一般来说，如果一个程序能够运行于用户态，就应该让它运行在用户态。只在迫不得已的情况下，才让程序运行于内核态。凡是牵扯到计算机本体根本运行的事情都应该在内核态下执行，只与用户数据和应用相关的东西则放在用户态执行。另外，对时序要求特别高的操作，也应该在内核态完成。
+
+
+
+#### 态势的识别
+
+那么计算机是如何知道现在正在运转的程序是内核态程序呢？而正确做出内核态或用户态的判断对系统的正确运行至关重要。显然做出这种判断需要某种标志。这个标志就是处理器的一个状态位。这个状态位是CPU状态字里面的一个字位。也就是说，所谓的用户态、内核态实际上是处理器的一种状态，而不是程序的状态。我们通过设置该状态字，可以将CPU设置为内核态、用户态或者其他的子态（有的CPU有更多种子态）。一个程序运行时，CPU是什么态，这个程序就运行在什么态。
+
 操作系统只需要这两种状态，同时这两种状态由对应的两种指令: 
 
 - 特权(privilege)指令:只能由操作系统使用、用户程序不能使用的指令
@@ -290,6 +357,16 @@ CPU 的内部由**寄存器、控制器、运算器和时钟**四部分组成，
 
 ### 中断/异常
 
+
+
+#### 中断的概念
+
+所谓中断，是指CPU对系统中或系统外发生的异步事件的相应。
+
+异步事件是指无一定时序关系的随机发生的时间，如外围设备完成数据传输，实时控制设备出现异常情况等。“中断”这个名称来源于：当这些异步事件发生后，打断了CPU对当前程序的执行，而转去处理该异步事件（执行该时间的中断处理程序）。直到处理完成之后，再转回原程序的中断点继续执行。
+
+
+
 可以说操作系统是由“中断驱动”或者“时间驱动”的。中断/异常是CPU对系统发生的某个事件作出的一种反应。
 
 所有计算机都提供了允许其他模块（I/O、存储器)中断处理器正常处理过程的机制。中断最初是用于提高处理器效率的一种手段。例如，多数I/O设备都要远慢于处理器，处理器必须暂停并保持空闲，直到打印机完成工作。暂停的时间长度可能相当于成百上千个不涉及存储器的指令周期，显然，这对于处理器的使用来说是非常浪费的。这种只有一个单独程序的情况，称为单道程序设计。在单道程序设计中处理器话费一定的运行时间进行计算，直到遇到一个I/O指令，这时它必须等到该I/O指令结束后才能继续执行。这种问题是可以避免的，就是存储器可以保存多个程序，在一个程序等待时通过切换去执行其他的程序，这种处理称为多道程序设计或多任务处理。它是现代操作系统的主要方案。多道程序设计的目的是为了让处理器和I/O设备（包括存储设备）同时保持忙状态，以实现最大的效率。
@@ -318,6 +395,8 @@ CPU 的内部由**寄存器、控制器、运算器和时钟**四部分组成，
 
 
 
+中断的出现解决了主机和外围设备并行工作的问题，消除了因外围设备的慢速而使得主机等待的现象，提高了可靠性，为多机操作和实时处理提供了硬件基础。引起中断的那些事件称为中断事件或中断源，中断源向CPU发出的请求信号称为中断请求，而处理中断事件的那段程序称为中断处理程序。发生中断时正在执行的程序的暂停点称为中断断点，CPU暂停当前程序转而处理中断的过程称为中断响应，中断处理结束之后恢复原来程序的执行称为中断返回。
+
 
 
 ### 中断/异常机制工作原理
@@ -367,6 +446,17 @@ CPU 的内部由**寄存器、控制器、运算器和时钟**四部分组成，
 
 一个进程在执行过程中可能被中断数千次，但关键每次中断后，被中断的进程都返回到与中断发生前完全相同的状态。
 
+### 中断系统
+
+中断系统包括量大组成部分：
+
+- 中断系统的硬件中断装置
+- 软件中断处理程序
+
+中断装置负责捕获中断源发出的中断请求，并以一定的方式响应中断源，然后将CPU的控制权移交给特定的中断处理程序。中断处理程序负责辨别中断类型，并根据请求作出相应的操作。中断装置提供了中断系统的基本框架，是中断系统的机制部分。中断处理程序是利用中断机制对处理能力的扩展和对多种处理需求的适应，属于中断系统的策略部分。
+
+
+
 
 
 ## 存储器
@@ -407,7 +497,7 @@ CPU 的内部由**寄存器、控制器、运算器和时钟**四部分组成，
 
 ## 内存
 
-
+内存就是一个字节数组。要读取(read)内存，必须制定一个地址(address)，才能访问存储在那里的数据。要写入(write)或更新(update)内存，还必须制定要写入给定地址的数据。
 
 内存包括主存(内存条,基于DRAM(动态RAM))与高速缓存(Cache,基于SRAM(静态RAM，静态RAM速度很快但是成本很高，所以用于在CPU内部充当缓冲))两部分。可能是由于Cache相较内存条容量很小，毕竟内存容量只计内存条大小，加上重要性也不及内存条，一般人或许不知道Cache,所以就忽略了高速缓存Cache，直接将主存--内存条等同了内存吧。计算器内存条采用的是DRAM(动态随机存储器)，即计算机的主存。通常所说的内存容量即指内存条DRAM的大小。
 
diff --git "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md" "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
index 7cf76645..1d462423 100644
--- "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
+++ "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
@@ -6,6 +6,16 @@
 
 
 
+事实表明，人们常常希望同时运行多个程序。比如：在使用计算机或者笔记本的时候，我们会同时运行浏览器、邮件、游戏、音乐播放器，等等。实际上，一个正常的系统可能会有上百个进程同时在运行。如果能实现这样的系统，人们就不需要考虑这个时候哪一个CPU是可用的，使用起来非常简单。因此我们的挑战是:如何提供有许多CPU的假象？(虽然只有少量的物理CPU可用，但是操作系统如何提供几乎有无数个CPU可用的假象？)
+
+操作系统通过虚拟化（virtualizing）CPU来提供这种假象。通过让一个进程只运行一个时间片，然后切换到其他进程，操作系统提供了存在多个虚拟CPU的假象。这就是时分共享（time sharing）CPU技术，允许用户如愿运行多个并发进程。潜在的开销就是性能损失，因为如果CPU必须共享，每个进程的运行就会慢一点。要实现CPU的虚拟化，要实现得好，操作系统就需要一些低级机制以及一些高级智能。我们将低级机制称为机制（mechanism）。机制是一些低级方法或协议，实现了所需的功能。例如，我们稍后将学习如何实现上下文切换（context switch），它让操作系统能够停止运行一个程序，并开始在给定的CPU上运行另一个程序。所有现代操作系统都采用了这种分时机制。
+
+时分共享（time sharing）是操作系统共享资源所使用的最基本的技术之一。通过允许资源由一个实体使用一小段时间，然后由另一个实体使用一小段时间，如此下去，所谓的资源（例如，CPU或网络链接）可以被许多人共享。时分共享的自然对应技术是空分共享，资源在空间上被划分给希望使用它的人。例如，磁盘空间自然是一个空分共享资源，因为一旦将块分配给文件，在用户删除文件之前，不可能将它分配给其他文件。
+
+为了虚拟化CPU，操作系统需要以某种方式让许多任务共享物理CPU，让它们看起来像是同时运行。基本思想很简单：运行一个进程一段时间，然后运行另一个进程，如此轮换。通过以这种方式时分共享（time sharing）CPU，就实现了虚拟化。然而，在构建这样的虚拟化机制时存在一些挑战。第一个是性能：如何在不增加系统开销的情况下实现虚拟化？第二个是控制权：如何有效地运行进程，同时保留对CPU的控制？控制权对于操作系统尤为重要，因为操作系统负责资源管理。如果没有控制权，一个进程可以简单地无限制运行并接管机器，或访问没有权限的信息。因此，在保持控制权的同时获得高性能，这是构建操作系统的主要挑战之一。
+
+
+
 ## 进程概念
 
 狭义定义：进程是正在运行的程序的实例（an instance of a computer program that is being executed）。
@@ -215,9 +225,7 @@
 
 - Shared Memory共享内存
 
-    多台服务器访问同一个存储设备的同一分区。
-
-    两个进程之间还可以通过共享内存进行进程间通信，其中两个或者多个进程可以访问公共内存空间。两个进程的共享工作是通过共享内存完成的，一个进程所作的修改可以对另一个进程可见(很像线程间的通信)。
+    共享内存可以看作对一段内存区域的映射，它将一段内存区域映射到多个进程的地址空间，从而使得这些进程能够共享这一内存区域。共享内存是进程通信中最快的一种方法，因为数据不需要在进程间复制，而可以直接映射到各个进程的地址空间中。在共享内存中要注意的一个问题是：当多个进程对共享内存区域进行访问时，要注意这些进程之间的同步问题。例如，如果server正在向共享内存区域中写数据，那么client进程就不能访问这些数据，直到server全部写完之后，client才可以访问。为了实现进程间的同步问题，通常使用前面介绍过的信号量来实现这一目标。一个共享内存段可以由一个进程创建，然后由任意共享这一内存段的进程对它进行读写。当进程间需要通信时，一个进程可以创建一个共享内存段，然后需要通信的各个进程就可以在信号量的控制下保持同步，在这里交换数据，完成通信。
 
 - Message Queue消息传递系统/消息队列
 
@@ -543,16 +551,33 @@ Android使用的进程有些不同。活动管理器是Android负责正在运行
 
 ## 线程
 
-多线程技术是指把执行一个应用程序的进程划分为可以同时运行的多个线程。
+#### 为什么要有线程呢？ 
+
+如果说，在操作系统中引入进程的目的是使多个程序并发执行以改善资源利用率及提高系统的吞吐量；那么，在操作系统中再引入线程，则是为了减少程序并发执行时所付出的时空开销，使操作系统具有更好的并发性。为了说明这一点，首先回顾进程的两个基本属性：一是进程是一个可拥有资源的独立单位；二是进程同时又是一个可以独立调度和分派的基本单位。正是由于进程具有这两个基本属性，才使之成为一个能独立运行的基本单位，从而也就构成了进程并发执行的基础。
 
-为什么要有线程呢？ 
 
-在传统的操作系统中，每个进程都有一个地址空间和一个控制线程。事实上，这是大部分进程的定义。不过，在许多情况下，经常存在同一地址空间中运行多个控制线程的情形，这些线程就像是分离的进程。
+
+简而言之，由于进程是一个资源拥有者，因而在进程的创建、撤销和切换中，系统必须为之付出较大的时空开销。也正因如此，在系统中所设置的进程数目不宜过多，进程切换的频率也不宜过高，但这也就限制了并发程度的进一步提高。
+如何能使多个程序更好地并发执行，同时又尽量减少系统的开销，这已成为近年来设计操作系统时所追求的重要目标。有不少操作系统的学者们考虑：可否将进程的上述两个属性分开，由操作系统分开进行处理？即对作为调度和分派的基本单位，不同时作为独立分配资源的单位，以使之轻装运行；而对拥有资源的基本单位，又不频繁地对之进行切换。正是在这种思想的指导下，产生了线程概念。在传统的操作系统中，每个进程都有一个地址空间和一个控制线程。事实上，这是大部分进程的定义。不过，在许多情况下，经常存在同一地址空间中运行多个控制线程的情形，这些线程就像是分离的进程。
 
 上面说到进程 = 资源 + 指令执行序列。那能不能将资源和指令执行分开，组合成一个资源 + 多个指令执行序列的方式？ 这种不切换资源，只切换执行指令的方式就是线程。线程保留了并发的优点，避免了进程切换的代价。
 
 
 
+#### 线程的定义
+
+在引入线程的操作系统中，线程是进程的一个实体，是被系统独立调度和分派的基本单位。线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源（如程序计数器、一组寄存器和栈），但它可与同属一个进程的其他线程共享进程所拥有的全部资源。一个线程可以创建和撤销另一个线程；同一进程中的多个线程之间可以并发执行。
+
+
+
+在传统的操作系统中，拥有资源的基本单位和独立调度、分派的基本单位都是进程。而在引入线程的操作系统中，则把线程作为调度和分派的基本单位，而把进程作为资源拥有的基本单位，使传统进程的两个属性分开，线程便能轻装运行，从而可显著地提高系统的并发程度。在同一进程中，线程的切换不会引起进程切换；在由一个进程中的线程切换到另一个进程中的线程时，将会引起进程切换。
+
+
+
+多线程技术是指把执行一个应用程序的进程划分为可以同时运行的多个线程。
+
+
+
 线程不像是进程那样具备较强的独立性。同一个进程中的所有线程都会有完全一样的地址空间，这意味着它们也共享同样的全局变量。由于每个线程都可以访问进程地址空间内每个内存地址，**「因此一个线程可以读取、写入甚至擦除另一个线程的堆栈」**。线程之间除了共享同一内存空间外，还具有如下不同的内容
 
 
diff --git "a/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md" "b/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
index 31ab0e09..69536170 100644
--- "a/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
+++ "b/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
@@ -161,6 +161,10 @@ Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自
 
 
 
+如果说分页存储器管理方式引入的目的是提高内存的利用率，那么分段存储器管理方式的引入便是为了方便用户的使用。引入分段存储器管理方式主要是为了满足用户方便编程、分段共享和分段保护等要求。
+
+分段存储管理方式要求每个程序的地址空间按照自身的逻辑关系划分成若干段，比如主程序段、子程序段、数据段、堆栈段等，每个段都有自己的名字。为了简单，通常可用一个段号来代替段名，每个段都从0开始独立编址，段内地址连续。段的长度由相应的逻辑信息组的长度决定，因而各段的长度不等。分配内存时，为每个段分配一连续的存储空间，段间地址空间可以不连续。
+
 
 
 分页和分段的两个特点: 
@@ -189,9 +193,11 @@ Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自
 
 
 
+## 虚拟内存
+
+每个进程访问自己的私有虚拟地址空间（virtual address space）（有时称为地址空间，address space），操作系统以某种方式映射到机器的物理内存上。一个正在运行的程序中的内存引用不会影响到其他进程（或操作系统本身）的地址空间。对于正在运行的程序，它完全拥有自己的物理内存。但实际情况是，物理内存是由操作系统管理的共享资源。
 
 
-## 虚拟内存
 
 面对越来越大的程序,常常产生程序>内存的问题,为解决这种问题,虚拟内存的概念得到普及.
 
@@ -294,6 +300,38 @@ Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自
 
 
 
+## 内存类型
+
+在运行一个C程序的时候，会分配两种类型的内存。第一种称为栈内存，它的申请和释放操作是编译器来隐式管理的，所以有时也称为自动（automatic）内存。
+
+C中申请栈内存很容易。比如，假设需要在func()函数中为一个整形变量x申请空间。为了声明这样的一块内存，只需要这样做：
+
+```c
+void func() {
+    int x: // declares an integer on the stack
+}
+```
+
+编译器完成剩下的事情，确保在你进入 func() 函数的时候，在栈上开辟空间。当你从该函数退出时，编译器释放内存。因此，如果你希望某些信息存在于函数调用之外，建议不要将它们放在栈上。
+
+就是这种对长期内存的需求，所以我们才需要第二种类型的内存，即所谓的堆（heap）内存，其中所有的申请和释放操作都由程序员显式地完成。毫无疑问，这是一项非常艰巨的任务！这确实导致了很多缺陷。但如果小心并加以注意，就会正确地使用这些接口，没有太多的麻烦。下面的例子展示了如何在堆上分配一个整数，得到指向它的指针：
+
+```c
+void func() {
+    int *x = (int *)malloc(sizeof(int));
+}
+```
+
+关于这一小段代码有两点说明。首先，你可能会注意到栈和堆的分配都发生在这一行：首先编译器看到指针的声明（int * x）时，知道为一个整型指针分配空间，随后，当程序调用malloc()时，它会在堆上请求整数的空间，函数返回这样一个整数的地址（成功时，失败时则返回NULL），然后将其存储在栈中以供程序使用。因为它的显式特性，以及它更富于变化的用法，堆内存对用户和系统提出了更大的挑战。
+
+#### 内存泄露
+
+忘记释放内存另一个常见错误称为内存泄露（memory leak），如果忘记释放内存，就会发生。在长时间运行的应用程序或系统（如操作系统本身）中，这是一个巨大的问题，因为缓慢泄露的内存会导致内存不足，此时需要重新启动。因此，一般来说，当你用完一段内存时，应该确保释放它。请注意，使用垃圾收集语言在这里没有什么帮助：如果你仍然拥有对某块内存的引用，那么垃圾收集器就不会释放它，因此即使在较现代的语言中，内存泄露仍然是一个问题。在某些情况下，不调用free()似乎是合理的。例如，你的程序运行时间很短，很快就会退出。在这种情况下，当进程死亡时，操作系统将清理其分配的所有页面，因此不会发生内存泄露。虽然这肯定“有效”（请参阅后面的补充），但这可能是一个坏习惯，所以请谨慎选择这样的策略。长远来看，作为程序员的目标之一是养成良好的习惯。其中一个习惯是理解如何管理内存，并在C这样的语言中，释放分配的内存块。即使你不这样做也可以逃脱惩罚，建议还是养成习惯，释放显式分配的每个字节。
+
+
+
+**补充：**为什么在你的进程退出时没有内存泄露当你编写一个短时间运行的程序时，可能会使用malloc()分配一些空间。程序运行并即将完成：是否需要在退出前调用几次free()？虽然不释放似乎不对，但在真正的意义上，没有任何内存会“丢失”。原因很简单：系统中实际存在两级内存管理。第一级是由操作系统执行的内存管理，操作系统在进程运行时将内存交给进程，并在进程退出（或以其他方式结束）时将其回收。第二级管理在每个进程中，例如在调用malloc()和free()时，在堆内管理。即使你没有调用free()（并因此泄露了堆中的内存），操作系统也会在程序结束运行时，收回进程的所有内存（包括用于代码、栈，以及相关堆的内存页）。无论地址空间中堆的状态如何，操作系统都会在进程终止时收回所有这些页面，从而确保即使没有释放内存，也不会丢失内存。因此，对于短时间运行的程序，泄露内存通常不会导致任何操作问题（尽管它可能被认为是不好的形式）。如果你编写一个长期运行的服务器（例如Web服务器或数据库管理系统，它永远不会退出），泄露内存就是很大的问题，最终会导致应用程序在内存不足时崩溃。当然，在某个程序内部泄露内存是一个更大的问题：操作系统本身。这再次向我们展示：编写内核代码的人，工作是辛苦的...
+
 
 
 ## Android内存管理

From 388bb17ce1ef58c359ca49c8d284dff71c3d13c8 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 12 Apr 2021 22:11:39 +0800
Subject: [PATCH 054/213] update os notes

---
 ...73\347\273\237\347\256\200\344\273\213.md" |   2 +-
 ...13\344\270\216\347\272\277\347\250\213.md" | 130 +++++++++++++++---
 ...05\345\255\230\347\256\241\347\220\206.md" | 106 +++++++++++++-
 OperatingSystem/5.I:O.md                      |   8 +-
 ...07\344\273\266\347\256\241\347\220\206.md" |  54 +++++++-
 5 files changed, 269 insertions(+), 31 deletions(-)

diff --git "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md" "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
index e3d5aeb9..3f638f3a 100644
--- "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
+++ "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
@@ -349,7 +349,7 @@ CPU 的内部由**寄存器、控制器、运算器和时钟**四部分组成，
 - 特权(privilege)指令:只能由操作系统使用、用户程序不能使用的指令
 - 非特权指令:用户程序可以使用的指令
 
-用户态 -> 内核态的唯一途径是通过中断/异常/陷入机制。
+用户态 -> 内核态的唯一途径是通过陷入（trap，一种中断方式）机制（将系统调用的代码放在一个约定好的寄存器中，通过陷入将控制交给操作系统）。
 
 内核态 -> 用户态是通过设置程序状态字PSW。
 
diff --git "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md" "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
index 1d462423..862fe261 100644
--- "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
+++ "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
@@ -209,9 +209,15 @@
 
 - Socket套接字
 
+    套接字的功能非常强大，可以支持不同层面、不同应用、跨网络的通信。使用套接字进行通信需要双方均创建一个套接字，其中一方作为服务器方，另外一方作为客户方。服务器方必须先创建一个服务区套接字，然后在该套接字上进行监听，等待远方的连接请求。欲与服务器通信的客户则创建一个客户套接字，然后向服务区套接字发送连接请求。服务器套接字在收到连接请求后，将在服务器方机器上创建一个客户套接字，与远方的客户机上的客户套接字形成点到点的通信通道。之后，客户方和服务器方就可以通过send和recv命令在这个创建的套接字通道上进行交流了。
+
     socket 提供端到端的双相通信。一个套接字可以与一个或多个进程关联。就像管道有命令管道和未命名管道一样，套接字也有两种模式，套接字一般用于两个进程之间的网络通信，网络套接字需要来自诸如TCP（传输控制协议）或较低级别UDP（用户数据报协议）等基础协议的支持。
 
-- Signals信号/信号量
+- Signals信号
+
+    管道和套接字虽然提供了丰富的通信语义，并且也得到了广泛应用，但它们也存在某些缺点，并且在某些时候，这两种通信机制会显得很不好用。首先，如果使用管道和套接字方式来通信，必须事先在通信的进程间建立连接（创建管道或套接字），这需要消耗系统资源。其次，通信是自愿的。即一方虽然可以随意向管道或套接字发送信息，但对方却可以选择接收的时机。即使对方对此充耳不闻，你也奈何不得。再次，由于建立连接消耗时间，一旦建立，我们就想进行尽可能多的通信。而如果通信的信息量微小，如我们只是想通知一个进程某件事情的发生，则用管道和套接字就有点“杀鸡用牛刀”的味道，效率十分低下。因此，我们需要一种不同的机制来处理如下通信需求：想迫使一方对我们的通信立即做出回应。我们不想事先建立任何连接，而是临时突然觉得需要与某个进程通信。传输的信息量微小，使用管道或套接字不划算。应付上述需求，我们使用的是信号（signal）。那么信号是什么呢？在计算机里，信号就是一个内核对象，或者说是一个内核数据结构。发送方将该数据结构的内容填好，并指明该信号的目标进程后，发出特定的软件中断。操作系统接收到特定的中断请求后，知道是有进程要发送信号，于是到特定的内核数据结构里查找信号接收方，并进行通知。接到通知的进程则对信号进行相应处理。信号非常类似我们生活当中的电报。如果你想给某人发一封电报，就拟好电文，将报文和收报人的信息都交给电报公司。电报公司则将电报发送到收报人所在地的邮局（中断），并通知收报人来取电报。发报时无需收报人事先知道，更无需进行任何协调。如果对方选择不对信号做出响应，则将被操作系统终止运行。
+
+    
 
     两个或多个进程可以通过简单的信号进行合作，可以强迫一个进程在某个位置停止，直到它接收到一个特定的信号。信号量是一个特殊的变量。用于进程间传递信息的一个整数值。
 
@@ -223,20 +229,32 @@
 
     操作系统会中断目标程序的进程来向其发送信号、在任何非原子指令中，执行都可以中断，如果进程已经注册了新号处理程序，那么就执行进程，如果没有注册，将采用默认处理的方式。
 
+- 信号量
+
+    信号量（semaphore）是由荷兰人E.W.Dijkstra在20世纪60年代所构思出的一种程序设计构造。其原型来源于铁路的运行：在一条单轨铁路上，任何时候只能有一列列车行驶在上面（如图6-9）。而管理这条铁路的系统就是信号量。任何一列火车必须等到表明铁路可以行驶的信号后才能进入轨道。当一列列车进入单轨运行后，需要将信号改为禁止进入，从而防止别的火车同时进入轨道。而当列车驶出单轨后，则需要将信号变回允许进入状态。这很像以前的旗语，在计算机里，信号量实际上就是一个简单整数。一个进程在信号变为0或者1的情况下推进，并且将信号变为1或0来防止别的进程推进。当进程完成任务后，则将信号再改变为0或1，从而允许其他进程执行。需要注意的是，信号量不只是一种通信机制，更是一种同步机制。
+
 - Shared Memory共享内存
 
-    共享内存可以看作对一段内存区域的映射，它将一段内存区域映射到多个进程的地址空间，从而使得这些进程能够共享这一内存区域。共享内存是进程通信中最快的一种方法，因为数据不需要在进程间复制，而可以直接映射到各个进程的地址空间中。在共享内存中要注意的一个问题是：当多个进程对共享内存区域进行访问时，要注意这些进程之间的同步问题。例如，如果server正在向共享内存区域中写数据，那么client进程就不能访问这些数据，直到server全部写完之后，client才可以访问。为了实现进程间的同步问题，通常使用前面介绍过的信号量来实现这一目标。一个共享内存段可以由一个进程创建，然后由任意共享这一内存段的进程对它进行读写。当进程间需要通信时，一个进程可以创建一个共享内存段，然后需要通信的各个进程就可以在信号量的控制下保持同步，在这里交换数据，完成通信。
+    管道、套接字、信号、信号量，虽然满足了多种通信需要，但还是有一种需要未能满足。这就是两个进程需要共享大量数据。这就像两个人，他们互相喜欢，并想要一起生活时（共享大量数据量），打电话、握手、对白等就显得不够了，这个时候需要的是拥抱，只有将其紧紧拥抱于怀，感觉才最到位，也才能尽可能地共享。进程的拥抱就是共享内存。共享内存就是两个进程共同拥有同一片内存。对于这片内存中的任何内容，二者均可以访问。要使用共享内存进行通信，一个进程首先需要创建一片内存空间专门作为通信用，而其他进程则将该片内存映射到自己的（虚拟）地址空间。这样，读写自己地址空间中对应共享内存的区域时，就是在和其他进程进行通信。乍一看，共享内存有点像管道，有些管道不也是一片共享内存吗？这是形似而神不似。首先，使用共享内存机制通信的两个进程必须在同一台物理机器上；其次，共享内存的访问方式是随机的，而不是只能从一端写，另一端读，因此其灵活性比管道和套接字大很多，能够传递的信息也复杂得多。共享内存的缺点是管理复杂，且两个进程必须在同一台物理机器上才能使用这种通信方式。共享内存的另外一个缺点是安全性脆弱。因为两个进程存在一片共享的内存，如果一个进程染有病毒，很容易就会传给另外一个进程。就像两个紧密接触的人，一个人的病毒是很容易传染另外一个人的。这里需要注意的是，使用全局变量在同一个进程的进程间实现通信不称为共享内存。
+
+    共享内存是进程通信中最快的一种方法，因为数据不需要在进程间复制，而可以直接映射到各个进程的地址空间中。在共享内存中要注意的一个问题是：当多个进程对共享内存区域进行访问时，要注意这些进程之间的同步问题。例如，如果server正在向共享内存区域中写数据，那么client进程就不能访问这些数据，直到server全部写完之后，client才可以访问。为了实现进程间的同步问题，通常使用前面介绍过的信号量来实现这一目标。一个共享内存段可以由一个进程创建，然后由任意共享这一内存段的进程对它进行读写。当进程间需要通信时，一个进程可以创建一个共享内存段，然后需要通信的各个进程就可以在信号量的控制下保持同步，在这里交换数据，完成通信。
 
 - Message Queue消息传递系统/消息队列
 
+    消息队列是一列具有头和尾的消息排列。新来的消息放在队列尾部，而读取消息则从队列头部开始，消息队列乍一看，这不是管道吗？一头读、一头写？没错。这的确看上去像管道，但它不是管道。首先，它无需固定的读写进程，任何进程都可以读写（当然是有权限的进程）。其次，它可以同时支持多个进程，多个进程可以读写消息队列。即所谓的多对多，而不是管道的点对点。另外，消息队列只在内存中实现。最后，它并不是只在UNIX和类UNIX操作系统中实现。几乎所有主流操作系统都支持消息队列。
+
     进程与其它的进程进行通信而不必借助共享数据，通过互相发送和接收消息，建立一条通信链路。
 
     一听到消息队列这个名词你可能不知道是什么意思，消息队列是用来描述内核寻址空间内的内部链接列表。可以按几种不同的方式将消息按顺序发送到队列并从队列中检索消息。每个消息队列由 IPC 标识符唯一标识。消息队列有两种模式，一种是`严格模式`， 严格模式就像是 FIFO 先入先出队列似的，消息顺序发送，顺序读取。还有一种模式是 `非严格模式`，消息的顺序性不是非常重要。
 
 - Pipe管道通信
 
-    在两个进程之间，可以建立一个通道，一个进程向这个通道里写入字节流，另一个进程从这个管道中读取字节流。管道是同步的，当进程尝试从空管道读取数据时，该进程会被阻塞，直到有可用数据为止。shell 中的`管线 pipelines` 就是用管道实现的，当 shell 发现输出
+    人们最常使用的通信手段就是对白。对白的特点就是一方发出声音，另一方接收声音。而声音的传递则通过空气（当面或无线交谈）、线缆（有线电话）进行传递。类似，进程对白就是一个进程发出某种数据信息，另外一方接收数据信息，而这些数据信息通过一片共享的存储空间进行传递。在这种方式下，一个进程向这片存储空间的一端写入信息，另一个进程从存储空间的另外一端读取信息。这看上去像什么？管道。管道所占的空间既可以是内存，也可以是磁盘。就像两人对白的媒介可以是空气，也可以是线缆一样。要创建一个管道，一个进程只需调用管道创建的系统调用即可。该系统调用所做的事情就是在某种存储介质上划出一片空间，赋给其中一个进程写的权利，另一个进程读的权利即可。
 
+    从根本上说，管道是一个线性字节数组，类似文件，可以使用文件读写的方式进行访问。但却不是文件。因为通过文件系统看不到管道的存在。另外，我们前面说了，管道可以设在内存里，而文件很少设在内存里
+    
+    在两个进程之间，可以建立一个通道，一个进程向这个通道里写入字节流，另一个进程从这个管道中读取字节流。管道是同步的，当进程尝试从空管道读取数据时，该进程会被阻塞，直到有可用数据为止。shell 中的`管线 pipelines` 就是用管道实现的，当 shell 发现输出
+    
     发送进程以字符流形式将大量数据送入管道，接收进程可从管道接收数据，二者利用管道进行通信，管道是单向的、先进先出的，它把一个进程的输出和另一个进程的输入连接在一起。一个进程（写进程）在管道的尾部写入数据，另一个进程（读进程）从管道的头部读出数据。每次只有一个进程能够真正地进入管道，其他的只能等待。
     
     
@@ -287,12 +305,12 @@
 
 - 先来先服务(first-come,first-serverd)
 
-    按照进入就绪队列的进程顺序，不加其他条件干涉
+    按照进入就绪队列的进程顺序，不加其他条件干涉。但是也存在缺陷，例如一个进程本来需要5秒就能执行完成，但是在它前面的进程确需要1个小时，它不得不等待一个小时。
 
 - 最短作业优先(Shortest Job First)
 
     优先选出就绪队列中CPU执行时间最短的进程，例如：就绪队列有4个进程P1，P2，P3，P4，执行时间为：16,12,4,3 按照短进程优先，则周转时间(从进程提交到进程完成的时间间隔)分别为：35,19,7,3
-    平均周转时间：16，平均周转时间越小，调度性能越好。
+    平均周转时间：16，平均周转时间越小，调度性能越好。这种算法的核心是所有的程序并不都一样，而是有优先级的区分。具体来说，就是短任务的优先级比长任务的高，而我们总是安排优先级高的程序先运行。就像晚辈在公交汽车上见到长辈需要让座一样。
 
     在所有的进程都可以运行的情况下，最短作业优先的算法才是最优的。
 
@@ -309,9 +327,9 @@
     
 - 优先级调度
 
-    每个进程都被赋予一个优先级，优先级高的进程优先运行。
-
-
+    每个进程都被赋予一个优先级，优先级高的进程优先运行。优先级调度的优点是可以赋予重要的进程以高优先级以确保重要任务能够得到CPU时间。其缺点则是低优先级的进程可能会“饥饿”。
+    
+    优先级倒挂（priority inversion）其所指的是一个低优先级任务持有一个被高优先级认为所需要的共享资源。这样高优先级任务因资源缺乏而处于受阻状态，一直到低优先级任务释放资源为止。这样实际上造成了这两个任务的优先级倒挂。如果此时有其他优先级介于二者之间的任务，并且其不需要这个共享资源，则该中级优先级的进程将获得CPU控制，从而超越这两个任务，导致高优先级进程被临界区外的低优先级进程阻塞。在某些时候，优先级倒挂并不会造成损害。高优先级任务的延迟并不会注意到。因为低优先级进程最终会释放资源。但在其他一些时候，优先级倒挂则可能引起严重后果。如果一个高优先级进程一直不能获得资源，有可能造成系统故障，或激发事先定义的纠正措施，如系统复位。例如，美国的火星探测器Mars Path-finder就是因为优先级倒挂而出现故障。
 
 
 
@@ -553,6 +571,8 @@ Android使用的进程有些不同。活动管理器是Android负责正在运行
 
 #### 为什么要有线程呢？ 
 
+进程是运转的程序，是为了在CPU上实现多道编程而发明的一个概念。但是进程在一个时间只能干一件事情。如果想同时干两件事，例如同时看两场电影，我们自然想到传说中的分身术，就像孙悟空那样同时变出多个真身。当然，人在现实中进行分身是办不到的。但进程却可以办到，办法就是线程。线程就是我们为了让一个进程能够同时干多件事情而发明的“分身术”。
+
 如果说，在操作系统中引入进程的目的是使多个程序并发执行以改善资源利用率及提高系统的吞吐量；那么，在操作系统中再引入线程，则是为了减少程序并发执行时所付出的时空开销，使操作系统具有更好的并发性。为了说明这一点，首先回顾进程的两个基本属性：一是进程是一个可拥有资源的独立单位；二是进程同时又是一个可以独立调度和分派的基本单位。正是由于进程具有这两个基本属性，才使之成为一个能独立运行的基本单位，从而也就构成了进程并发执行的基础。
 
 
@@ -604,6 +624,10 @@ Android使用的进程有些不同。活动管理器是Android负责正在运行
 
 ### 线程实现
 
+线程的调度却与进程调度有稍许不同。由于线程是在进程的基础上产生的概念（进程里面的一个执行序列），其调度可以由进程负责。当然，我们也可以将线程的调度交给操作系统。而这两种不同的调度推手就形成了线程的两种实现：用户态实现和内核态实现。由进程自己管理就是用户态线程的实现，由操作系统管理就是内核态线程实现。用户态和内核态的判断以线程表所处的位置为依据：位于内核叫内核态实现，位于用户层叫用户态实现。前面我们在讲述进程时没有提到过实现方式的问题，即应该是在用户态还是在内核态实现的问题。这是因为进程是在CPU上实现并发（多道编程），而CPU是由操作系统管理的，因此，进程的实现只能由操作系统内核来进行，而不存在用户态实现的情况，根本没有这种探讨的需要。但对于线程就不同了，因为线程是进程内部的东西，当然存在由进程直接管理线程的可能性。因此，线程存在着内核态与用户态两种实现可能。
+
+
+
 主要有三种实现方式
 
 - 在用户空间中实现线程；
@@ -612,8 +636,36 @@ Android使用的进程有些不同。活动管理器是Android负责正在运行
 
 下面我们分开讨论一下
 
+#### 在内核中实现线程
+
+由操作系统来管理线程有很多好处，最重要的好处是用户编程简单。因为线程的复杂性由操作系统承担，用户程序员在编程时无需管理线程的调度，即无需担心线程什么时候会执行、什么时候会挂起。另外一个重要好处是，如果一个线程执行阻塞操作，操作系统可以从容地调度另外一个线程执行。因为操作系统能够监控所有的线程。那么内核态线程实现有什么缺点呢？首先是效率较低。因为线程在内核态实现，每次线程切换都需要陷入到内核，由操作系统来进行调度。而从用户态陷入到内核态是要花时间的。另外，内核态实现占用内核稀缺的内存资源，因为操作系统需要维护线程表。操作系统所占内存空间一旦装载结束后就已经固定，无法动态改变。由于线程的数量通常大大多于进程的数量，因此随着线程数量的增加，操作系统内核空间将迅速耗尽。那么内核态线程实现有什么缺点呢？首先是效率较低。因为线程在内核态实现，每次线程切换都需要陷入到内核，由操作系统来进行调度。而从用户态陷入到内核态是要花时间的。另外，内核态实现占用内核稀缺的内存资源，因为操作系统需要维护线程表。操作系统所占内存空间一旦装载结束后就已经固定，无法动态改变。由于线程的数量通常大大多于进程的数量，因此随着线程数量的增加，操作系统内核空间将迅速耗尽。如果要建立进程线程，但内核空间不够了，怎么办？我们可以做的选择有：“杀死”别的进程；创建失败；让它等一下。前面说过，“杀死”别的进程是一件很不好的事情，因为将造成服务不确定性。宣称创建失败也很差。因为创建失败有可能意味着某个进程无法往前推进，这违反了我们前面说过的进程模型的时序推进要求。让创建者等一下，这要看创建的是什么进程和线程了。如果是系统进程线程，等一下可能意味着关键服务无法按时启动；如果是用户进程线程，等一下可能引起用户的强烈不满。而且，等多久谁也不知道。那在内核空间满了后，应该怎么办呢？打一个战场上的比方就清楚了。如果战场上对手太厉害了，想再调个师的军队，结果没有，怎么办？投降。也就是说，如果内核空间溢出，操作系统将停止运转。因为要创立的进程可能很重要，所以不能不创建。所以最好的结局是“死掉”。别人发现系统“死了”就会采取行动来补救。如果操作系统还要运转，却不能正确地运转，那是很危险的事情。操作系统采取的这种行动在灾难应对领域称为“无害遽止”。但上面两个缺点还不是最致命的。最致命的是内核态实现需要修改操作系统，这在线程概念提出之初是一件很难办到的事情。试想，如果你作为研究人员提出了线程概念，然后你去找一家操作系统研发商，要求其修改操作系统，加入线程的管理，结果会怎样？操作系统开发商会请你走开。有谁敢把一个还未经证明的新概念加入到对计算机影响甚大的操作系统里？除非我们先证明线程的有效性，否则很难说服他人修改操作系统。这样，就有了线程的用户态实现。
+
+现在我们考虑使用内核来实现线程的情况，此时不再需要运行时环境了。另外，每个进程中也没有线程表。相反，在内核中会有用来记录系统中所有线程的线程表。当某个线程希望创建一个新线程或撤销一个已有线程时，它会进行一个系统调用，这个系统调用通过对线程表的更新来完成线程创建或销毁工作。
+
+当某个线程希望创建一个新线程或撤销一个已有线程时，它会进行一个系统调用，这个系统调用通过对线程表的更新来完成线程创建或销毁工作。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/thread_kernel.png?raw=true)  
+
+内核中的线程表持有每个线程的寄存器、状态和其他信息。这些信息和用户空间中的线程信息相同，但是位置却被放在了内核中而不是用户空间中。另外，内核还维护了一张进程表用来跟踪系统状态。
+
+所有能够阻塞的调用都会通过系统调用的方式来实现，当一个线程阻塞时，内核可以进行选择，是运行在同一个进程中的另一个线程（如果有就绪线程的话）还是运行一个另一个进程中的线程。但是在用户实现中，运行时系统始终运行自己的线程，直到内核剥夺它的 CPU 时间片（或者没有可运行的线程存在了）为止。
+
+
+
+由于在内核中创建或者销毁线程的开销比较大，所以某些系统会采用可循环利用的方式来回收线程。当某个线程被销毁时，就把它标志为不可运行的状态，但是其内部结构没有受到影响。稍后，在必须创建一个新线程时，就会重新启用旧线程，把它标志为可用状态。
+
+如果某个进程中的线程造成缺页故障后，内核很容易的就能检查出来是否有其他可运行的线程，如果有的话，在等待所需要的页面从磁盘读入时，就选择一个可运行的线程运行。这样做的缺点是系统调用的代价比较大，所以如果线程的操作（创建、终止）比较多，就会带来很大的开销。
+
+
+
 #### 在用户空间中实现线程
 
+线程在刚刚出现时，由于无法说服操作系统人员修改操作系统，其实现的方式只能是在用户态。（谁提出谁举证。）那么用户态实现意味着什么呢？或者说用户态实现是什么意思呢？就是用户自己做线程的切换，自己管理线程的信息，而操作系统无须知道线程的存在。那么在用户态如何进行线程调度呢？那就是用户自己写一个执行系统（runtimesystem）作调度器，即除了正常执行任务的线程外，还有一个专门负责线程调度的线程。由于大家都在用户态下运行，谁也不比谁占优势，要想取得CPU控制权只能靠大家的自愿合作。一个线程在执行完一段时间后主动把资源释放给别人使用，而在内核态下则无须如此。因为操作系统可通过周期性的时钟中断把控制权夺过来。在用户态实现情况下，执行系统的调度器（runtime scheduler）也是线程，没有能力强行夺走控制权，所以必须合作。
+
+那么用户态实现有什么优点呢？有。首先是灵活性。因为操作系统无须知道线程的存在，所以在任何操作系统上都能应用；其次是线程切换快。因为切换在用户态进行，无须陷入到内核态。最后是不用修改操作系统，实现容易。
+
+那么这种实现方式有什么缺点吗？有。首先，编程序变得很诡异。我们前面说过，用户态线程需要相互合作才能运转。这样，我们在写程序时，必须仔细斟酌在什么时候应该让出CPU给别的线程使用。而让出时机的选择对线程的效率和可靠性有很大的影响。这并不是一件容易的事。另外一个更为严重的问题是，用户态线程实现无法完全达到线程提出所要达到的目的：进程级多道编程。如果在执行过程中一个线程受阻，它将无法将控制权交出来（因为受阻后无法执行交出CPU的指令了），这样整个进程都无法推进。操作系统随即把CPU控制权交给另外一个进程。这样，一个线程受阻造成整个进程都受阻，我们期望通过线程对进程实施分身的计划就失败了。这是用户态线程的致命弱点。
+
 第一种方法是把整个线程包放在用户空间中，内核对线程一无所知，它不知道线程的存在。所有的这类实现都有同样的通用结构
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/thread_user.png?raw=true)  
@@ -636,37 +688,63 @@ Android使用的进程有些不同。活动管理器是Android负责正在运行
 
 另外一个问题是，如果一个线程开始运行，该线程所在进程中的其他线程都不能运行，除非第一个线程自愿的放弃 CPU，在一个单进程内部，没有时钟中断，所以不可能使用轮转调度的方式调度线程。除非其他线程能够以自己的意愿进入运行时环境，否则调度程序没有可以调度线程的机会。
 
-### 在内核中实现线程
 
-现在我们考虑使用内核来实现线程的情况，此时不再需要运行时环境了。另外，每个进程中也没有线程表。相反，在内核中会有用来记录系统中所有线程的线程表。当某个线程希望创建一个新线程或撤销一个已有线程时，它会进行一个系统调用，这个系统调用通过对线程表的更新来完成线程创建或销毁工作。
 
-当某个线程希望创建一个新线程或撤销一个已有线程时，它会进行一个系统调用，这个系统调用通过对线程表的更新来完成线程创建或销毁工作。
+#### 在用户和内核空间中混合实现线程
 
-![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/thread_kernel.png?raw=true)  
+鉴于用户态和内核态的线程模型都存在缺陷，因此现代操作系统将二者结合起来使用。用户态的执行系统负责进程内部线程在非阻塞时的切换；内核态的操作系统负责阻塞线程的切换。即我们同时实现内核态和用户态线程管理。其中内核态线程数量较少，而用户态线程数量较多。每个内核态线程可以服务一个或多个用户态线程。换句话说，用户态线程被多路复用到内核态线程上。例如，某个进程有5个线程，我们可以将5个线程分成两组，一组3个线程，另一组2个线程。每一组线程使用一个内核线程。这样，该进程将使用两个内核线程。如果一个线程阻塞，则与其同属于一组的线程皆阻塞，但另外一组线程却可以继续执行。
 
-内核中的线程表持有每个线程的寄存器、状态和其他信息。这些信息和用户空间中的线程信息相同，但是位置却被放在了内核中而不是用户空间中。另外，内核还维护了一张进程表用来跟踪系统状态。
+结合用户空间和内核空间的优点，设计人员采用了一种`内核级线程`的方式，然后将用户级线程与某些或者全部内核线程多路复用起来
 
-所有能够阻塞的调用都会通过系统调用的方式来实现，当一个线程阻塞时，内核可以进行选择，是运行在同一个进程中的另一个线程（如果有就绪线程的话）还是运行一个另一个进程中的线程。但是在用户实现中，运行时系统始终运行自己的线程，直到内核剥夺它的 CPU 时间片（或者没有可运行的线程存在了）为止。
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/user_kernel_thread_os.png?raw=true)  
 
+在这种模型中，编程人员可以自由控制用户线程和内核线程的数量，具有很大的灵活度。采用这种方法，内核只识别内核级线程，并对其进行调度。其中一些内核级线程会被多个用户级线程多路复用。
 
 
-由于在内核中创建或者销毁线程的开销比较大，所以某些系统会采用可循环利用的方式来回收线程。当某个线程被销毁时，就把它标志为不可运行的状态，但是其内部结构没有受到影响。稍后，在必须创建一个新线程时，就会重新启用旧线程，把它标志为可用状态。
 
-如果某个进程中的线程造成缺页故障后，内核很容易的就能检查出来是否有其他可运行的线程，如果有的话，在等待所需要的页面从磁盘读入时，就选择一个可运行的线程运行。这样做的缺点是系统调用的代价比较大，所以如果线程的操作（创建、终止）比较多，就会带来很大的开销。
+### 线程从用户态进入内核态
 
+什么情况会造成一个线程从用户态进入到内核态呢？首先，如果在程序运行过程中发生中断或异常，系统将自动切换到内核态来运行中断或异常处理机制。此外，程序进行系统调用也将造成从用户态进入到内核态的转换。
 
+例如，一个C++程序调用函数cin。cin是标准命名空间STD中的一个流对象，它调用C函数库里面的scanf（）库函数，scanf（）库函数则进一步调用操作系统的READ函数来真正获取用户输入。这里的READ函数实际上是由操作系统提供的一个系统调用（需要注意的是，很多高级语言的函数库里也包含名为READ的库函数，不过此READ非彼READ）。其执行过程如下：
 
-## 在用户和内核空间中混合实现线程
+1. 执行汇编语言里面的系统调用指令（如syscall）。
+2. 将调用的参数SYS＿READ、file number,size存放在指定的寄存器或栈上（事先约好）。
+3. 当处理器执行到"syscall"指令时，察觉这是一个系统调用指令，将进行如下操作：
+    - 设置处理器至内核态。
+    - 保存当前寄存器（栈指针、程序计数器、通用寄存器）。
+    - 将栈指针设置指向内核栈地址。
+    - 将程序计数器设置为一个事先约定的地址上。该地址上存放的是系统调用处理程序的起始地址。
+4. 系统调用处理程序执行系统调用，并调用内核里面的READ函数。这样就实现了从用户态到内核态的转换，并完成系统调用所要求的功能。
 
-结合用户空间和内核空间的优点，设计人员采用了一种`内核级线程`的方式，然后将用户级线程与某些或者全部内核线程多路复用起来
 
-![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/user_kernel_thread_os.png?raw=true)  
 
-在这种模型中，编程人员可以自由控制用户线程和内核线程的数量，具有很大的灵活度。采用这种方法，内核只识别内核级线程，并对其进行调度。其中一些内核级线程会被多个用户级线程多路复用。
+### 线程同步
+
+引入线程后，也引入了一个巨大的问题，即多线程程序的执行结果有可能是不确定的。而不确定则是我们人类非常反感的东西。那么如何在保持线程这个概念的同时，消除其执行结果的不确定性呢？答案是线程的同步。
+
+线程同步的目的就是不管线程之间的执行如何穿插，其运行结果都是正确的。或者说，要保证多线程执行下结果的确定性。而在达到这个目标的同时，要保持对线程执行的限制越少越好。除此之外，线程同步的另外一个目的涉及执行效率。除了前面说过的多线程执行的结果是不确定的之外，其执行效率也是不确定的。比如，在某段时间内，线程A执行了5条指令，而线程B只执行了3条指令。线程A比线程B多执行了两条指令。但这并不是问题的关键。问题的关键是到底线程A是否比线程B执行的多，或者是多多少等，皆是不确定的。如果我们想使其变得确定，就需要进行线程同步。
+
+
+
+锁有两个基本操作：
+
+- 闭锁
+
+    闭锁就是将锁锁上，其他人进不来
+
+- 开锁
 
+    开锁就是你做的事情做完了，将锁打开，别的人可以进去了。闭锁操作有两个步骤，分别如下：
 
+    - 等待锁达到打开状态
+    - 获得锁并锁上
 
-**导致系统出现死锁的情况**
+
+
+### 死锁
+
+如果有一组线程，每个线程都在等待一个事件的发生，而这个事件只能由该组线程里面的另一线程发出，则称这组线程发生了死锁。
 
 死锁的出现需要同时满足下面四个条件
 
@@ -677,6 +755,16 @@ Android使用的进程有些不同。活动管理器是Android负责正在运行
 
 
 
+多道编程或者多线程编程除了要应对死锁之外，还有一个问题必须面对：饥饿。更准确地说是资源饥饿。资源饥饿指的是某个线程一直等不到它所需要的资源，从而无法向前推进。这就像一个人因饥饿而无法成长一样。刚听上去饥饿像是一个与死锁不同的问题。但仔细考虑，却发现它实际上是死锁的一种通例。因为处于死锁状态的所有线程均无法获得其需要的资源，所以都处于饥饿状态。死锁实际上就是饥饿。对于处于饥饿状态的线程来说，它因为无法往前推进，又有一点死锁的味道。因此，饥饿有时也称为死锁的“孪生兄弟”。不过，这里需要注意的是，饥饿和死锁还是有所不同的。处于死锁的线程必须多于1个，且处于一个死锁线程组的线程所需资源均为该组里其他线程所持有。而处于饥饿的线程可以只有1个，并且其所需要的资源可以被任何线程所占有。
+
+除此之外，饥饿还有另外一种特例：活锁。在活锁状态下，处于活锁线程组里的线程状态可以改变，但是整个活锁组的线程无法推进。活锁可以用两个人过一条很窄的小桥来比喻：为了让对方先过，两个人都想给对方让路而闪身到一边，但由于两个人都同时进行此种动作，有可能两个人都同时运动到左边，然后又同时运动到右边。这样，虽然两个人的状态一直在变化，但却都无法往前推进。由此可见，活锁是死锁的通例。
+
+从上述分析可以看出，死锁、活锁、饥饿是一个包含与被包含的关系。死锁是活锁的特例，而活锁又是饥饿的特例。在多道编程时，我们不只要应对死锁，还需要应对活锁和饥饿，而由于它们之间存在类似性，死锁应对的手段也可以在一定程度上用来应对活锁和饥饿，因为活锁和饥饿是死锁的通例，且死锁是无法完全避免的，活锁和饥饿也是不可完全避免的。
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/lock_hung.jpg?raw=true)        
+
+
+
 ### 进程和线程的区别
 
 进程有如下两个特点: 
diff --git "a/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md" "b/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
index 69536170..6d8e055e 100644
--- "a/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
+++ "b/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
@@ -1,5 +1,7 @@
 # 3. 内存管理
 
+内存管理机制负责对内存架构进行管理，使程序在内存架构的任何一个层次上的存放对于用户来说都是一样的。用户无须担心自己的程序是存储在缓存、主存、磁盘还是磁带上，反正运行、计算、输出的结果都一样。而内存管理实现这种媒介透明的手段就是虚拟内存。用我们多次讲过的“抽象”来说，虚拟内存就是操作系统提供给用户的另一个“幻象”。这个幻象构建在内存架构的顶端，给用户提供一个比物理主存空间大许多的地址空间。
+
 常用概念: 
 
 - 页框：内存中固定长度的块
@@ -42,7 +44,17 @@
 
 #### 基址寄存器和变址寄存器
 
-最简单的办法是使用`动态重定位(dynamic relocation)`技术，它就是通过一种简单的方式将每个进程的地址空间映射到物理内存的不同区域。还有一种方式是使用基址寄存器和变址寄存器。
+在多道编程环境下，由于程序加载到内存的地址不是固定的（有多个地方可加载），我们必须对地址进行翻译。那么如何来翻译呢？我们看到，一个程序是加载到内存里事先划分好的某片区域，而且该程序是整个加载进去。该程序里面的虚地址只要加上其所占区域的起始地址即可获得物理地址。因此，我们的翻译过程非常简单：物理地址=虚拟地址+程序所在区域的起始地址
+
+程序所在区域的起始地址称为（程序）基址。另外，由于有多个程序在内存空间中，我们需要进行地址保护。由于每个程序占用连续的一片内存空间，因此只要其访问的地址不超出该片连续空间，则为合法访问。因此，地址保护也变得非常简单，只要访问的地址满足下列条件即为合法访问：
+
+程序所在区域的起始地址≤有效地址≤程序所在区域的起始地址+程序长度
+
+由此可见，我们只需要设置两个端值：基址和变址，即可达到地址翻译和地址保护的目的。这两个端值可以由两个寄存器来存放，分别称为基址寄存器和变址寄存器。在固定分区下，基址就是固定内存分区中各个区域的起始内存地址，而变址则是所加载程序的长度（记住，不是内存各个分区的上限）。
+
+这样，每次程序发出的地址需要和极限比较大小；如果大于极限，则属非法访问。在这个时候我们将陷入内核，终止进程（在个别操作系统上，也可能进入一个异常处理的过程）；否则将基址加上偏移获得物理地址，就可以合法访问这个物理地址。
+
+`动态重定位(dynamic relocation)`技术，它就是通过一种简单的方式将每个进程的地址空间映射到物理内存的不同区域。
 
 - 基址寄存器：存储数据内存的起始位置
 - 变址寄存器：存储应用程序的长度。
@@ -51,6 +63,8 @@
 
 
 
+
+
 ## 内存的演变
 
 在早些的操作系统中，并没有引入内存抽象的概念。程序直接访问和操作的都是物理内存，内存的管理也非常简单，除去操作系统所用的内存之外，全部给用户程序使用，想怎么折腾都行，只要别超出最大的容量。这种内存操作方式使得操作系统中存在多进程变得完全不可能，比如MS-DOS，你必须执行完一条指令后才能接着执行下一条。如果是多进程的话，由于直接操作物理内存地址，当一个进程给内存地址1000赋值后，另一个进程也同样给内存地址赋值，那么第二个进程对内存的赋值会覆盖第一个进程所赋的值，这回造成两条进程同时崩溃。随着计算机技术发展，要求操作系统支持多进程的需求，所谓多进程，并不需要同时运行这些进程，只要它们都处于ready 状态，操作系统快速地在它们之间切换，就能达到同时运行的假象。每个进程都需要内存，Context Switch时，之前内存里的内容怎么办？简单粗暴的方式就是先dump到磁盘上，然后再从磁盘上restore之前dump的内容（如果有的话），但效果并不好，太慢了！那怎么才能不慢呢？把进程对应的内存依旧留在物理内存中，需要的时候就切换到特定的区域。这就涉及到了内存的保护机制，毕竟进程之间可以随意读取、写入内容就乱套了，非常不安全。因此操作系统需要对物理内存做一层抽象，也就是「地址空间」(Address Space)，一个进程的地址空间包含了该进程所有相关内存，比如code/stack/heap。一个16KB的地址空间可能长这样：
@@ -139,6 +153,8 @@ Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自
 
 大小不等的固定分区和大小可变的分区技术在内存的使用上都是低效的，前者会产生内部碎片，后者会产生外部碎片。但是，如果内存被划分成大小固定、相等的块，切块相对比较小，每个进程也被分成同样大小的小块，那么进程中称为页的块可以分配到内存中称为页框的可用块。这样在使用分页技术时，每个进程在内存中浪费的空间，仅仅是进程最后一页的一小部分形成的内部碎片。没有任何外部碎片。
 
+分页系统的核心就是将虚拟内存空间和物理内存空间皆划分为大小相同的页面，如4KB、8KB或16KB等，并以页面作为内存空间的最小分配单位，一个程序的一个页面可以存放在任意一个物理页面里。这样，由于物理空间是页面的整数倍，并且空间分配以页面为单位，将不会再产生外部碎片。同时，由于一个虚拟页面可以存放在任何一个物理页面里，空间增长也容易解决：只需要分配额外的虚拟页面，并找到一个闲置的物理页面存放即可。在分页系统下，一个程序发出的虚拟地址由两部分组成：页面号和页内偏移值。
+
 这样操作系统需要为每个进程维护一个页表（page table）。页表给出了该进程的每页所对应页框的位置。在程序中每个逻辑地址包括一个页号和该页中的偏移量。在分页中，逻辑地址到物理地址的转换仍然由处理器硬件完成，给出逻辑地址（页号，偏移量）后，处理器使用页表产生物理地址（页框号，偏移量）。
 
 
@@ -151,9 +167,73 @@ Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自
 
 
 
+#### 地址翻译
+
+从上面的分析可以看出，分页系统要能够工作的前提是：对于任何一个虚拟页面，系统知道该页面是否在物理内存中，如果在的话，其对应的物理页面是哪个；如果不在的话，则产生一个系统中断（缺页中断），并将该虚页从磁盘转到内存，然后将分配给它的物理页面号返回。也就是说，页面管理系统要能够将虚拟地址转换为物理地址。
+
+因此，分页系统的核心是页面的翻译，即从虚拟页面到物理页面的映射。而这个翻译过程由内存管理单元（MMU）完成。MMU接收CPU发出的虚拟地址，将其翻译为物理地址后发送给内存。内存单元按照该物理地址进行相应访问后读出或写入相关数据
+
+内存管理单元对虚拟地址的翻译只是对页面号的翻译，即将虚拟页面号翻译成物理页面号。而对于偏移值，则不进行任何操作。这是因为虚拟页表和物理页表大小完全一样，虚拟页面里的偏移值和物理页面里的偏移值完全一样，因此无须翻译。那么内存管理单元是通过什么手段完成这种翻译的呢？当然是查页表。对于每个程序，内存管理单元都为其保存一个页表，该页表中存放的是虚拟页面到物理页面的映射。每当为一个虚拟页面寻找到一个物理页面后，就在页表里面增加一个记录来保留该虚拟页面到物理页面的映射关系。随着虚拟页面进出物理内存，页表的内容页不断发生变化。
+
+在程序发出一个虚拟地址给内存管理单元后，内存管理单元首先将地址里面页号部分的字位分离出来，然后判断该虚拟页面是否有效，是否存放在内存，是否受到保护。如果页面无效，即该虚拟页面不存在或没有在内存，也就是说该虚拟页面在物理内存里面没有对应。如果该页面受到保护，即对该页面的访问被禁止，则产生一个系统中断来处理这些特殊情况。对于无效页面访问，需要终止发出该无效访问的进程。对于合法但不在物理内存中的页面，我们通过缺页中断将该虚拟页面放进物理内存。对于受保护的页面，同样终止该进程。
+
+
+
+页表在分页内存管理系统的地位十分关键。页表的根本功能是提供从虚拟页面到物理页面的映射。因此，页表的记录条数与虚拟页面数相同。
+
+内存管理单元依赖页表来进行一切与页面有关的管理活动。这些活动包括判断某一页面号是否在内存里，页面是否受到保护，页面是否非法空间等。因此，页表除了提供虚拟页面到物理页面的映射外，还记录这些相关信息。
+
+
+
+分页系统不会产生外部碎片，一个进程占用的内存空间可以不是连续的，并且一个进程的虚拟页面在不需要的时候可以放在磁盘上。这样，在分页系统下，进程空间的增长和虚拟内存的实现都解决了。除此之外，分页系统的另一个优点是可以共享小的地址，即页面共享。我们只需要在对应给定页面的页表项里做一个相关的记录即可。当然，分页系统也存在缺点。第一个缺点就是页表很大，占用了大量的内存空间。例如，对于32位寻址、页面尺寸为4KB的分页系统来说，页表将有1048576个记录。每个记录又要占用多个字节，这样，一个页表所占的内存空间相当大。那么有没有办法减少页表的尺寸呢？可以选择多级页表的方式。既然一个程序可以分解为一个个页面，并将部分页面存放在磁盘上而降低其内存占用空间，页表也可以采用同样的方式处理，即将页表分为一个个页面，不需要的页面也放在磁盘上。内存里只存放需要的页面。
+
+#### 多级页表
+
+在多级页表结构下，页表根据存放的内容可分为：顶级页表、一级页表、二级页表、三级页表等。顶级页表里面存放的是一级页表的信息，一级页表里面存放的是二级页表的信息，以此类推，到最后一级页表存放的才是虚拟页面到物理页面的映射。一个程序在运行时其顶级页表常驻内存，而次级页表则按需要决定是否存放在物理内存。
+
+例如，如果使用两层页表的话，虚拟地址的前10位可作为顶级页表的索引，中间10位可作为次级页表的索引，最后12位可作为页内偏移值。这样，当CPU发出一个虚拟地址时，我们将虚拟地址一分为三，用最前面10位的值找到顶级页表的对应记录，得到所需要的次级页表。用中间10位的值作为索引在刚才获得次级页表里找到对应的记录，得到对应的物理页面号。然后将物理页面号与页内偏移值链接起来获得最后的物理地址。
+
+多级页表为什么占用的内存空间少呢？因为大部分次级页表会放到磁盘上，而放在内存里面的页表较少。因此，内存占用少。多级页表有什么缺点呢？它降低了系统的速度。因此每次内存访问都变成多次内存访问。对于二级页表，一次内存访问变成了三次内存访问。如果次级页表不在内存，还需要加上一次磁盘访问。这样，系统的速度将大为下降。对于级数更多的页表来说，内存访问速度额下降将更加明显。
+
+
+
+地址翻译因增加了内存访问次数而降低了系统效率。如果只使用单级页表，则每次内存访问变为两次内存访问，速度的下降还尚可以忍受。但如果使用多级页表或反转页表，则每次内存访问将变为多于两次的内存访问，这样效率的下降将非常明显。由于内存访问是每条指令都需要执行的操作，这样将造成整个系统效率的下降。那有没有什么办法改善翻译的速度呢？有。因为程序的运行呈现所谓的时空局域性，即在一段时间内，程序所要访问的地址空间有一定的空间局域性。如果一个页面被访问，则该页面的其他地址可能也将被随后访问。这样，我们可以将该页面的翻译结果存放在缓存里，而无须在访问该页面的每个地址时再翻译一次。这样就可以大大提高系统的执行效率。
+
+这种存放翻译结果的缓存称为翻译快表（Translation Look-Aside Buffer,TLB）。TLB里面存放的是从虚拟页面到物理页面的映射，其记录的格式与内容和正常页表的记录格式与内容一样。这样，在进行地址翻译时，如果TLB里有该虚拟地址记录，即“命中”，就从TLB获得其对应的物理页面号，而无须经过多级页表或反转页表查找，从而大大提高翻译速度。如果TLB里面没有该虚拟页面号，即“未命中”，则需要按正常方式读取页表内容。在TLB未命中的情况下，我们既可以将页表相应记录存入TLB，然后再由TLB来满足地址翻译需求（即重新启动指令），也可以直接由页表来满足翻译请求，同时将翻译结果存入TLB。这两种方式提供的抽象是不一样的。前者提供的抽象是所有翻译皆由TLB完成，而后者提供的抽象则是翻译过程既看到TLB，又看到正常页表。方式的差异将影响模块化的设计思路。
+
+TLB通常由CPU制造商提供，但TLB的更换算法则有可能由操作系统提供。
+
+#### 分页的缺点
+
+分页内存管理它克服了交换系统的所有缺点，但它自己有什么缺点吗？页表太大？这个缺点用多级页表克服了。多级页表速度慢？这个问题用TLB解决了绝大部分。页面来回更换？这个缺点用页面更换算法解决了大部分。固定页面大小呢？这不应该算是一个缺点，因为可变页面大小的操作系统不仅难以选择最优的页面大小，而且会变得很复杂。内部碎片算是一个小小的缺憾，但总比交换系统的外部碎片强，一个进程的内部碎片所浪费的空间平均起来只有半个页面，相对于分页系统的诸多优点来说，这个缺点似乎微不足道。那么分页系统还有其他缺陷吗？有。其中的一个是共享困难。虽然在理论上可以按页进行共享，似乎粒度很细，但实际上这根本就是不现实的。原因是一个页面的内容很可能既包括代码又包括数据，即很难使一个页面只包含需要共享的内容或不需要共享的内容。只要一个页面里面有一行地址是不能共享的，这个页面就不能共享。而一个页面里面存在至少一行不能共享的地址是完全可能的。这样，想自由地共享任何内容几乎就变得不可能了。
+
+如果说上述缺点尚可以容忍，但有一个缺点却是无法容忍的，同时也是分页系统无法解决的。这个缺点就是一个进程只能占有一个虚拟地址空间。在此种限制下，一个程序的大小至多只能和虚拟空间一样大，其所有内容都必须从这个共同的虚拟空间内分配。
+
+
+
+我们来看一个例子：编译器的工作过程。我们知道编译器在工作时需要保持多个数据结构：词法分析树、常数表、代码段、符合表、调用栈。保持多个数据结构本身并无任何问题。问题出在这些数据结构可以独立增长和收缩。即在编译器扫描过程中，这些数据结构里面数据可以增多或减少，从而造成该数据结构所需内存空间的变化。
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/man_page_1.jpg?raw=true)        
+
+
+
+如果编译器只在一个虚拟空间活动，则所有的数据结构或表格均在一个虚拟空间分配，这样就必然发生不同的数据结构占据虚拟空间的不同部分的情况。这样，当一个数据结构空间需要增长时，就会碰到处于其上的其他数据结构而造成无法增长。那么如果某个数据结构无法增长，例如词法树所占空间无法增长，则编译过程将失败。
+
+当然，编译器在工作时会为每个数据结构多分配一些空间来容纳其随后的增长。而且这些空间的大小都经过经验数据测试，可以应对大多数情况下数据结构增长的需要。但是，谁也不能保障不会碰到一个很大的程序，以致某个数据结构的增长空间不够的情况。例如，如果一个程序里定义的变量奇多无比，则符号表所占的空间将大幅增加。
+
+那么怎么解决这个问题呢？记住，这里的碰撞可是在虚拟空间中的碰撞，而不是物理空间的碰撞。解决的办法自然是增加虚拟空间的容量。但是虚拟空间的大小受寻址宽度的限制而无法增长。剩下的办法就只能让一个程序使用多个虚拟空间！由于分页系统只使用一个虚拟地址空间，自然解决不了这个问题。那么要解决这个问题显然需要一种新的内存管理模式。这种新的模式就是分段管理系统。
+
 ### 分段
 
-细分用户程序的另一种可选方案是分段。采用分段技术，可以把用户进程地址空间按程序的自身的逻辑关系和与其相关的数据划分到几个段（fragment）中。尽管段有最大长度限制，但并不要求所有程序的所有段的长度都相等。同样内存空间也会被动态的划分为若干长度不相同的取悦，称为物理段，每个物理段由起始地址和长度确定。和分页一样，采用分段技术时的逻辑地址也是由两部分组成：段号和偏移量。 以段为单位进行分配，每段在内存中占据连续空间，但各段之间可以不相邻。
+分段管理就是将一个程序按照逻辑单元分成多个程序段，每一个段使用自己单独的虚地址空间。例如，对于编译器来说，我们可以给其5个段，占用5个虚地址空间。
+
+这样，一个段占用一个虚地址空间，就不会再发生空间增长时碰撞到另一个段的问题。从而避免因空间不够而造成编译失败的情况。如果某个数据结构对空间的需求超过整个虚地址能够提供的空间，则编译仍将失败。不过出现这种可能的概率恐怕不会比太阳从西边出来的概率高出多少。
+
+一个程序占据多个虚拟地址空间，那么不同的段有可能有同样的虚拟地址空间。如果要区分一个虚拟地址所在的段，我们必须在虚拟地址前面冠以一个前缀，即该地址所在的段号。也就是说，在分段情况下，一个虚拟地址将由段号和段内偏差两个部分构成，
+
+
+
+采用分段技术，可以把用户进程地址空间按程序的自身的逻辑关系和与其相关的数据划分到几个段（fragment）中。尽管段有最大长度限制，但并不要求所有程序的所有段的长度都相等。同样内存空间也会被动态的划分为若干长度不相同的取悦，称为物理段，每个物理段由起始地址和长度确定。和分页一样，采用分段技术时的逻辑地址也是由两部分组成：段号和偏移量。 以段为单位进行分配，每段在内存中占据连续空间，但各段之间可以不相邻。
 
 由于使用大小不等的段，分段类似于动态分区。在未采用覆盖方案或使用虚存的情况下，为执行一个程序，需要把它的所有段都装入内存。与动态分区不同的是，在分段方案中，一个程序可以占据多个分区，并且这些分区不要求是连续的。分段消除了内部碎片，但是和动态分区一样，他会产生外部碎片。不过由于进程被分成多个小块，因此外部碎片也会很小。
 
@@ -183,11 +263,19 @@ Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自
 
 ![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/page_vs_fragment.png?raw=true)
 
+#### 分段的优缺点
 
+逻辑分段的优点十分明显。首先，每个逻辑单元可单独占一个虚拟地址空间，这样使得编写程序的空间大为增长，几乎可以编写出没有尺寸限制的程序来。其次，由于段是按逻辑关系而分，共享起来就非常方便。不会出现分页系统下一个页面里面可能同时包含数据和代码而造成共享不便的问题。由于不同的逻辑段使用不同的基址与极限对，我们可以对不同的段采用不同的保护措施。最后，对于空间稀疏的程序来说，分段管理将节省大量的空间。因为空余的部分不用分配任何虚拟空间；而在分页下，空余的空间仍然需要分配虚拟页面，只不过该页面非法而已。而在上下文切换时要更换的内容很简单：段表。因为段表很小，这种切换非常容易。
+
+分段管理的缺点也十分明显。既然是分段，就存在前面基本内存管理时介绍过的缺点：外部碎片和一个段必须全部加载到内存。一般来说，一个程序的所有逻辑段是同时需要的。如果实行分段管理，则由于每个段必须全部加载到内存，这就造成了我们在基本内存管理时已经遇到过的一个问题：一个程序必须同时全部加载到内存才能执行。当然，解决这个问题可以使用重叠（overlay）。但我们已经尝过分页系统好处后再使用overlay显然有“优汰劣胜”的味道。
+
+那么我们的解决办法是什么呢？分页。但这次的分页不是前面的直接对程序进程分页，而是对程序里面的段进行分页。这就形成了所谓的段页式内存管理模式。这种段内分页是前面讲过的页式内存管理的否定之否定。
 
 ### 段页式存储管理方案
 
-综合页式、段式方案的优点，客服两者的缺点。用户进程先按段划分，每一段再按页面划分。内存分配还是以页为单位进行分配。
+段页式管理就是将程序分为多个逻辑段，在每个段里面又进行分页，即将分段和分页组合起来使用。这样做的目的就是想同时获得分段和分页的好处，但又避免了单独分段或单独分页的缺陷。如果我们将每个段看做一个单独的程序，则逻辑分段就相当于同时加载多个程序。
+
+综合页式、段式方案的优点，克服两者的缺点。用户进程先按段划分，每一段再按页面划分。内存分配还是以页为单位进行分配。
 
 
 
@@ -207,6 +295,10 @@ Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自
 
 虚拟内存机制使得期望运行大于物理内存的程序成为可能。其方法是将程序放在磁盘上，而将主存作为一种缓存，用来保存最频繁使用的部分程序。这种机制需要快速的映像内存地址，以便把程序生成的地址转换为有关字节在RAM中的物理地址。这种映像由CPU中的一个称为存储器管理单元（Memory Management Unit，MMU）的部件来完成。
 
+虚拟内存的中心思想是将物理主存扩大到便宜、大容量的磁盘上，即将磁盘空间看做主存空间的一部分。用户程序存放在磁盘上就相当于存放在主存内。用户程序既可以完全存放在主存，也可以完全存放在磁盘上，当然也可以部分存放在主存、部分存放在磁盘。而在程序执行时，程序发出的地址到底是在主存还是在磁盘则由操作系统的内存管理模块负责判断，并到相应的地方进行读写操作。事实上，我们可以更进一步，将缓存和磁带也包括进来，构成一个效率、价格、容量错落有致的存储架构。即虚拟内存要提供的就是一个空间像磁盘那样大、速度像缓存那样高的主存储系统
+
+
+
 **虚拟内存**的**基本思想**是:每个程序都拥有自己的地址空间,这个空间被分割成多个块,每个块被成为一页或页面.
 
 **程序运行时,并不是所有页都在物理内存中**:
@@ -252,7 +344,7 @@ Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自
 
 #### 3. 置换策略
 
-以便处理在必须读取一个新页时，应该置换内存中的哪一页。当内存中的所有页框都被占据，且需要读取一个新页以处理一次缺页中断时，置换策略决定置换当前内存中的哪一页。所有策略的目标都是移出最近最不能访问的页。
+如果访问的页面不在内存中，则系统将产生缺页中断。缺页中断服务程序将负责把位于磁盘上的数据加载到物理内存来。如果物理内存还有空闲页面，那就直接使用空闲的页面。但如果物理内存已满，则需要挑选某个已经使用过的页面进行替换。那么挑选哪个页面合适呢？当内存中的所有页框都被占据，且需要读取一个新页以处理一次缺页中断时，置换策略决定置换当前内存中的哪一页。所有策略的目标都是移出最近最不能访问的页。
 
 - `最优算法`在当前页面中置换最后要访问的页面。不幸的是，没有办法来判定哪个页面是最后一个要访问的，`因此实际上该算法不能使用`。然而，它可以作为衡量其他算法的标准。
 - `NRU` 算法根据 R 位和 M 位的状态将页面氛围四类。从编号最小的类别中随机选择一个页面。NRU 算法易于实现，但是性能不是很好。存在更好的算法。
@@ -266,6 +358,12 @@ Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自
 
 总之，**「最好的算法是老化算法和WSClock算法」**。他们分别是基于 LRU 和工作集算法。他们都具有良好的性能并且能够被有效的实现。还存在其他一些好的算法，但实际上这两个可能是最重要的。
 
+##### 内存抖动
+
+在更换页面时，如果更换的页面是一个很快就会被再次访问的页面，则在此次缺页中断后很快又会发生新的缺页中断。在最坏情况下，每次新的访问都是对一个不在内存的页面进行访问，即每次内存访问都产生一次缺页中断，这样每次内存访问皆变成一次磁盘访问，而由于磁盘访问速度比内存可以慢一百万倍，因此整个系统的效率急剧下降。这种现象就称为内存抖动，或者抽打、抽筋（tras-hing）。
+
+
+
 #### 4. 驻留集管理
 
 对于分页式虚拟内存，在准备执行时，不需要也不可能把一个进程的所有页都读入内存。因此，操作系统必须决定读取多少页，即决定给特定的进程分配多大的内存空间。
diff --git a/OperatingSystem/5.I:O.md b/OperatingSystem/5.I:O.md
index 87a8fe44..8b52065c 100644
--- a/OperatingSystem/5.I:O.md
+++ b/OperatingSystem/5.I:O.md
@@ -1,5 +1,7 @@
 # 5.I/O
 
+输入输出的目的，简单来说，就是提供一个人机交互的通道，使得人与计算机能够进行沟通。
+
 
 
 计算机系统中参与I/O的外设大体上可分为如下三类： 
@@ -26,8 +28,10 @@
     - 读或写的字数，也通过数据线传送，并由DMA模块保存在其数据计数寄存器中
 
     然后处理器继续执行其他工作，此时它已把这个I/O操作委托给DMA模块。DMA模块直接从存储器中或向存储器中逐字传送整块数据，并且数据不再需要通过处理器。传送结束后，DMA模块给处理器发送一个中断信号。因此，只有在传送开始和结束时才会用到处理器。
-
-
+    
+    由于DMA需要使用内存总线，而CPU也需要使用内存总线，这样将形成内存总线竞争。那么DMA使用总线的模式将依赖于CPU使用内存的模式。根据这些模式的不同，我们可以选择周期盗用（cycle stealing）或者爆发模式（burst mode）。由于DMA传输的数据量通常较大，数据存放何处就是一个需要考虑的因素。我们既可以将数据直接存入内存，也可以存入DMA缓冲区，然后通过中断让CPU一次性将DMA缓冲区的数据拷入内存。另外一个考虑因素就是如何寻址内存。是使用虚拟地址还是物理地址？使用物理地址的好处是速度快，缺点是绕过MMU存在安全和可靠性风险。
+    
+    DMA模式的优缺点优点就是将主CPU从I/O中解脱出来。而缺点自然是增加了成本和复杂性。而且，由于DMA需要与CPU竞争内存总线，其效率的提高不如理论上的期望。因此，并不是任何I/O都应该使用DMA。
 
 ## I/O进程
 
diff --git "a/OperatingSystem/6.\346\226\207\344\273\266\347\256\241\347\220\206.md" "b/OperatingSystem/6.\346\226\207\344\273\266\347\256\241\347\220\206.md"
index e6908122..865318cd 100644
--- "a/OperatingSystem/6.\346\226\207\344\273\266\347\256\241\347\220\206.md"
+++ "b/OperatingSystem/6.\346\226\207\344\273\266\347\256\241\347\220\206.md"
@@ -1,12 +1,12 @@
 # 6.文件管理
 
-文件是对磁盘的抽象。
+操作系统为磁盘提供的抽象就是：文件及文件系统，或者说，文件系统就是磁盘的抽象。
 
-所谓未见是指一组带标识（标识即为文件名）的、在逻辑上有完整意义的信息项的序列。
+文件系统是操作系统提供的另一个抽象。它是一个子虚乌有的东西，看不见、摸不着，但却可以使用的介于磁盘与用户之间的界面。
 
 文件管理系统是一组系统软件，它为使用文件的用户和应用程序提供服务，包括文件访问、目录维护和访问控制。文件管理系统通常被视为一个由操作系统提供服务的系统服务，而不是操作系统的一部分，但是在任何系统中，至少有一部分文件管理功能是由操作系统执行的。
 
-
+简单地说，文件系统将其接触的磁盘物理特性转换为用户看到的路径名和文件名。用户对磁盘进行访问只需要给出文件名和路径名即可，而无须知道磁柱、磁道、扇面、数据块等信息。
 
 文件系统不但提供存储数据（组织为文件）的手段，而且提供一系列对文件进行操作的功能接口。典型的操作如下：
 
@@ -17,6 +17,8 @@
 - 读
 - 写
 
+与内存管理系统类似，文件系统也需要达到两个目的：地址独立和地址保护。地址独立就是一个文件在产生的时候无须担心其存放的磁盘地址，即文件数据的产生与文件将来存放的磁盘地址相互独立。而地址保护则需要对文件的访问进行一定的限制，即不是任何人都可以访问任何文件的。注意，这里的保护与内存地址保护是有区别的。内存管理下地址保护指的是一个进程不能访问另一个进程空间，而这里的保护不是一个文件不能访问另一个文件空间，而是一个文件的访问是有限制的。
+
 
 
 ### 文件系统架构
@@ -34,6 +36,44 @@
 
 
 
+### 地址独立的实现机制：文件夹
+
+给一个文件名，操作系统是怎么知道从什么地方读取文件的内容呢？或者说，文件在磁盘上的什么位置，操作系统是如何知道的呢？这当然需要一个数据结构来记录每个文件在磁盘上的地址，这个数据结构就是文件夹。
+
+文件夹也称为目录夹（folder），它保存的不是用户数据，而是关于文件及文件系统的信息。简单地说，文件夹的角色就是跟踪文件，里面存放的是从文件到文件在磁盘的地址的映射，即“文件名→文件在磁盘上的地址”。文件夹对于文件来说，就相当于动态地址翻译对于虚拟地址的作用，即从虚拟地址到实际地址的一种翻译机制。
+
+这样，当给予一个文件名时，我们从文件夹里可以找到该文件所在的位置，从而发出正确的读取命令。那么文件在磁盘上的地址是什么呢？这就要看文件在磁盘上是如何存放了。如果文件在磁盘上是连续存放的，即一个文件占用一片连续的磁盘空间，则文件在磁盘上的地址就是该文件的第一块数据块所在的磁盘扇面号。当然，文件的存放不只有连续存放一种模式，因此文件在磁盘上的地址还有别的形式，我们稍后解释。但总的一点就是，文件夹应该提供一种找出一个文件所有磁盘块的方法。
+
+既然文件夹存放的是文件名到磁盘地址的映射，那么自然地我们可以以一个简单数组来实现。这个数组是以文本文件存放的，你可以自己写一个程序打开这个文件就可以看到里面的内容。而读取文件夹的内容就变成读取这个简单数组的内容。而这正是shell utility"ls"（UNIX、Linux、Windows Power Shell）和"dir"（Windows）所做的事情。这里很重要的一点是文件夹本身也是文件。因此，我们可以像对待文件一样对待文件夹：使用同样的存储结构来存放文件夹的数据；文件夹里面的每个记录本身又可以是文件夹。
+
+
+
+由于文件夹里面又可以有文件夹，这样就形成了一个层次结构。这个层次结构的顶端就是根文件夹，也称为根目录，根目录是一个文件系统的总起点，它在操作系统启动的时候加载到内存。从根目录开始，该文件系统里面的所有文件都可以找出来。由于根目录是整个文件系统的源点，如果根目录损坏，则整个文件系统都无法访问，也就说文件系统已经崩溃。
+
+假定我们要找的文件是：/zou/cs307/file.pdf。这个文件名最前面的“/”代表的就是根目录。因此，我们首先从根目录开始寻找。根目录里面可能保护许多文件和文件夹，其中的一个文件夹就是zou，而根目录里面存放有zou文件夹所在的磁盘地址。我们获得的磁盘地址读取zou的内容（一个文本数组），将其打开。我们发现，打开的zou文件夹里又包括另一个文件夹cs307及其在磁盘上的位置。我们从给出的磁盘位置上读取文件夹cs307的内容（另一个文本数组），发现里面包括一个文件名为file.pdf的文件及其对应的磁盘地址。我们从给出的磁盘地址上就可以读取文件file.pdf的内容。这样从根目录开始，我们需要访问磁盘3次才能得到文件file.pdf的内容。
+
+
+
+### 相对路径和绝对路径
+
+文件名"zou/cs307/file.pdf"包括从根目录开始的一个完全路径，因此称为绝对路径。绝对路径是从根目录的视角看一个文件的访问路径。与此相对的是相对路径，即从某个工作目录，如用户当前所处的目录的角度看某一个文件的访问路径。例如，如果我们目前已经在目录"zou/cs307/"下，则只需要给出文件名file.pdf即可访问该文件。使用相对路径的好处是没有必要寻遍整个目录夹，可以节省磁盘访问次数，从而提高文件访问效率。前面讲过，从根目录开始需要3次磁盘访问才能得到文件file.pdf的内容；但如果在工作目录"zou/cs307/"下直接给出文件名file.pdf，则只需要进行一次磁盘访问即可。因为当前目录的内容是已经打开的，即已经加载到内存的，我们无须磁盘访问即可查看当前目录内容，发现file.pdf的文件及其对应的磁盘地址。我们只需要按照该地址对磁盘进行一个访问即可获得file.pdf的内容。
+
+但需要注意的是，相对路径不一定总是比绝对路径节省磁盘访问次数。如果你要访问的文件是当前这个目录的“直系后代”，则将节省磁盘访问次数；否则，即如果不是“直系后代”，你就可能多花费时间。例如，在图16-7的目录树里面，如果当前目录是“目录夹1”，则使用相对路径访问“文件1”将节省磁盘访问次数，而访问“文件2”则比绝对路径更费时间。这一点我们从相对“文件2”的相对路径和绝对路径名就可以看出：文件2的相对路径名：“../目录2/文件2”。文件2的绝对路径名：“/目录2/文件2”。
+
+
+
+文件拷贝程序的工作原理很简单：打开源文件和目标文件，循环往复地将源文件的内容读到一个缓冲区，然后将缓冲区的内容写到输出目标文件里。当拷贝结束后，关闭源文件和目标文件。上述程序中使用的文件系统调用包括fin.open、fout.open、fout＜＜、fin.get等。这里需要注意的是，输入文件的打开模式为只读，而输出文件的打开模式是只有创立这个文件的人才能读写，其他人均无访问权限（输出模式0700代表的就是这个意思）。那么上述程序有一个问题，不知读者是否看出？在正确性方面没有问题，但在效率上却不太令人满意。这是因为该程序的系统调用次数太多，而系统调用需要陷入到内核。另外，每次系统调用都需要进行磁盘操作，而磁盘操作的效率远远低于内存操作的效率。解决这个问题的办法是可以将缓冲区变大，从而降低系统调用和磁盘访问的次数。但缓冲区越大，需要的内存就越大，将造成程序的可执行性下降。而且，就算缓冲区很大，文件还可以更大，还是不能从根本上解决效率低的问题。那有没有其他办法解决效率低下的问题呢？当然有，就是不使用系统调用。而是采用我们下面将要讲述的内存映射的文件访问。
+
+
+
+### 内存映射的文件访问
+
+解决读写文件效率低的中心思想就是把磁盘访问变成内存访问。实现这种访问转变的手段就是内存映射的文件访问。内存映射的文件访问原理很简单：把需要访问的文件映射到一个进程的虚拟地址内。这样，访问该虚拟地址就相当于访问文件。这样文件访问就变成内存访问。例如，假定我们将一个32KB大小的test文件映射一个进程的虚地址1024KB处。那么读写1024KB的地址就是读写test这个文件的第一个字节。而当该进程中止的时候，与文件对应的这个内存内容将被冲洗（flush）到磁盘上。
+
+这样做的好处就是磁盘访问变成了内存访问，效率自然提高。例如，还是我们前面的文件拷贝，这次不用文件系统调用来实现，而是使用内存映射的文件访问来实现。例如，我们可以将文件a和b均映射到同一个进程的不同虚拟地址上。这样读a文件对应的虚地址将把a的内容从磁盘上拷贝到内存，再把内容写到b对应的虚地址上即可。不过需要提醒的是，内存映射的文件访问不是为了文件拷贝而提出的，而是为了文件的共享。具体来说，我们可以将同一个文件映射到两个或多个进程的虚地址空间。这样每个进程对相应的虚地址空间进行访问时就是对同一个文件进行访问。
+
+
+
 
 
 ## Android文件系统
@@ -62,6 +102,14 @@ Android文件系统目录的顶层部分：
 
 当计算机开始引 boot 时，BIOS 读入并执行 MBR。
 
+
+
+一个磁盘包括一个个扇面，编号从0递增，整数计数。第0个扇面在整个文件系统中占有重要意义。该扇面存放的是主引导记录（Master Boot Record,MBR）。该记录的内容是一个小小的程序，用来启动计算机。如果该扇面损坏，则整个磁盘就无法使用。这时唯一的办法就是将磁盘拿到硬件制造商那里对磁盘扇面重新编号。在MBR后面紧接着的是磁盘分区表。磁盘分区表里给出的是磁盘的所有分区及其开始和终结地址，其中一个分区为主分区。操作系统就装载在这个分区中。主分区里面最前面的是引导记录（Boot Record）。在计算机启动时，处于主板ROM里面的BIOS程序首先运行。BIOS在进行一些基本的系统配置扫描后对磁盘的扇面0进行读操作，将MBR里面的程序读到内存并运行。MBR程序接下来找到系统主分区，并将主分区里面的Boot Record加载并运行。Boot Record里面的内容是一个小程序，该程序将负责找到操作系统映像，并加载到内存，从而启动操作系统。所有的文件系统都必须按照这种格式存放，操作系统才能正常启动。
+
+在Boot Record记录块后面的内容就因情况而异了。一般来说，在该记录块后面的磁盘内容布局因文件系统的不同可以不同。但在通常情况下，紧接着引导记录后面的是一个超级数据块（Super Block），该块里面存放的是关于该文件系统的各种参数，如文件系统类型、文件系统数据块尺寸等。在Super Block后面则是磁盘的自由空间，其后面是I-NODE区，再后面是文件系统根目录区。分区的最后存放的是用户文件和文件夹区。
+
+
+
 #### 引导块
 
 MBR 做的第一件事就是`确定活动分区`，读入它的第一个块，称为`引导块(boot block)` 并执行。引导块中的程序将加载分区中的操作系统。为了一致性，每个分区都会从引导块开始，即使引导块不包含操作系统。引导块占据文件系统的前 4096 个字节，从磁盘上的字节偏移量 0 开始。引导块可用于启动操作系统。

From 78ad164fc6e7215853a7885929b0006aa5e8d4f6 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Tue, 13 Apr 2021 14:56:07 +0800
Subject: [PATCH 055/213] add os notes

---
 ...73\347\273\237\347\256\200\344\273\213.md" | 44 ++++++++++++-----
 ...13\344\270\216\347\272\277\347\250\213.md" |  2 +
 ...07\344\273\266\347\256\241\347\220\206.md" |  6 +++
 ...8.\350\231\232\346\213\237\346\234\272.md" | 48 +++++++++++++++++++
 4 files changed, 89 insertions(+), 11 deletions(-)

diff --git "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md" "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
index 3f638f3a..462ffb2e 100644
--- "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
+++ "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
@@ -2,8 +2,6 @@
 
 # 1.操作系统简介
 
-
-
 操作系统(Operating System, 简称OS)是管理和控制计算机硬件与软件资源的计算机程序，是一种由引导程序（bootloader）启动并管理计算机中所有程序生命周期的系统程序。任何其他软件都必须在操作系统的支持下才能运行，操作系统能有效组织和管理系统中的各种软、硬件资源，合理组织计算机系统的工作流程并控制程序的执行，为用户提供一个良好的操作环境。 目前比较为人所知的操作系统有Microsoft的Windows系统、Apple的Mac及以Linux为内核的各种Linux发行版(Centos/Ubuntu等)。 现代计算机系统由一个或多个处理器、主存、打印机、键盘、鼠标、显示器、网络接口及各种输入\输出设备构成。
 
 作用:    它可以帮我们管理计算机的各种资源，协助我们完成各种复杂繁琐的任务。
@@ -95,7 +93,9 @@
 
 ### 计算机硬件
 
-从概念上讲，计算机的结构非常简单：首先布置一根总线，然后将各种硬件设备挂在总线上。所有的这些设备都有一个控制设备，外部设备都由这些控制器与CPU通信。而所有设备之间的通信均需通过总线： 
+计算机的硬件由大量的IC （Integrated Circuit，集成电路）组成。每块IC上都带有许多引脚。这些引脚有的用于输入，有的用于输出。
+
+从概念上讲，计算机的结构非常简单：首先布置一根总线，然后将各种硬件设备挂在总线上。所有的这些设备都有一个控制设备，外部设备都由这些控制器与CPU通信。而所有设备之间的通信均需通过总线，如果对总线做一个简单的概括，可以认为总线就是数字信号的集合，而这些信号被提供给计算机上的每块电路板： 
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/computer_hardware.jpg?raw=true)        
 
@@ -236,6 +236,10 @@ CPU(中央处理器)是计算机的大脑，它主要和内存进行交互，从
 
 
 
+为了驱动CPU运转，称为“时钟信号”的电信号必不可少。这种电信号就好像带有一个时钟，滴答滴答地每隔一定时间就变换一次电压的高低。输出时钟信号的元件叫作“时钟发生器”。时钟发生器中带有晶振，根据其自身的频率（振动的次数）产生时钟信号。时钟信号的频率可以衡量CPU的运转速度。这里使用的是2.5MHz（兆赫兹）的时钟发生器。最大时钟频率(maximum clock speed)，也称主频，是影响处理器速度的决定性因素之一。时钟频率决定了执行一条指令所需要的时间，处理器的数据位宽也影响处理器的速度。
+
+
+
 CPU 主要由两部分构成：`控制单元` 和 `算术逻辑单元（ALU）`
 
 - 控制单元：从内存中提取指令并解码执行
@@ -256,18 +260,20 @@ CPU 的内部由**寄存器、控制器、运算器和时钟**四部分组成，
 
 使用高级语言编写的程序会在编译后转化成机器语言，然后通过CPU内部的寄存器来处理。不同类型的CPU，其内部寄存器的数量，种类以及寄存器存储的数值范围都是不同的。根据功能的不同，我们可以将寄存器大致划分为八类: 
 
-- ***累加寄存器简称累加器(Accumulator， AC)***：是一个通用寄存器。存储临时的执行运算的数据和运算后的数据。
-- ***标志寄存器***：存储运算处理后的CPU的状态。
+- ***累加寄存器简称累加器(Accumulator Register， AC)***：是一个通用寄存器。存储执行运算的数据和运算后的数据。
+- ***标志寄存器(Flag Register)***：存储运算处理后的CPU的状态。
 - ***程序计数器(Program Counter, PC)***：记录将要取出的指令的地址。存储下一条指令所在内存的地址。
-- ***基址寄存器***：存储数据内存的起始地址。
-- ***变址寄存器***：存储基址寄存器的相对地址。
-- ***通用寄存器***：存储任意数据。
-- ***指令寄存器(Instruction Register, IR)***：记录最近取出的指令。存储指令，CPU取到的指令存放在处理器的一个寄存器中，这个寄存器就是指令寄存器。CPU内部使用，程序员无法通过程序对该寄存器进行读写操作。
-- ***堆栈寄存器(stack pointer)***：目的是跟踪调用堆栈，存储栈区域的起始地址。指向内存中当前栈的顶端。堆栈指针会包含输入过程中的有关参数、局部变量以及没有保存在寄存器中的临时变量。
+- ***基址寄存器(Base Register)***：存储数据内存的起始地址。
+- ***变址寄存器(Index Register)***：存储基址寄存器的相对地址。
+- ***通用寄存器(General Purpose Register)***：存储任意数据。
+- ***指令寄存器(Instruction Register, IR)***：存储指令，CPU取到的指令存放在处理器的一个寄存器中，这个寄存器就是指令寄存器。CPU内部使用，程序员无法通过程序对该寄存器进行读写操作。
+- ***堆栈寄存器(Stack Register)***：目的是跟踪调用堆栈，存储栈区域的起始地址。指向内存中当前栈的顶端。堆栈指针会包含输入过程中的有关参数、局部变量以及没有保存在寄存器中的临时变量。
 - **程序状态字寄存器(PSW(Program Status Word))**：这个寄存器是由操作系统维护的8个字节(64位) long 类型的数据集合。它会跟踪当前系统的状态。除非发生系统结束，否则我们可以忽略 PSW 。用户程序通常可以读取整个PSW，但通常只能写入其某些字段。PSW 在系统调用和 I / O 中起着重要作用。
 
 其中，程序计数器，累加寄存器，标志寄存器，指令寄存器和栈寄存器都只有一个，其他的寄存器一般有多个。
 
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/cpu.jpg?raw=true)        
+
 
 
 ### 计算机执行的原理是: 取指执行
@@ -497,7 +503,23 @@ CPU 的内部由**寄存器、控制器、运算器和时钟**四部分组成，
 
 ## 内存
 
-内存就是一个字节数组。要读取(read)内存，必须制定一个地址(address)，才能访问存储在那里的数据。要写入(write)或更新(update)内存，还必须制定要写入给定地址的数据。
+通常所说的内存指的是计算机的主存储器（mainmemory）简称主存。主存通过控制芯片等与CPU相连，主要负责存储指令和数据。主存由可读写的元素构成，每个字节（1字节=8位）都带有一个地址编号。CPU可以通过该地址读取主存中的指令和数据，当然也可以写入数据。
+
+
+
+内存实际上是一种名为内存IC的电子元件。虽然内存IC包括DRAM、SRAM、ROM[插图]等多种形式，但从外部来看，其基本机制都是一样的。内存IC中有电源、地址信号、数据信号、控制信号等用于输入输出的大量引脚（IC的引脚），通过为其指定地址（address），来进行数据的读写。
+
+下内存IC（在这里假设它为RAM）的引脚配置示例。虽然这是一个虚拟的内存IC，但它的引脚和实际的内存IC是一样的。VCC和GND是电源，A0～A9是地址信号的引脚，D0～D7是数据信号的引脚，RD和WR是控制信号的引脚(读取或写入)。将电源连接到VCC和GND后，就可以给其他引脚传递比如0或者1这样的信号。大多数情况下，+ 5V的直流电压表示1,0V表示0。
+
+![内存IC的引脚配置示例](https://raw.githubusercontent.com/CharonChui/Pictures/master/ram.jpg?raw=true)        
+
+那么，这个内存IC中能存储多少数据呢？数据信号引脚有D0～D7共八个，表示一次可以输入输出8位（=1字节）的数据。此外，地址信号引脚有A0～A9共十个，表示可以指定0000000000～1111111111共1024个地址。而地址用来表示数据的存储场所，因此我们可以得出这个内存IC中可以存储1024个1字节的数据。因为1024=1K[插图]，所以该内存IC的容量就是1KB。
+
+虽然内存的实体是内存IC，不过从程序员的角度来看，也可以把它假想成每层都存储着数据的楼房，并不需要过多地关注内存IC的电源和控制信号等。
+
+![1KB内存的模型](https://raw.githubusercontent.com/CharonChui/Pictures/master/1kb_memory.jpg?raw=true)        
+
+
 
 内存包括主存(内存条,基于DRAM(动态RAM))与高速缓存(Cache,基于SRAM(静态RAM，静态RAM速度很快但是成本很高，所以用于在CPU内部充当缓冲))两部分。可能是由于Cache相较内存条容量很小，毕竟内存容量只计内存条大小，加上重要性也不及内存条，一般人或许不知道Cache,所以就忽略了高速缓存Cache，直接将主存--内存条等同了内存吧。计算器内存条采用的是DRAM(动态随机存储器)，即计算机的主存。通常所说的内存容量即指内存条DRAM的大小。
 
diff --git "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md" "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
index 862fe261..4cba483b 100644
--- "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
+++ "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
@@ -18,6 +18,8 @@
 
 ## 进程概念
 
+程序是指令和数据的集合。
+
 狭义定义：进程是正在运行的程序的实例（an instance of a computer program that is being executed）。
 
 广义定义：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是[操作系统](https://baike.baidu.com/item/操作系统/192)动态执行的[基本单元](https://baike.baidu.com/item/基本单元)，在传统的[操作系统](https://baike.baidu.com/item/操作系统)中，进程既是基本的[分配单元](https://baike.baidu.com/item/分配单元)，也是基本的执行单元。
diff --git "a/OperatingSystem/6.\346\226\207\344\273\266\347\256\241\347\220\206.md" "b/OperatingSystem/6.\346\226\207\344\273\266\347\256\241\347\220\206.md"
index 865318cd..c39742af 100644
--- "a/OperatingSystem/6.\346\226\207\344\273\266\347\256\241\347\220\206.md"
+++ "b/OperatingSystem/6.\346\226\207\344\273\266\347\256\241\347\220\206.md"
@@ -34,7 +34,13 @@
 - 基本I/O管理程序(basic I/O supervisor)；负责所有文件I/O的初始化和终止。在这一层，需要一定的控制结构来维护设备的输入/输出、调度和文件状态。基本I/O管理程序是操作系统的一部分。
 - 逻辑I/O（logical I/O）使用户和应用程序能够访问记录。因此基本文件系统处理的是数据块，而逻辑I/O模块处理的是文件记录。逻辑I/O提供一种通用的记录I/O的能。
 
+### 文件
 
+文件是将数据存储在磁盘等存储媒介中的一种形式。文件是字节数据的集合体。程序文件中存储数据的单位是字节。文件的大小之所以用××KB、××MB等来表示，就是因为文件是以字节（B=Byte）为单位来存储的。
+
+文件就是字节数据的集合。用1字节（=8位）表示的字节数据有256种，用二进制数来表示的话，其范围就是00000000～11111111。如果文件中存储的数据是文字，那么该文件就是文本文件。如果是图形，那么该文件就是图像文件。在任何情况下，文件中的字节数据都是连续存储的。
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/file_data.jpg?raw=true)        
 
 ### 地址独立的实现机制：文件夹
 
diff --git "a/OperatingSystem/8.\350\231\232\346\213\237\346\234\272.md" "b/OperatingSystem/8.\350\231\232\346\213\237\346\234\272.md"
index ea7fd949..e8ba0cbf 100644
--- "a/OperatingSystem/8.\350\231\232\346\213\237\346\234\272.md"
+++ "b/OperatingSystem/8.\350\231\232\346\213\237\346\234\272.md"
@@ -81,6 +81,54 @@ DVM运行Java语言的应用和代码。标准的Java编译器将源代码（写
 
     以上命令首先将jar包push到/data/app目录下，因为该目录一般用于存放应用程序，接着使用adb shell执行dalvikvm程序。dalvikvm的执行语法是: dalvikvm -cp 类路径 类名，从这里可以感觉到，dalvikvm的作用就像在pc上执行java程序一样。
 
+## 程序是如何执行的
+
+计算机只能运行本地代码。本地（native）这个术语有“母语的”意思。对CPU来说，母语就是机器语言，而转换成机器语言的程序就是本地代码。用任何编程语言编写的源代码，最后都要翻译成本地代码，否则CPU就不能理解。也就是说，即使是用不同编程语言编写的代码，转换成本地代码后，也都变成用同一种语言（机器语言）来表示了。
+
+#### 编译：编译器负责转换源代码
+
+能够把C语言等高级编程语言编写的源代码转换成本地代码的程序称为编译器。每个编写源代码的编程语言都需要其专用的编译器。将C语言编写的源代码转换成本地代码的编译器称为C编译器。
+
+编译器首先读入代码的内容，然后再把源代码转换成本地代码。编译器中就好像有一个源代码同本地代码的对应表。但实际上，仅仅靠对应表是无法生成本地代码的。读入的源代码还要经过语法解析、句法解析、语义解析等，才能生成本地代码。
+
+根据CPU类型的不同，本地代码的类型也不同。因而，编译器不仅和编程语言的种类有关，和CPU的类型也是相关的。例如，Pentium等x86系列CPU用的C编译器，同PowerPC这种CPU用的C编译器就不同。从另一个方面来看，这其实是非常方便的。因为这样一来，同样的源代码就可以翻译成适用于不同CPU的本地代码了。
+
+但是仅靠编译是无法得到可执行文件的。
+
+#### 链接
+
+编译器转换源代码后，就会生成一个个的本地文件。不过，本地文件是无法直接运行的。为了得到可以运行的EXE文件，编译之后还需要进行“链接”处理。
+
+把多个目标文件结合，生成1个EXE文件的处理就是链接，运行连接的程序就称为链接器（linkage editor或连结器）。
+
+
+
+![Windows下的编译和链接机制](https://raw.githubusercontent.com/CharonChui/Pictures/master/windows_compile_link.jpg?raw=true)        
+
+
+
+在了解了通过程序的编译及链接来生成EXE文件的机制后，接下来看一下EXE文件的运行机制。EXE文件是作为单独的文件储存在硬盘中的。通过资源管理器找到并双击EXE文件，就会把EXE文件的内容加载到内存中运行。
+
+请大家思考一下下面的问题。本地代码在对程序中记述的变量进行读写时，是参照数据存储的内存地址来运行命令的。在调用函数时，程序的处理流程就会跳转到存储着函数处理内容的内存地址上。EXE文件作为本地代码的程序，并没有指定变量及函数的实际内存地址。在类似于Windows操作系统这样的可以加载多个可执行程序的运行环境中，每次运行时，程序内的变量及函数被分配到的内存地址都是不同的。那么，在EXE文件中，变量和函数的内存地址的值，是如何来表示的呢？
+
+下面就让我们来揭晓答案。那就是EXE文件中给变量及函数分配了虚拟的内存地址。在程序运行时，虚拟的内存地址会转换成实际的内存地址。链接器会在EXE文件的开头，追加转换内存地址所需的必要信息。这个信息称为再配置信息。
+
+
+
+EXE文件的再配置信息，就成为了变量和函数的相对地址。相对地址表示的是相对于基点地址的偏移量，也就是相对距离。实现相对地址，也是需要花费一番心思的。在源代码中，虽然变量及函数是在不同位置分散记述的，但在链接后的EXE文件中，变量及函数就会变成一个连续排列的组。这样一来，各变量的内存地址就可以用相对于变量组起始位置这一基点的偏移量来表示，同样，各函数的内存地址也可以用相对于函数组起始位置这一基点的偏移量来表示。而各组基点的内存地址则是在程序运行时被分配的。
+
+
+
+EXE文件的内容分为再配置信息、变量组和函数组，这一点想必大家都清楚了吧。不过，当程序加载到内存后，除此之外还会额外生成两个组，那就是栈和堆。栈是用来存储函数内部临时使用的变量（局部变量），以及函数调用时所用的参数的内存区域。堆是用来存储程序运行时的任意数据及对象的内存领域。
+
+![加载到内存的程序由4部分构成](https://raw.githubusercontent.com/CharonChui/Pictures/master/progress_memory.jpg?raw=true)        
+
+EXE文件中并不存在栈及堆的组。栈和堆需要的内存空间是在EXE文件加载到内存后开始运行时得到分配的。因而，内存中的程序，就是由用于变量的内存空间、用于函数的内存空间、用于栈的内存空间、用于堆的内存空间这4部分构成的。
+
+
+
+
+
 ---
 
 - [上一篇:7.嵌入式系统](https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/7.%E5%B5%8C%E5%85%A5%E5%BC%8F%E7%B3%BB%E7%BB%9F.md)

From 6bab277ee44d17f93301ba234d4e692d022248f9 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 14 Apr 2021 08:42:46 +0800
Subject: [PATCH 056/213] update git note

---
 .../Git\347\256\200\344\273\213.md"           | 160 ++++++++++++++----
 ...77\347\224\250\346\225\231\347\250\213.md" |   8 +-
 2 files changed, 135 insertions(+), 33 deletions(-)

diff --git "a/JavaKnowledge/Git\347\256\200\344\273\213.md" "b/JavaKnowledge/Git\347\256\200\344\273\213.md"
index 2a33f604..71d8ecb4 100644
--- "a/JavaKnowledge/Git\347\256\200\344\273\213.md"
+++ "b/JavaKnowledge/Git\347\256\200\344\273\213.md"
@@ -48,12 +48,8 @@ Git简介
 - 已提交`(committed)`
 - 已推送`(pushed)`
 
-
 已提交表示数据已经安全的保存在本地数据库中。 已修改表示修改了文件，但还没保存到数据库中。 已暂存表示对一个已修改文件的当前版本做了标记，使之包含在下次提交的快照中。
 
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_list.png)                
-
-
 `Git`仓库目录是`Git`用来保存项目的元数据和对象数据库的地方。这是`Git`中最重要的部分，从其它计算机克隆仓库时，拷贝的就是这里的数据。
 工作目录是对项目的某个版本独立提取出来的内容。这些从`Git`仓库的压缩数据库中提取出来的文件，放在磁盘上供你使用或修改。
 
@@ -94,6 +90,40 @@ git push  // 把所有文件从本地仓库推送进远程仓库
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git.png)                  
 图中的`index`部分就是暂存区           
 
+## 三棵树
+
+
+
+Git 作为一个系统，是以它的一般操作来管理并操纵这三棵树的：
+
+| 树                | 用途                                 |
+| :---------------- | :----------------------------------- |
+| HEAD              | 上一次提交的快照，下一次提交的父结点 |
+| Index             | 预期的下一次提交的快照               |
+| Working Directory | 沙盒                                 |
+
+#### HEAD
+
+HEAD 是当前分支引用的指针，它总是指向该分支上的最后一次提交。 这表示 HEAD 将是下一次提交的父结点。 通常，理解 HEAD 的最简方式，就是将它看做 **该分支上的最后一次提交** 的快照。
+
+#### 索引
+
+索引是你的 **预期的下一次提交**。 我们也会将这个概念引用为 Git 的“暂存区”，这就是当你运行 `git commit` 时 Git 看起来的样子。
+
+#### 工作目录
+
+最后，你就有了自己的 **工作目录**（通常也叫 **工作区**）。 另外两棵树以一种高效但并不直观的方式，将它们的内容存储在 `.git` 文件夹中。 工作目录会将它们解包为实际的文件以便编辑。 你可以把工作目录当做 **沙盒**。在你将修改提交到暂存区并记录到历史之前，可以随意更改。
+
+
+
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_list.png)                
+
+
+
+## 常用命令
+
 - 安装好git后我们要先配置一下。以便`git`跟踪。           
 
     ```
@@ -103,6 +133,7 @@ git push  // 把所有文件从本地仓库推送进远程仓库
     上面修改后可以使用`cat ~/.gitconfig`查看                      
     如果指向修改仓库中的用户名时可以不加`--global`，这样可以用`cat .git/config`来查看             
     `git config --list`来查看所有的配置。   
+    如果需要查看当前的user.name和user.email的值可以通过。`git config user.name`
     
 - 新建仓库     
     ```        
@@ -137,17 +168,20 @@ git push  // 把所有文件从本地仓库推送进远程仓库
 
 - `git status`查看当前仓库的状态和信息，会提示哪些内容做了改变已经当前所在的分支。              
 
-- `git diff`                 
-    `git diff`直接查看所有的区别                 
+- `git diff`
+    
+    ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_diff.webp?raw=true)        
+    `git diff`直接查看当前修改未add(暂存staged)的差别
+    `git diff --staged`查看已add(到暂存区)的差别                  
     `git diff HEAD -- xx.txt`查看工作区与版本库最新版的差别。            
     
     - 首先如果我们只是本地修改了一个文件，但是还没有执行`git add .`之前，该如何查看有那些修改。这种情况下直接执行`git diff`就可以了。   
     - 那如果我们执行了`git add .`操作，然后你再执行`git diff`这时就会发现没有任何结果，这时因为`git diff`这个命令只是检查工作区和暂存区之间的差异。    
     如果我们要查看暂存区和本地仓库之间的差异就需要加一个参数使用`--staged`参数或者`--cached`，`git diff --cached`。这样再执行就可以看到暂存区和本地仓库之间的差异。     
     - 现在如果我们把修改使用`git commit`从暂存区提交到本地仓库，再看一下差异。这时候再执行`git diff --cached`就会发现没有任何差异。
-    如果我们行查看本地仓库和远程仓库的差异，就要换另一个参数，执行`git diff master origin/master`这样就可以看到差异了。 这里面`master`是本地的仓库，而`origin/master`是
+如果我们行查看本地仓库和远程仓库的差异，就要换另一个参数，执行`git diff master origin/master`这样就可以看到差异了。 这里面`master`是本地的仓库，而`origin/master`是
     远程仓库，因为默认都是在主分支上工作，所以两边都是`master`而`origin`代表远程。    
-
+    
 - `git push` 提交到远程仓库                        
     可以直接调用`git push`推送到当前分支         
     或者`git push origin master`推送到远程`master`分支         
@@ -163,14 +197,14 @@ git push  // 把所有文件从本地仓库推送进远程仓库
     git log --oneline --graph
     ```
     下面是常用的参数:   
-    - `–author=“Alex Kras”` ——只显示某个用户的提交任务
-    - `–name-only` ——只显示变更文件的名称
-    - `–oneline`——将提交信息压缩到一行显示
-    - `–graph` ——显示所有提交的依赖树
-    - `–reverse` ——按照逆序显示提交记录（最先提交的在最前面）
-    - `–after` ——显示某个日期之后发生的提交
-    - `–before` ——显示发生某个日期之前的提交
-
+    - `–-author=“Alex Kras”` ——只显示某个用户的提交任务
+    - `–-name-only` ——只显示变更文件的名称
+    - `–-oneline`——将提交信息压缩到一行显示
+    - `–-graph` ——显示所有提交的依赖树
+    - `–-reverse` ——按照逆序显示提交记录（最先提交的在最前面）
+    - `–-after` ——显示某个日期之后发生的提交
+    - `–-before` ——显示发生某个日期之前的提交
+    - `--grep` ——过滤内容
 
 - `git reflog`                
     可以查看所有操作记录包括`commit`和`reset`操作以及删除的`commit`记录
@@ -218,6 +252,51 @@ git push  // 把所有文件从本地仓库推送进远程仓库
     `git reset HEAD fileName`可以把用`git add`之后但是还没有`commit`之前暂存区中的修改撤销。          
     说到这里就说一个问题，如果你reset到某一个版本之后，发现弄错了，还想返回去，这时候用`git log`已经找不到之前的`commit id`了。那怎么办？这时候可以使用下面的命令来找。
 
+    先执行git log命令，将此时的Git仓库可视化
+    
+    ![img](https:////upload-images.jianshu.io/upload_images/14329037-fd317598a0b3efdd.png?imageMogr2/auto-orient/strip|imageView2/2/w/666/format/webp)
+    
+    三棵树的情况：
+    
+    ![img](https:////upload-images.jianshu.io/upload_images/14329037-8c56a66a32504a13.png?imageMogr2/auto-orient/strip|imageView2/2/w/655/format/webp)
+    
+    ### 回滚快照
+    
+    *注：快照即提交的版本，每个版本我们称之为一个快照。*
+    
+    现在我们利用 reset 命令回滚快照，并看看 Git 仓库和三棵树分别发生了什么。
+    
+    执行 git reset HEAD~ 命令：
+    
+    *注：HEAD 表示最新提交的快照，而 HEAD~ 表示 HEAD 的上一个快照，HEAD~~表示上上个快照，如果表示上10个快照，则可以用HEAD ~10*
+    
+    此时我们的快找回滚到了第二棵数（暂存区域）
+    
+    
+    
+    ![img](https:////upload-images.jianshu.io/upload_images/14329037-bf301ab8d5c02cf8.png?imageMogr2/auto-orient/strip|imageView2/2/w/665/format/webp)
+    
+    第一次执行reset后Git仓库
+    
+    ![img](https:////upload-images.jianshu.io/upload_images/14329037-f1a6a0b23de0ea39.png?imageMogr2/auto-orient/strip|imageView2/2/w/655/format/webp)
+    
+    第一次执行reset后三棵树
+    
+    git reset HEAD~ 命令其实是 git reset --mixed HEAD~ 的缩写， --mixed 选项是默认的。
+    
+    > **默认**
+    >  git reset HEAD~ 命令其实影响了两棵树：首先是移动 HEAD 的指向，将其指向上一个快照（HEAD~）；然后再将该位置的快照回滚到暂存区域。
+    >  **--soft选项**
+    >  git reset --soft HEAD~ 命令就相当于只移动 HEAD 的指向，但并不会将快照回滚到暂存区域。相当于撤消了上一次的提交（commit）。一不小心提交了，后悔了，那么你就执行 git reset --soft HEAD~ 命令即可（此时执行 git log 命令，也不会再看到已经撤消了的那个提交）。
+    >  **--hard选项**
+    >  reset 不仅移动 HEAD 的指向，将快照回滚动到暂存区域，它还将暂存区域的文件还原到工作目录。
+    
+    
+
+
+
+
+
 - `git checkout`撤销修改或者切换分支           
     `git checkout -- xx.txt`意思就是将`xx.txt`文件在工作区的修改全部撤销。可能会有两种情况:      
     
@@ -233,8 +312,9 @@ git push  // 把所有文件从本地仓库推送进远程仓库
     为什么分支的地方也是用`git checkout`这里撤销还是用它呢？他们的区别在于`--`，如果没有`--`那就是检出分支了。
     `git checkout origin/developer`  // 切换到orgin/developer分支   
 
+上面介绍了两个回退操作`git reset`和`git checkout`，这里就总结一下如何来对修改进行撤销操作:     
 
-上面介绍了`git reset`和`git checkout`，这里就总结一下如何来对修改进行撤销操作:     
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_reset_checkout.png?raw=true)        
 
 - 已经修改，但是并未执行`git add .`进行暂存        
     如果只是修改了本地文件，但是还没有执行`git add .`这时候我们的修改还是再工作区，并未进入暂存区，我们可以使用:`git checkouot .`或者`git reset --hard`来进行
@@ -332,8 +412,8 @@ git push  // 把所有文件从本地仓库推送进远程仓库
 
     // 重命名分支    
     `git branch -m new_branch wchar_support`
-
-
+    // 查看每一个分支的最后一次提交
+    `git branch -v`
 - `git merge`合并指定分支到当前分支                         
    `git merge devBranch`将`devBranch`分支合并到`master`。          
 
@@ -374,22 +454,24 @@ git push  // 把所有文件从本地仓库推送进远程仓库
 从这个图中能看到缓存区的存在，这就是为什么我们新加或者修改之后都要调用`git add`方法后再调用`git commit`。              
 其实我一直有点分不开`reset`和`checkout`的区别，从这个图里能明显看出来了：
 
-- 当执行`git reset HEAD`命令时，暂存区的目录树会被重写，会被`master`分支指向的目录树所替换，但是工作区不受影响。
-- 当执行`git checkout .`或`git checkout -- file`命令是，会用暂存区全部的文件或指定的文件替换工作区的文件。这个操作很危险，会清楚工作区中未添加到暂存区的改动。
-命令时，会用`HEAD`指向的`master`分支中的全部或部分文件替换暂存区和工作区中的文件。这个命令也是极度危险的。因为不但会清楚工作区中未提交的改动，也会清楚暂存区中未提交的改动。
+- **取消暂存** 当执行`git reset HEAD`命令时，暂存区的目录树会被重写，会被`master`分支指向的目录树所替换，但是工作区不受影响。所以如果我们修改了一个问题，执行了add之后，还没有commit这时候想要取消add，可以执行git reset HEAD XXX
+
+- **撤销对文件的修改，将它还原成上次提交时的样子或者刚克隆完的样** 当执行`git checkout .`或`git checkout -- file`命令是，会用暂存区全部的文件或指定的文件替换工作区的文件。这个操作很危险，会清除工作区中未添加到暂存区的改动。
+  命令时，会用`HEAD`指向的`master`分支中的全部或部分文件替换暂存区和工作区中的文件。这个命令也是极度危险的。因为不但会清楚工作区中未提交的改动，也会清楚暂存区中未提交的改动。
+
 - `git reset HEAD <file>` 是在添加到暂存区后，撤出暂存区使用，他只会把文件撤出暂存区，但是你的修改还在，仍然在工作区。当然如果使用`git reset --hard HEAD`这样就完了，工作区所有的内容都会被远程仓库最新代码覆盖。
-- `git checkout -- xxx.txt`是用于修改后未添加到暂存区时使用(如果修改后添加到暂存区后就没效果了，必须要先`reset`撤销暂存区后再使用`checkout`)，这时候会把之前的修改覆盖掉。所以是危险的。
 
+- `git checkout -- xxx.txt`是用于修改后未添加到暂存区时使用(如果修改后添加到暂存区后就没效果了，必须要先`reset`撤销暂存区后再使用`checkout`)，这时候会把之前的修改覆盖掉。所以是危险的。 你对那个文件在本地的任何修改都会消失——Git 会用最近提交的版本覆盖掉它。 除非你确实清楚不想要对那个文件的本地修改了，否则请不要使用这个命令
 
 - 隐藏操作     
 
-    假设您正在为产品新的功能编写/实现代码，当正在编写代码时，突然出现软件客户端升级。这时，您必须将新编写的功能代码保留几个小时然后去处理升级的问题。在这段时间内不能提交代码，也不能丢弃您的代码更改。 所以需要一些临时等待一段时间，您可以存储部分更改，然后再提交它。
-    
+    假设您正在为产品新的功能编写/实现代码，当正在编写代码时，突i然出现软件客户端升级。这时，您必须将新编写的功能代码保留几个小时然后去处理升级的问题。在这段时间内不能提交代码，也不能丢弃您的代码更改。 所以需要一些临时等待一段时间，您可以存储部分更改，然后再提交它。
+
     在`Git`中，隐藏操作将使您能够修改跟踪文件，阶段更改，并将其保存在一系列未完成的更改中，并可以随时重新应用。
-    
+
     假设你现在在`a`分支上开发新版本内容，已经开发了一部分，但是还没有达到可以提交的程度。你需要切换到`b`分支进行另一个升级的开发。那么可以
     把当前工作的改变隐藏起来，要将一个新的存根推到堆栈上，运行`git stash`命令。   
-    
+
     ```shell
     $ git stash
     Saved working directory and index state WIP on master: ef07ab5 synchronized with the remote repository
@@ -403,18 +485,24 @@ git push  // 把所有文件从本地仓库推送进远程仓库
     
     nothing to commit, working directory clean
     ```
-    
+
     现在，可以安全地切换分支并在其他地方工作。通过使用`git stash list`命令来查看已存在更改的列表。
     ```shell
     $ git stash list
     stash@{0}: WIP on master: ef07ab5 synchronized with the remote repository
     ```
-    
+
     假设您已经解决了客户升级问题，想要重新开始新的功能的代码编写，查找上次没有写完成的代码，
     只需执行`git stash pop`命令即可从堆栈中删除更改并将其放置在当前工作目录中。
-    
+
     这样你之前隐藏的内容就会重新出现了，你可以继续开发了。    
 
+    当要记录工作目录和索引的当前状态，但想要返回到干净的工作目录时，则使用`git stash`。 该命令保存本地修改，并恢复工作目录以匹配`HEAD`提交。
+
+    这个命令所储藏的修改可以使用`git stash list`列出，使用`git stash show`进行检查，并使用`git stash apply`或`git stash apply stash@{2}`恢复(可能在不同的提交之上)。调用没有任何参数的`git stash`相当于`git stash save`
+
+    
+
 - Rebase操作
 
     多人在同一个分支上协作时，很容易出现冲突，即使没有冲突，在`push`代码之前也要先`pull`，在本地合并后再`push`，所以就经常会出现这样的分支:
@@ -465,6 +553,18 @@ $ git log --graph --pretty=oneline --abbrev-commit
     ```
     `git rebase`的过程中，有时会有`conflit`这时`Git`会停止`rebase`并让用户去解决冲突，解决完冲突后，用`git add`命令去更新这些内容，然后不用执行`git commit`，直接执行`git rebase --continue`这样`git`会继续`apply`余下的补丁。   
 
+
+
+
+
+
+
+## 参考
+
+[Git使用教程](https://www.jianshu.com/p/e57a4a2cf077)
+
+[Git官方文档](https://git-scm.com/book/zh/v2)
+
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
diff --git "a/JavaKnowledge/Vim\344\275\277\347\224\250\346\225\231\347\250\213.md" "b/JavaKnowledge/Vim\344\275\277\347\224\250\346\225\231\347\250\213.md"
index 71132805..32f99d97 100644
--- "a/JavaKnowledge/Vim\344\275\277\347\224\250\346\225\231\347\250\213.md"
+++ "b/JavaKnowledge/Vim\344\275\277\347\224\250\346\225\231\347\250\213.md"
@@ -16,8 +16,10 @@ Vim使用教程
 ---
 
 - `i` 进入`insert`模式
-- `a` 在光标后进行插入，直接进入`Insert`模式
-- `o` 在当前行后插入一个新行，直接进入`Insert`模式
+- `a(append)` 在光标后进行插入，直接进入`insert`模式
+- `o(open a line below)` 在当前行后插入一个新行，直接进入`insert`模式
+- `I` 从改行的最前面开始编辑
+- `A` 从改行的最后面开始编辑
 - `cw` 替换从光标位置开始到该单词结束位置的所有字符，直接进入`Insert`模式
 
 
@@ -37,7 +39,7 @@ Vim使用教程
 - `e` 移动到单词结束位置
 - `b` 移动到单词开始位置
 - `:59` 移动到59行
-- `#l` 移动光标到改行第#个字的位置，如`5l`
+- `#l` 移动光标到该行第#个字的位置，如`5l`
 - `ctrl+g` 列出当前光标所在行的行号等信息
 - `: #` 如输入: 15会跳到文章的第15行
 - `ctrl + d`向下翻页

From 644d177356319bc130b46064fcea6e1346e06b11 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 14 Apr 2021 14:17:07 +0800
Subject: [PATCH 057/213] add Git notes

---
 .../Git\347\256\200\344\273\213.md"           | 350 ++++++++++++++----
 1 file changed, 286 insertions(+), 64 deletions(-)

diff --git "a/JavaKnowledge/Git\347\256\200\344\273\213.md" "b/JavaKnowledge/Git\347\256\200\344\273\213.md"
index 71d8ecb4..c1346e27 100644
--- "a/JavaKnowledge/Git\347\256\200\344\273\213.md"
+++ "b/JavaKnowledge/Git\347\256\200\344\273\213.md"
@@ -36,7 +36,7 @@ Git简介
 - 使用命令`git commit`，完成。
 
 
-五种状态 
+Git的五种状态 
 ---
 
 
@@ -61,6 +61,15 @@ Git简介
 - 暂存文件，将文件的快照放入暂存区域。
 - 提交更新，找到暂存区域的文件，将快照永久性存储到`Git`仓库目录。
 
+#### Git目录下文件的状态: 
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_file_lifecycle.png?raw=true)        
+你工作目录下的每一个文件都不外乎这两种状态: 
+- 已跟踪(Tracked)
+    已跟踪的文件是指那些被纳入了版本控制的文件，在上一次快照中有他们的记录，在工作一段时间后，它们的状态可能是未修改，已修改或已放入暂存区。简而言之，已跟踪的文件就是Git已经知道的文件
+- 未跟踪(Untracked)
+    工作目录中除已跟踪文件外的其它所有文件都属于未跟踪文件，它们即不存在与上次快照的记录中，也没有被放入暂存区。
+
 
 四个区
 ---
@@ -91,9 +100,6 @@ git push  // 把所有文件从本地仓库推送进远程仓库
 图中的`index`部分就是暂存区           
 
 ## 三棵树
-
-
-
 Git 作为一个系统，是以它的一般操作来管理并操纵这三棵树的：
 
 | 树                | 用途                                 |
@@ -165,7 +171,7 @@ HEAD 是当前分支引用的指针，它总是指向该分支上的最后一次
     就是对已经存在的`commit`进行 再次提交；     
     简单用法:    
     `git cherry-pick <commit id>`
-
+    git rebase 命令基本是是一个自动化的 cherry-pick 命令。 它计算出一系列的提交，然后再以它们在其他地方以同样的顺序一个一个的 cherry-picks 出它们。
 - `git status`查看当前仓库的状态和信息，会提示哪些内容做了改变已经当前所在的分支。              
 
 - `git diff`
@@ -187,7 +193,7 @@ HEAD 是当前分支引用的指针，它总是指向该分支上的最后一次
     或者`git push origin master`推送到远程`master`分支         
     `git push origin devBranch`推送到远程`devBranch`分支           
 
-- `git log`查看当前分支下的提交记录             
+### `git log`查看当前分支下的提交记录             
     用`git log`可以查看提交历史，以便确定要回退到哪个版本。
     如果已经使用`git log`查出版本`commit id`后`reset`到某一次提交后，又要重返回来，
     用`git reflog`查看命令历史，以便确定要回到未来的哪个版本。     
@@ -195,6 +201,7 @@ HEAD 是当前分支引用的指针，它总是指向该分支上的最后一次
     git log -p -2 // -p 是仅显示最近的x次提交   
     git log --stat // stat简略的显示每次提交的内容梗概，如哪些文件变更，多少删除，多少添加
     git log --oneline --graph
+    git log --grep="1"
     ```
     下面是常用的参数:   
     - `–-author=“Alex Kras”` ——只显示某个用户的提交任务
@@ -206,10 +213,17 @@ HEAD 是当前分支引用的指针，它总是指向该分支上的最后一次
     - `–-before` ——显示发生某个日期之前的提交
     - `--grep` ——过滤内容
 
+#### Git日志搜索
+如果你想知道某一个东西是什么时候存在或者引入的。git log命令有许多强大的工具可以通过提交信息甚至是diff的内容来找到某个特定的提交。
+例如，如果我们想找到ZLIB_BUF_MAX常量是什么时候引入的，我们可以使用-S选项来显示新增和删除该字符串的提交:   
+```shell
+git log -S ZLIB_BUF_MAX --oneline
+
+
 - `git reflog`                
     可以查看所有操作记录包括`commit`和`reset`操作以及删除的`commit`记录
 
-- `git reset`       
+### `git reset`       
     `git reset`命令用于将当前HEAD复位到指定状态。一般用于撤消之前的一些操作(如:`git add`,`git commit`等)。                 
     在`git`的一般使用中，如果发现错误的将不想暂存的文件被`git add`进入索引之后，想回退取消，则可以使用命令:`git reset HEAD <file>`，
     同时`git add`完毕之后，`git`也会做相应的提示，比如:    
@@ -252,48 +266,79 @@ HEAD 是当前分支引用的指针，它总是指向该分支上的最后一次
     `git reset HEAD fileName`可以把用`git add`之后但是还没有`commit`之前暂存区中的修改撤销。          
     说到这里就说一个问题，如果你reset到某一个版本之后，发现弄错了，还想返回去，这时候用`git log`已经找不到之前的`commit id`了。那怎么办？这时候可以使用下面的命令来找。
 
-    先执行git log命令，将此时的Git仓库可视化
-    
-    ![img](https:////upload-images.jianshu.io/upload_images/14329037-fd317598a0b3efdd.png?imageMogr2/auto-orient/strip|imageView2/2/w/666/format/webp)
-    
-    三棵树的情况：
-    
-    ![img](https:////upload-images.jianshu.io/upload_images/14329037-8c56a66a32504a13.png?imageMogr2/auto-orient/strip|imageView2/2/w/655/format/webp)
-    
-    ### 回滚快照
-    
-    *注：快照即提交的版本，每个版本我们称之为一个快照。*
-    
-    现在我们利用 reset 命令回滚快照，并看看 Git 仓库和三棵树分别发生了什么。
-    
-    执行 git reset HEAD~ 命令：
-    
-    *注：HEAD 表示最新提交的快照，而 HEAD~ 表示 HEAD 的上一个快照，HEAD~~表示上上个快照，如果表示上10个快照，则可以用HEAD ~10*
-    
-    此时我们的快找回滚到了第二棵数（暂存区域）
-    
-    
-    
-    ![img](https:////upload-images.jianshu.io/upload_images/14329037-bf301ab8d5c02cf8.png?imageMogr2/auto-orient/strip|imageView2/2/w/665/format/webp)
-    
-    第一次执行reset后Git仓库
-    
-    ![img](https:////upload-images.jianshu.io/upload_images/14329037-f1a6a0b23de0ea39.png?imageMogr2/auto-orient/strip|imageView2/2/w/655/format/webp)
-    
-    第一次执行reset后三棵树
-    
-    git reset HEAD~ 命令其实是 git reset --mixed HEAD~ 的缩写， --mixed 选项是默认的。
-    
-    > **默认**
-    >  git reset HEAD~ 命令其实影响了两棵树：首先是移动 HEAD 的指向，将其指向上一个快照（HEAD~）；然后再将该位置的快照回滚到暂存区域。
-    >  **--soft选项**
-    >  git reset --soft HEAD~ 命令就相当于只移动 HEAD 的指向，但并不会将快照回滚到暂存区域。相当于撤消了上一次的提交（commit）。一不小心提交了，后悔了，那么你就执行 git reset --soft HEAD~ 命令即可（此时执行 git log 命令，也不会再看到已经撤消了的那个提交）。
-    >  **--hard选项**
-    >  reset 不仅移动 HEAD 的指向，将快照回滚动到暂存区域，它还将暂存区域的文件还原到工作目录。
-    
-    
+假设我们进入到一个新目录，其中有一个文件。 我们称其为该文件的 v1 版本，将它标记为蓝色。 现在运行 git init，这会创建一个 Git 仓库，其中的 HEAD 引用指向未创建的 master 分支。
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-ex1.png?raw=true)        
+此时，只有工作目录有内容。
+现在我们想要提交这个文件，所以用git add来获取工作目录中的内容，并将其复制到索引中。 
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-ex2.png?raw=true)        
+接着运行git commit，它会取得索引中的内容并将它保存为一个永久的快照，然后创建一个指向该快照的提交对象，最后更新master来指向本次提交。
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-ex3.png?raw=true)        
+此时如果我们运行 git status，会发现没有任何改动，因为现在三棵树完全相同。
+
+现在我们想要对文件进行修改然后提交它。 我们将会经历同样的过程；首先在工作目录中修改文件。 我们称其为该文件的 v2 版本，并将它标记为红色。
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-ex4?raw=true)        
+如果现在运行 git status，我们会看到文件显示在 “Changes not staged for commit” 下面并被标记为红色，因为该条目在索引与工作目录之间存在不同。 接着我们运行 git add 来将它暂存到索引中。
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-ex5.png?raw=true)        
+此时，由于索引和 HEAD 不同，若运行 git status 的话就会看到 “Changes to be committed” 下的该文件变为绿色 ——也就是说，现在预期的下一次提交与上一次提交不同。 最后，我们运行 git commit 来完成提交。
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-ex6.png?raw=true)        
+现在运行 git status 会没有输出，因为三棵树又变得相同了。
+
+切换分支或克隆的过程也类似。 当检出一个分支时，它会修改 HEAD 指向新的分支引用，将 索引 填充为该次提交的快照， 然后将 索引 的内容复制到 工作目录 中。
+
+#### 重置的作用
+在以下情景中观察 reset 命令会更有意义。
+
+为了演示这些例子，假设我们再次修改了 file.txt 文件并第三次提交它。 现在的历史看起来是这样的：
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-start.png?raw=true)        
+让我们跟着 reset 看看它都做了什么。 它以一种简单可预见的方式直接操纵这三棵树。 它做了三个基本操作。
+
+##### 第 1 步：移动 HEAD
+reset 做的第一件事是移动 HEAD 的指向。 这与改变 HEAD 自身不同（checkout 所做的）；reset 移动 HEAD 指向的分支。 这意味着如果 HEAD 设置为 master 分支（例如，你正在 master 分支上）， 运行 git reset 9e5e6a4 将会使 master 指向 9e5e6a4。
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-soft.png?raw=true)        
+无论你调用了何种形式的带有一个提交的 reset，它首先都会尝试这样做。 使用 reset --soft，它将仅仅停在那儿。
+
+现在看一眼上图，理解一下发生的事情：它本质上是撤销了上一次 git commit 命令。 当你在运行 git commit 时，Git 会创建一个新的提交，并移动 HEAD 所指向的分支来使其指向该提交。 当你将它 reset 回 HEAD~（HEAD 的父结点）时，其实就是把该分支移动回原来的位置，而不会改变索引和工作目录。 现在你可以更新索引并再次运行 git commit 来完成 git commit --amend 所要做的事情了
+##### 第 2 步：更新索引（--mixed）
+注意，如果你现在运行 git status 的话，就会看到新的 HEAD 和以绿色标出的它和索引之间的区别。
+
+接下来，reset 会用 HEAD 指向的当前快照的内容来更新索引。
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-mixed.png?raw=true)        
+如果指定 --mixed 选项，reset 将会在这时停止。 这也是默认行为，所以如果没有指定任何选项（在本例中只是 git reset HEAD~），这就是命令将会停止的地方。
+
+现在再看一眼上图，理解一下发生的事情：它依然会撤销一上次 提交，但还会 取消暂存 所有的东西。 于是，我们回滚到了所有 git add 和 git commit 的命令执行之前。
+
+##### 第 3 步：更新工作目录（--hard）
+reset 要做的的第三件事情就是让工作目录看起来像索引。 如果使用 --hard 选项，它将会继续这一步。
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-hard.png?raw=true)        
+现在让我们回想一下刚才发生的事情。 你撤销了最后的提交、git add 和 git commit 命令 以及 工作目录中的所有工作。
+
+必须注意，--hard 标记是 reset 命令唯一的危险用法，它也是 Git 会真正地销毁数据的仅有的几个操作之一。 其他任何形式的 reset 调用都可以轻松撤消，但是 --hard 选项不能，因为它强制覆盖了工作目录中的文件。 在这种特殊情况下，我们的 Git 数据库中的一个提交内还留有该文件的 v3 版本， 我们可以通过 reflog 来找回它。但是若该文件还未提交，Git 仍会覆盖它从而导致无法恢复。
+
+回顾
+reset 命令会以特定的顺序重写这三棵树，在你指定以下选项时停止：
+
+- 移动 HEAD 分支的指向 （若指定了 --soft，则到此停止）
+- 使索引看起来像 HEAD （若未指定 --hard，则到此停止）
+- 使工作目录看起来像索引
+
 
+##### 通过路径来重置
+前面讲述了 reset 基本形式的行为，不过你还可以给它提供一个作用路径。 若指定了一个路径，reset 将会跳过第 1 步，并且将它的作用范围限定为指定的文件或文件集合。 这样做自然有它的道理，因为 HEAD 只是一个指针，你无法让它同时指向两个提交中各自的一部分。 不过索引和工作目录 可以部分更新，所以重置会继续进行第 2、3 步。
 
+现在，假如我们运行 git reset file.txt （这其实是 git reset --mixed HEAD file.txt 的简写形式，因为你既没有指定一个提交的 SHA-1 或分支，也没有指定 --soft 或 --hard），它会：
+
+- 移动 HEAD 分支的指向 （已跳过）
+- 让索引看起来像 HEAD （到此处停止）
+
+所以它本质上只是将 file.txt 从 HEAD 复制到索引中。
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-path1.png?raw=true)        
+它还有 取消暂存文件 的实际效果。 如果我们查看该命令的示意图，然后再想想 git add 所做的事，就会发现它们正好相反。
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-path2.png?raw=true)        
+这就是为什么 git status 命令的输出会建议运行此命令来取消暂存一个文件。我们可以不让 Git 从 HEAD 拉取数据，而是通过具体指定一个提交来拉取该文件的对应版本。 我们只需运行类似于 git reset eb43bf file.txt 的命令即可。
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-path3.png?raw=true)        
+它其实做了同样的事情，也就是把工作目录中的文件恢复到 v1 版本，运行 git add 添加它， 然后再将它恢复到 v3 版本（只是不用真的过一遍这些步骤）。 如果我们现在运行 git commit，它就会记录一条“将该文件恢复到 v1 版本”的更改， 尽管我们并未在工作目录中真正地再次拥有它。
+
+还有一点同 git add 一样，就是 reset 命令也可以接受一个 --patch 选项来一块一块地取消暂存的内容。 这样你就可以根据选择来取消暂存或恢复内容了。
 
 
 
@@ -349,6 +394,24 @@ HEAD 是当前分支引用的指针，它总是指向该分支上的最后一次
     git reset --hard HEAD^  // HEAD^代表最新提交的前一次  
     git push -f  // 强制推送
     ```
+#### reset checkout的区别
+你大概还想知道 checkout 和 reset 之间的区别。 和 reset 一样，checkout 也操纵三棵树，不过它有一点不同，这取决于你是否传给该命令一个文件路径。
+
+不带路径
+运行 git checkout [branch] 与运行 git reset --hard [branch] 非常相似，它会更新所有三棵树使其看起来像 [branch]，不过有两点重要的区别。
+
+首先不同于 reset --hard，checkout 对工作目录是安全的，它会通过检查来确保不会将已更改的文件弄丢。 其实它还更聪明一些。它会在工作目录中先试着简单合并一下，这样所有 还未修改过的 文件都会被更新。 而 reset --hard 则会不做检查就全面地替换所有东西。
+
+第二个重要的区别是 checkout 如何更新 HEAD。 reset 会移动 HEAD 分支的指向，而 checkout 只会移动 HEAD 自身来指向另一个分支。
+
+例如，假设我们有 master 和 develop 分支，它们分别指向不同的提交；我们现在在 develop 上（所以 HEAD 指向它）。 如果我们运行 git reset master，那么 develop 自身现在会和 master 指向同一个提交。 而如果我们运行 git checkout master 的话，develop 不会移动，HEAD 自身会移动。 现在 HEAD 将会指向 master。
+
+所以，虽然在这两种情况下我们都移动 HEAD 使其指向了提交 A，但 做法 是非常不同的。 reset 会移动 HEAD 分支的指向，而 checkout 则移动 HEAD 自身。
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-checkout.png?raw=true)        
+带路径
+运行 checkout 的另一种方式就是指定一个文件路径，这会像 reset 一样不会移动 HEAD。 它就像 git reset [branch] file 那样用该次提交中的那个文件来更新索引，但是它也会覆盖工作目录中对应的文件。 它就像是 git reset --hard [branch] file（如果 reset 允许你这样运行的话）， 这样对工作目录并不安全，它也不会移动 HEAD。
+
+此外，同 git reset 和 git add 一样，checkout 也接受一个 --patch 选项，允许你根据选择一块一块地恢复文件内容。
 
 
 - `git revert`撤销提交   
@@ -360,7 +423,43 @@ HEAD 是当前分支引用的指针，它总是指向该分支上的最后一次
     相比`git reset`它不会改变现在得提交历史。`git reset`是直接删除制定的`commit`
     并把`HEAD`向后移动了一下。而`git revert`是一次新的特殊的`commit`，`HEAD`继续前进，本质和普通`add commit`一样，仅仅是`commit`内容很特殊。内容是与前面普通`commit`变化的反操作。
     比如前面普通`commit`是增加一行`a`，那么`revert`内容就是删除一行`a`。
+在 Git 开发中通常会控制主干分支的质量，但有时还是会把错误的代码合入到远程主干。 虽然可以直接回滚远程分支， 但有时新的代码也已经合入，直接回滚后最近的提交都要重新操作。 那么有没有只移除某些 Commit 的方式呢？可以一次 revert操作来完成。
+
+考虑这个例子，我们提交了 6 个版本，其中 3-4 包含了错误的代码需要被回滚掉。 同时希望不影响到后续的 5-6。
+```shell
+* 982d4f6 (HEAD -> master) version 6
+* 54cc9dc version 5
+* 551c408 version 4, harttle screwed it up again
+* 7e345c9 version 3, harttle screwed it up
+* f7742cd version 2
+* 6c4db3f version 1
+```
+这种情况在团队协作的开发中会很常见：可能是流程或认为原因不小心合入了错误的代码， 也可能是合入一段时间后才发现存在问题。 总之已经存在后续提交，使得直接回滚不太现实。
 
+下面的部分就开始介绍具体操作了，同时我们假设远程分支是受保护的（不允许 Force Push）。 思路是从产生一个新的 Commit 撤销之前的错误提交。
+
+使用 git revert <commit> 可以撤销指定的提交， 要撤销一串提交可以用 <commit1>..<commit2> 语法。 注意这是一个前开后闭区间，即不包括 commit1，但包括 commit2。
+```shell
+git revert --no-commit f7742cd..551c408
+git commit -a -m 'This reverts commit 7e345c9 and 551c408'
+```
+其中 f7742cd 是 version 2，551c408 是 version 4，这样被移除的是 version 3 和 version 4。 注意 revert 命令会对每个撤销的 commit 进行一次提交，--no-commit 后可以最后一起手动提交。
+
+此时 Git 记录是这样的：
+```shell
+* 8fef80a (HEAD -> master) This reverts commit 7e345c9 and 551c408
+* 982d4f6 version 6
+* 54cc9dc version 5
+* 551c408 version 4, harttle screwed it up again
+* 7e345c9 version 3, harttle screwed it up
+* f7742cd version 2
+* 6c4db3f version 1
+```
+现在的 HEAD（8fef80a）就是我们想要的版本，把它 Push 到远程即可。
+
+
+
+git revert 命令本质上就是一个逆向的 git cherry-pick 操作。 它将你提交中的变更的以完全相反的方式的应用到一个新创建的提交中，本质上就是撤销或者倒转。
 
 - `git rm`删除文件     
     该文件就不再纳入版本管理了。如果删除之前修改过并且已经放到暂存区域的话，则必须要用强制删除选项 -f（译注：即 force 的首字母），以防误删除文件后丢失修改的内容。
@@ -440,10 +539,30 @@ HEAD 是当前分支引用的指针，它总是指向该分支上的最后一次
     当然不要忘了把该文件提交上去                
     在用`linux`的时候会自动生成一些以`~`结尾的备份文件，如果ignore掉呢？[https://github.com/github/gitignore/blob/master/Global/Linux.gitignore](https://github.com/github/gitignore/blob/master/Global/Linux.gitignore)
 
-- 撤销最后一次提交
+### amend修改最后一次提交
     有时候我们提交完了才发现漏掉了几个文件没有加或者提交信息写错了，想要撤销刚才的的提交操作。可以修改后重新git add 然后使用`--amend`选项重新提交:`git commit --amend`，然后再执行`git push`操作。
 
+修补后的提交可能需要修补提交信息
+当你在修补一次提交时，可以同时修改提交信息和提交内容。 如果你修补了提交的内容，那么几乎肯定要更新提交消息以反映修改后的内容。
+
+另一方面，如果你的修补是琐碎的（如修改了一个笔误或添加了一个忘记暂存的文件）， 那么之前的提交信息不必修改，你只需作出更改，暂存它们，然后通过以下命令避免不必要的编辑器环节即可：
+
+$ git commit --amend --no-edit
+
+#### 修改多个提交信息
+为了修改在提交历史中较远的提交，必须使用更复杂的工具。 Git 没有一个改变历史工具，但是可以使用变基工具来变基一系列提交，基于它们原来的 HEAD 而不是将其移动到另一个新的上面。 通过交互式变基工具，可以在任何想要修改的提交后停止，然后修改信息、添加文件或做任何想做的事情。 可以通过给 git rebase 增加 -i 选项来交互式地运行变基。 必须指定想要重写多久远的历史，这可以通过告诉命令将要变基到的提交来做到。
+
+例如，如果想要修改最近三次提交信息，或者那组提交中的任意一个提交信息， 将想要修改的最近一次提交的父提交作为参数传递给 git rebase -i 命令，即 HEAD~2^ 或 HEAD~3。 记住 ~3 可能比较容易，因为你正尝试修改最后三次提交；但是注意实际上指定了以前的四次提交，即想要修改提交的父提交：
+
+$ git rebase -i HEAD~3
+再次记住这是一个变基命令——在 HEAD~3..HEAD 范围内的每一个修改了提交信息的提交及其 所有后裔 都会被重写。 不要涉及任何已经推送到中央服务器的提交——这样做会产生一次变更的两个版本，因而使他人困惑。
+输入
+
+$ git commit --amend
+修改提交信息，然后退出编辑器。 然后，运行
 
+$ git rebase --continue
+这个命令将会自动地应用另外两个提交，然后就完成了。 如果需要将不止一处的 pick 改为 edit，需要在每一个修改为 edit 的提交上重复这些步骤。 每一次，Git 将会停止，让你修正提交，然后继续直到完成。
 
 - 查看远程仓库克隆地址
     `git remote -v`
@@ -463,12 +582,8 @@ HEAD 是当前分支引用的指针，它总是指向该分支上的最后一次
 
 - `git checkout -- xxx.txt`是用于修改后未添加到暂存区时使用(如果修改后添加到暂存区后就没效果了，必须要先`reset`撤销暂存区后再使用`checkout`)，这时候会把之前的修改覆盖掉。所以是危险的。 你对那个文件在本地的任何修改都会消失——Git 会用最近提交的版本覆盖掉它。 除非你确实清楚不想要对那个文件的本地修改了，否则请不要使用这个命令
 
-- 隐藏操作     
-
-    假设您正在为产品新的功能编写/实现代码，当正在编写代码时，突i然出现软件客户端升级。这时，您必须将新编写的功能代码保留几个小时然后去处理升级的问题。在这段时间内不能提交代码，也不能丢弃您的代码更改。 所以需要一些临时等待一段时间，您可以存储部分更改，然后再提交它。
-
-    在`Git`中，隐藏操作将使您能够修改跟踪文件，阶段更改，并将其保存在一系列未完成的更改中，并可以随时重新应用。
-
+### stash(贮藏)     
+stash会处理工作目录的脏的文件--即跟踪文件的修改与暂存的改动--然后将未完成的修改保存到一个栈上，而你可以在任何时候重新应用这些改动（甚至在不同的分支上）。
     假设你现在在`a`分支上开发新版本内容，已经开发了一部分，但是还没有达到可以提交的程度。你需要切换到`b`分支进行另一个升级的开发。那么可以
     把当前工作的改变隐藏起来，要将一个新的存根推到堆栈上，运行`git stash`命令。   
 
@@ -491,19 +606,128 @@ HEAD 是当前分支引用的指针，它总是指向该分支上的最后一次
     $ git stash list
     stash@{0}: WIP on master: ef07ab5 synchronized with the remote repository
     ```
+    这个命令所储藏的修改可以使用`git stash list`列出，使用`git stash show`进行检查，并使用`git stash apply`或`git stash apply stash@{2}`恢复(可能在不同的提交之上)。或者可以用git stash pop将最近的一次stash恢复。调用没有任何参数的`git stash`相当于`git stash save`。在17年10月下旬Git讨论废弃了git stash save命令，代之以现有的git stash push命令。
+    可以使用git stash drop加上要移除的贮藏的名字来移除它。
 
-    假设您已经解决了客户升级问题，想要重新开始新的功能的代码编写，查找上次没有写完成的代码，
-    只需执行`git stash pop`命令即可从堆栈中删除更改并将其放置在当前工作目录中。
 
-    这样你之前隐藏的内容就会重新出现了，你可以继续开发了。    
 
-    当要记录工作目录和索引的当前状态，但想要返回到干净的工作目录时，则使用`git stash`。 该命令保存本地修改，并恢复工作目录以匹配`HEAD`提交。
+### 区间提交
+你想要查看 experiment 分支中还有哪些提交尚未被合并入 master 分支。 你可以使用 master..experiment 来让 Git 显示这些提交。也就是“在 experiment 分支中而不在 master 分支中的提交”。 
+```shell
+git log master..experiment
+```    
+#### 三点
+这个语法可以选择出被两个引用 之一 包含但又不被两者同时包含的提交。 再看看之前双点例子中的提交历史。 如果你想看 master 或者 experiment 中包含的但不是两者共有的提交，你可以执行：
+```shell
+git log master...experiment
+```
 
-    这个命令所储藏的修改可以使用`git stash list`列出，使用`git stash show`进行检查，并使用`git stash apply`或`git stash apply stash@{2}`恢复(可能在不同的提交之上)。调用没有任何参数的`git stash`相当于`git stash save`
 
-    
+### Rebase操作
+    官网中将rebase翻译为变基，我感觉理解成改变基点，重新实现更容易理解一些。
+    假设目前除master分支之外还有一个experiment分支: 
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/basic-rebase-1.png?raw=true)        
+我们现在想要把master分支merge一下experiment分支的最新代码。整合分支最容易的方法是merge命令。它会把这两个分支的最新快照(C3和C4)以及两者最近的共同祖先(C2)进行三方合并，合并的结果是生成一个新的快照(C5)并提交。
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/basic-rebase-2.png?raw=true)        
+其实，还有一种方法：你可以提取在C4中引入的补丁和修改，然后在C3的基础上应用一次。在Git中，这种操作就叫做变基(rebase)。你可以使用rebase命令将提交到某一分支上的所有修改都移至另一分支上，就好像“重新播放”一样。
+在这个例子中，你可以检出experiment分支，然后将它变基到master分支上:  
+```shell
+git checkout experiment
+git rebase master
+```
+它的原理是首先找到这两个分支(即当前分支experiment、变基操作的目标基底分支master)的最近共同祖先C2，然后对比当前分支相对于该祖先的历次提交，提取相应的修改并存为临时文件，然后将当前分支指向目标基底C3，最后以此将之前另存为临时文件的修改依序引用。
+![将C4中的修改变基到C3上](https://raw.githubusercontent.com/CharonChui/Pictures/master/basic-rebase-3.png?raw=true)        
+现在回到master分支，进行一次快进合并。
+```shell
+git checkout master
+git merge experiment
+```
+![master分支的快进合并](https://raw.githubusercontent.com/CharonChui/Pictures/master/basic-rebase-4.png?raw=true)        
+此时C4'指向的快照就和上面直接用merge中的C5指向的快照一模一样了。这两种整合方法的最终结果没有任何区别，但是变基使得提交历史更加整洁。你在查看一个经过变基的分支的历史记录时会发现，尽管实际的开发工作是并行的，但它们看上去就像是串行的一样，提交历史是一条直线没有分叉。
+一般我们这样做的目的是为了确保在向远程分支推送时能保持提交历史的整洁--例如向某个他人维护的项目贡献代码时。在这种情况下，你首先在自己的分支里进行开发，当开发完成时你需要先将你的代码变基到orgin/master上，然后再向主项目提交修改。这样的话，该项目的维护者就不再需要进行整合工作，只需要快进合并即可。
+请注意，无论是通过变基，还是通过三方合并，整合的最终结果所指向的快照始终是一样的，只不过提交历史不同罢了。变基是将一系列提交按照原有次序依次应用到另一分支上，而合并是把最终结果合在一起。
+
+##### 更有趣的变基例子
+在对两个分支进行变基时，所生成的“重放”并不一定要在目标分支上应用，你也可以指定另外的一个分支进行应用。假如你创建了一个主题分支server，为服务端添加了一些功能，提交了C3和C4.然后从C3上创建了主题分支client，为客户端添加了一些功能，提交了C8和C9.最后，你回到server分支，又提交了C10.
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/interesting-rebase-1.png?raw=true)        
+假设你希望将client中的修改合并到主分支并发布，但暂时并不想合并server中的修改，因为他们还需要经过更全面的测试。这时，你就可以使用git rebase命令的--onto选项，选中在client分支里但不在server分支里的修改(即C8和C9)，将它们在master分支上重放: `git rebase --onto master server client`
+以上命令的意思是：取出client分支，找出它从server分支分歧之后的补丁，然后把这些补丁在master分支上重放一遍，让client看起来像直接基于master修改一样。
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/interesting-rebase-2.png?raw=true)        
+现在可以快速合并master分支了(快速合并master分支，使之包含来自client分支的修改)：
+```shell
+git checkout master
+git merge client
+```
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/interesting-rebase-3.png?raw=true)        
+接下来你决定将server分支中的修改也整合进来，使用git rebase <basebranch> <topicbranch>命令可以直接将主题分支(即这里的server)变基到基分支(即这里的master)上。这样做能省去你先切换到server分支，再对其进行变基命令的多个步骤。
+`git rebase master server`
+如下图，将server中的修改变基到master上所示，server中的代码被“续”到了master后面。
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/interesting-rebase-4.png?raw=true)        
+然后就可以快进合并主分支master了: 
+```shell
+git checkout master
+git merge server
+```
+至此，client和server分支中的修改都已经整合到主分支里了，你可以删除这两个分支，最终提交历史会变成下图的样子: 
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/interesting-rebase-5.png?raw=true)        
+
+##### 变基的风险
+奇妙的变基也并非完美无缺，要用它得遵守一条准则： 
+如果提交存在于你的仓库之外，而别人可能基于这些提交进行开发，那么不要执行变基。
+变基操作的实质是丢弃一些现有的提交，然后相应地新建一些内容一样但实际上不同的提交。如果你已经将提交推送至某个仓库，而其他人也已经从该仓库拉取提交并进行了后续工作，此时，如果你用git rebase命令重新整理了提交并再次推送，你的同伴因此将不得不再次将他们手头的工作与你的提交进行整合，如果接下来你还要拉去并整合他们修改过的提交，事情就会变的一团糟。
+让我们来看一个在公开仓库上执行变基操作所带来的问题。假设你从一个中央服务器克隆然后在它的基础上进行了一些开发。你的提交历史如下图: 
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/perils-of-rebasing-1.png?raw=true)       
+然后，某人又向中央服务器提交了一些修改，其中还包括一次合并。你抓取了这些在远程分支上的修改，并将其合并到你本地的开发分支，然后你的提交记录就会变成这样:  
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/perils-of-rebasing-2.png?raw=true)        
+接下来，这个人又决定把合并操作回滚，改用变基。继而又用git push --force命令覆盖了服务器上的提交历史。之后你从服务器抓取更新，会发现多出来一些新的提交: 
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/perils-of-rebasing-3.png?raw=true)        
+结果就是你们两个人的处境都十分尴尬。如果你执行git pull命令，你将合并来自两条提交历史的内容，生成一个新的合并提交，最终仓库也会变成:  
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/perils-of-rebasing-4.png?raw=true)        
+这相当于是你将相同的内容又合并了一次，生成了一个新的提交。此时如果你执行git log命令，你会发现有两个调的作者、日期、日志居然是一样的，这会令人感到混乱。此外，如果你将这一堆又推送到服务器上，你实际上是将那些已经被变基抛弃的提交又找了回来，这会令人感到更加混乱。很明显对方并不想在提交历史中看到C4和C6，因为之前就是他把这两个提交丢弃的。
+
+##### 用变基解决变基
+如果你 真的 遭遇了类似的处境，Git 还有一些高级魔法可以帮到你。 如果团队中的某人强制推送并覆盖了一些你所基于的提交，你需要做的就是检查你做了哪些修改，以及他们覆盖了哪些修改。
+
+实际上，Git 除了对整个提交计算 SHA-1 校验和以外，也对本次提交所引入的修改计算了校验和——即 “patch-id”。
+
+如果你拉取被覆盖过的更新并将你手头的工作基于此进行变基的话，一般情况下 Git 都能成功分辨出哪些是你的修改，并把它们应用到新分支上。
+
+举个例子，如果遇到前面提到的 有人推送了经过变基的提交，并丢弃了你的本地开发所基于的一些提交 那种情境，如果我们不是执行合并，而是执行 git rebase teamone/master, Git 将会：
+
+- 检查哪些提交是我们的分支上独有的（C2，C3，C4，C6，C7）
+- 检查其中哪些提交不是合并操作的结果（C2，C3，C4）
+- 检查哪些提交在对方覆盖更新时并没有被纳入目标分支（只有 C2 和 C3，因为 C4 其实就是 C4'）
+- 把查到的这些提交应用在 teamone/master 上面
+
+从而我们将得到与 你将相同的内容又合并了一次，生成了一个新的提交 中不同的结果，如图 在一个被变基然后强制推送的分支上再次执行变基 所示。
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/perils-of-rebasing-5.png?raw=true)        
+要想上述方案有效，还需要对方在变基时确保 C4' 和 C4 是几乎一样的。 否则变基操作将无法识别，并新建另一个类似 C4 的补丁（而这个补丁很可能无法整洁的整合入历史，因为补丁中的修改已经存在于某个地方了）。
+
+在本例中另一种简单的方法是使用 git pull --rebase 命令而不是直接 git pull。 又或者你可以自己手动完成这个过程，先 git fetch，再 git rebase teamone/master。
+
+如果你只对不会离开你电脑的提交执行变基，那就不会有事。 如果你对已经推送过的提交执行变基，但别人没有基于它的提交，那么也不会有事。 如果你对已经推送至共用仓库的提交上执行变基命令，并因此丢失了一些别人的开发所基于的提交， 那你就有大麻烦了，你的同事也会因此鄙视你。
+
+如果你或你的同事在某些情形下决意要这么做，请一定要通知每个人执行 git pull --rebase 命令，这样尽管不能避免伤痛，但能有所缓解。
+
+#### 变基 vs. 合并
+至此，你已在实战中学习了变基和合并的用法，你一定会想问，到底哪种方式更好。 在回答这个问题之前，让我们退后一步，想讨论一下提交历史到底意味着什么。
 
-- Rebase操作
+有一种观点认为，仓库的提交历史即是 记录实际发生过什么。 它是针对历史的文档，本身就有价值，不能乱改。 从这个角度看来，改变提交历史是一种亵渎，你使用 谎言 掩盖了实际发生过的事情。 如果由合并产生的提交历史是一团糟怎么办？ 既然事实就是如此，那么这些痕迹就应该被保留下来，让后人能够查阅。
+
+另一种观点则正好相反，他们认为提交历史是 项目过程中发生的事。 没人会出版一本书的第一版草稿，软件维护手册也是需要反复修订才能方便使用。 持这一观点的人会使用 rebase 及 filter-branch 等工具来编写故事，怎么方便后来的读者就怎么写。
+
+现在，让我们回到之前的问题上来，到底合并还是变基好？希望你能明白，这并没有一个简单的答案。 Git 是一个非常强大的工具，它允许你对提交历史做许多事情，但每个团队、每个项目对此的需求并不相同。 既然你已经分别学习了两者的用法，相信你能够根据实际情况作出明智的选择。
+
+总的原则是，只对尚未推送或分享给别人的本地修改执行变基操作清理历史， 从不对已推送至别处的提交执行变基操作，这样，你才能享受到两种方式带来的便利。
+
+
+
+
+
+
+
+
+ 
 
     多人在同一个分支上协作时，很容易出现冲突，即使没有冲突，在`push`代码之前也要先`pull`，在本地合并后再`push`，所以就经常会出现这样的分支:
 ```git
@@ -555,14 +779,12 @@ $ git log --graph --pretty=oneline --abbrev-commit
 
 
 
-
+尝试让每一个提交成为一个逻辑上的独立变更集。 如果可以，尝试让改动可以理解——不要在整个周末编码解决五个问题，然后在周一时将它们提交为一个巨大的提交。 即使在周末期间你无法提交，在周一时使用暂存区域将你的工作最少拆分为每个问题一个提交，并且为每一个提交附带一个有用的信息。 如果其中一些改动修改了同一个文件，尝试使用 git add --patch 来部分暂存文件（在 交互式暂存 中有详细介绍）。 不管你做一个或五个提交，只要所有的改动是在同一时刻添加的，项目分支末端的快照就是独立的，使同事开发者必须审查你的改动时尽量让事情容易些。
 
 
 
 ## 参考
 
-[Git使用教程](https://www.jianshu.com/p/e57a4a2cf077)
-
 [Git官方文档](https://git-scm.com/book/zh/v2)
 
 ---

From 74796dc2030327a0689f6d826cdeea40c89d4075 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 14 Apr 2021 14:20:35 +0800
Subject: [PATCH 058/213] update os notes

---
 ...5\234\347\263\273\347\273\237\347\256\200\344\273\213.md" | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md" "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
index 462ffb2e..1933e2d0 100644
--- "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
+++ "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
@@ -21,8 +21,11 @@
 
 引申至非医学领域，Operating Person意思是操刀手，就是掌控事情的人。再将Person这个词换成System，则Operating Systems指的就是掌控局势的一种系统。也就是说计算机里面的一切事情均由Operating Systems来掌控。那么，我们现在面临两个问题：第一个问题是，操作系统到底是什么东西？第二个问题是，操作系统到底操控什么事情？我们先回答第一个问题。既然操作系统是掌控计算机局势的一个系统，自然很重要。但这个说法并不能帮助读者理解操作系统，也无法形成有形的概念。如果我们换个说法：操作系统是介于计算机和应用软件之间的一个软件系统，则概念就具体多了。从这个定义出发，我们知道操作系统的上面和下面都有别的对象存在：下面是硬件平台，上面是应用软件，现在回答第二个问题。我们知道操作系统代表的是掌控事情的系统，掌控什么事情呢？当然是计算机上或计算机里发生的一切事情。最原始的计算机并没有操作系统，而是直接由人来掌控事情，即所谓的单一控制终端、单一操作员模式。但是随着计算机复杂性的增长，人已经不能胜任直接掌控计算机了。于是我们编写出操作系统这个“软件”来掌控计算机，将人类从日益复杂的掌控任务中解脱出来。这个掌控有着多层深远的意义。首先，由于计算机的功能和复杂性不断发生变化（趋向更加复杂），操作系统所掌控的事情也就越来越多，越来越复杂。同时，操作系统本身能够使用的资源也不断增多（如内存容量）。这是早期驱动操作系统不断改善的根本原因。其次，既然操作系统是专门掌控计算机的，那么计算机上发生的所有事情自然需要操作系统的知晓和许可，未经操作系统同意的任何事情均视为非法的，也就是病毒和入侵攻击所试图运作的事情。作为操作系统的设计人员，我们当然要确保计算机不发生任何我们不知情或不同意的事情。但是人的能力是有限的，人的思维也是有缺陷的，我们设计出的系统自然不会十全十美，也会有缺陷，这就给了攻击者可乘之机。操作系统设计人员和攻击者之间的博弈是当前驱动操作系统改善的一个重要动力。再次，掌控事情的水平有高低之分，有效率不同之分。就像手术大夫之间也有水平高低之分。为了更好地掌控事情，同时也为了更好地满足人类永不知足的各种越来越苛刻的要求，操作系统自然需要不断改善。这种改善在过去、现在和将来都会继续下去的。最后，我们可以给操作系统下定义了：操作系统是一个软件系统；操作系统使计算机变得好用（将人类从繁琐、复杂的对机器掌控的任务中解脱）；操作系统使计算机运作变得有序（操作系统掌控计算机上所有的事情）。总结起来就是：操作系统是掌控计算机上所有事情的软件系统。
 
+### 操作系统三要素: 
 
-
+- 虚拟化（virtualization）
+- 并发（concurrency）
+- 持久性（persistence）
 
 
 ### 以现代标准而言，一个标准PC的操作系统应该提供以下功能

From 4801444571c6aa4e69730695c63657b4e7ea8a6b Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Fri, 16 Apr 2021 22:38:19 +0800
Subject: [PATCH 059/213] update os notes

---
 .../Git\347\256\200\344\273\213.md"           | 462 ++++++++----------
 ...77\347\224\250\346\225\231\347\250\213.md" |   6 +-
 ...01\350\231\232\345\274\225\347\224\250.md" |   6 +-
 ...&\347\261\273&\346\216\245\345\217\243.md" |   6 +-
 ...05\350\201\224\345\207\275\346\225\260.md" | 174 ++++++-
 ...73\347\273\237\347\256\200\344\273\213.md" | 104 ++--
 ...13\344\270\216\347\272\277\347\250\213.md" | 216 +++-----
 ...05\345\255\230\347\256\241\347\220\206.md" |  62 ++-
 OperatingSystem/5.I:O.md                      |  45 +-
 ...07\344\273\266\347\256\241\347\220\206.md" |  48 +-
 ...8.\350\231\232\346\213\237\346\234\272.md" |  10 +-
 ...13\351\227\264\351\200\232\344\277\241.md" |  23 +-
 ...10\346\201\257\346\234\272\345\210\266.md" |   9 +-
 ...roid Framework\346\241\206\346\236\266.md" |   2 +-
 ...30\345\210\266\345\237\272\347\241\200.md" |   2 +-
 ...ManagerService\347\256\200\344\273\213.md" |  10 +-
 ...ManagerService\347\256\200\344\273\213.md" |   2 +-
 17 files changed, 571 insertions(+), 616 deletions(-)

diff --git "a/JavaKnowledge/Git\347\256\200\344\273\213.md" "b/JavaKnowledge/Git\347\256\200\344\273\213.md"
index c1346e27..d3d372be 100644
--- "a/JavaKnowledge/Git\347\256\200\344\273\213.md"
+++ "b/JavaKnowledge/Git\347\256\200\344\273\213.md"
@@ -61,15 +61,6 @@ Git的五种状态
 - 暂存文件，将文件的快照放入暂存区域。
 - 提交更新，找到暂存区域的文件，将快照永久性存储到`Git`仓库目录。
 
-#### Git目录下文件的状态: 
-
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_file_lifecycle.png?raw=true)        
-你工作目录下的每一个文件都不外乎这两种状态: 
-- 已跟踪(Tracked)
-    已跟踪的文件是指那些被纳入了版本控制的文件，在上一次快照中有他们的记录，在工作一段时间后，它们的状态可能是未修改，已修改或已放入暂存区。简而言之，已跟踪的文件就是Git已经知道的文件
-- 未跟踪(Untracked)
-    工作目录中除已跟踪文件外的其它所有文件都属于未跟踪文件，它们即不存在与上次快照的记录中，也没有被放入暂存区。
-
 
 四个区
 ---
@@ -121,16 +112,20 @@ HEAD 是当前分支引用的指针，它总是指向该分支上的最后一次
 最后，你就有了自己的 **工作目录**（通常也叫 **工作区**）。 另外两棵树以一种高效但并不直观的方式，将它们的内容存储在 `.git` 文件夹中。 工作目录会将它们解包为实际的文件以便编辑。 你可以把工作目录当做 **沙盒**。在你将修改提交到暂存区并记录到历史之前，可以随意更改。
 
 
+#### Git目录下文件的状态: 
 
-
-
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_list.png)                
-
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_file_lifecycle.png?raw=true)        
+你工作目录下的每一个文件都不外乎这两种状态: 
+- 已跟踪(Tracked)
+    已跟踪的文件是指那些被纳入了版本控制的文件，在上一次快照中有他们的记录，在工作一段时间后，它们的状态可能是未修改，已修改或已放入暂存区。简而言之，已跟踪的文件就是Git已经知道的文件
+- 未跟踪(Untracked)
+    工作目录中除已跟踪文件外的其它所有文件都属于未跟踪文件，它们即不存在与上次快照的记录中，也没有被放入暂存区。
 
 
 ## 常用命令
 
-- 安装好git后我们要先配置一下。以便`git`跟踪。           
+### git config
+安装好git后我们要先配置一下。以便`git`跟踪。           
 
     ```
     git config --global user.name "xxx"            
@@ -139,9 +134,10 @@ HEAD 是当前分支引用的指针，它总是指向该分支上的最后一次
     上面修改后可以使用`cat ~/.gitconfig`查看                      
     如果指向修改仓库中的用户名时可以不加`--global`，这样可以用`cat .git/config`来查看             
     `git config --list`来查看所有的配置。   
-    如果需要查看当前的user.name和user.email的值可以通过。`git config user.name`
-    
-- 新建仓库     
+    如果需要查看当前的user.name和user.email的值可以通过`git config user.name`
+
+### git init    
+新建仓库     
     ```        
     mkdir gitDemo
     cd gitDemo
@@ -149,33 +145,33 @@ HEAD 是当前分支引用的指针，它总是指向该分支上的最后一次
     ```
     这样就创建完了。
 
-- `clone`仓库                 
+### git clone仓库                 
     在某一目录下执行.          
     `git clone [git path]`                                    
     只是后`Git`会自动把当地仓库的`master`分支和远程仓库的`master`分支对应起来，远程仓库默认的名称是`origin`。
 
-- `git add`提交文件更改(修改和新增),把当前的修改添加到暂存区                                 
+### git add提交文件更改(修改和新增),把当前的修改添加到暂存区                                 
     `git add xxx.txt`添加某一个文件                
     `git add .`添加当前目录所有的文件            
-    
-- `git commit`提交，把修改由暂存区提交到仓库中                         
+
+### `git commit`提交，把修改由暂存区提交到仓库中                         
     `git commit`提交，然后在出来的提示框内查看当前提交的内容以及输入注释。          
     或者也可以用`git commit -m "xxx"` 提交到本地仓库并且注释是xxx      
-
+    
     `git commit`是很小的一件事情，但是往往小的事情往往引不起大家的关注，不妨打开公司的任一个`repo`，查看`commit log`，满篇的`update`和`fix`，
     完全不知道这些`commit`是要做啥。在提交`commit`的时候尽量保证这个`commit`只做一件事情，比如实现某个功能或者修改了配置文件。注意是保证每个`commit`
     只做一件事，而不是让你做了一件事`commit`后就`push`，那样就有点过分了。  
 
-- `git cherry-pick`          
+### `git cherry-pick`          
     `git cherry-pick`可以选择某一个分支中的一个或几个`commit(s)`来进行操作。例如，假设我们有个稳定版本的分支，叫`v2.0`，另外还有个开发版本的分支`v3.0`，我们不能直接把两个分支合并，这样会导致稳定版本混乱，但是又想增加一个`v3.0`中的功能到`v2.0`中，这里就可以使用`cherry-pick`了。     
     就是对已经存在的`commit`进行 再次提交；     
     简单用法:    
-    `git cherry-pick <commit id>`
-    git rebase 命令基本是是一个自动化的 cherry-pick 命令。 它计算出一系列的提交，然后再以它们在其他地方以同样的顺序一个一个的 cherry-picks 出它们。
-- `git status`查看当前仓库的状态和信息，会提示哪些内容做了改变已经当前所在的分支。              
+    `git cherry-pick <commit id>`     
+    `git rebase`命令基本是是一个自动化的`cherry-pick`命令。它计算出一系列的提交，然后再以它们在其他地方以同样的顺序一个一个的`cherry-picks`出它们。
+### `git status`查看当前仓库的状态和信息，会提示哪些内容做了改变已经当前所在的分支。              
+
+### `git diff`
 
-- `git diff`
-    
     ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_diff.webp?raw=true)        
     `git diff`直接查看当前修改未add(暂存staged)的差别
     `git diff --staged`查看已add(到暂存区)的差别                  
@@ -188,86 +184,62 @@ HEAD 是当前分支引用的指针，它总是指向该分支上的最后一次
 如果我们行查看本地仓库和远程仓库的差异，就要换另一个参数，执行`git diff master origin/master`这样就可以看到差异了。 这里面`master`是本地的仓库，而`origin/master`是
     远程仓库，因为默认都是在主分支上工作，所以两边都是`master`而`origin`代表远程。    
     
-- `git push` 提交到远程仓库                        
+### `git push` 提交到远程仓库                        
     可以直接调用`git push`推送到当前分支         
     或者`git push origin master`推送到远程`master`分支         
     `git push origin devBranch`推送到远程`devBranch`分支           
 
 ### `git log`查看当前分支下的提交记录             
-    用`git log`可以查看提交历史，以便确定要回退到哪个版本。
-    如果已经使用`git log`查出版本`commit id`后`reset`到某一次提交后，又要重返回来，
-    用`git reflog`查看命令历史，以便确定要回到未来的哪个版本。     
-    ```
-    git log -p -2 // -p 是仅显示最近的x次提交   
-    git log --stat // stat简略的显示每次提交的内容梗概，如哪些文件变更，多少删除，多少添加
-    git log --oneline --graph
-    git log --grep="1"
-    ```
-    下面是常用的参数:   
-    - `–-author=“Alex Kras”` ——只显示某个用户的提交任务
-    - `–-name-only` ——只显示变更文件的名称
-    - `–-oneline`——将提交信息压缩到一行显示
-    - `–-graph` ——显示所有提交的依赖树
-    - `–-reverse` ——按照逆序显示提交记录（最先提交的在最前面）
-    - `–-after` ——显示某个日期之后发生的提交
-    - `–-before` ——显示发生某个日期之前的提交
-    - `--grep` ——过滤内容
+用`git log`可以查看提交历史，以便确定要回退到哪个版本。
+如果已经使用`git log`查出版本`commit id`后`reset`到某一次提交后，又要重返回来，
+用`git reflog`查看命令历史，以便确定要回到未来的哪个版本。     
+```
+git log -p -2 // -p 是仅显示最近的x次提交   
+git log --stat // stat简略的显示每次提交的内容梗概，如哪些文件变更，多少删除，多少添加
+git log --oneline --graph
+git log --grep="1"
+```
+下面是常用的参数:   
+- `–-author=“Alex Kras”` ——只显示某个用户的提交任务
+- `–-name-only` ——只显示变更文件的名称
+- `–-oneline`——将提交信息压缩到一行显示
+- `–-graph` ——显示所有提交的依赖树
+- `–-reverse` ——按照逆序显示提交记录（最先提交的在最前面）
+- `–-after` ——显示某个日期之后发生的提交
+- `–-before` ——显示发生某个日期之前的提交
+- `--grep` ——过滤内容
 
 #### Git日志搜索
 如果你想知道某一个东西是什么时候存在或者引入的。git log命令有许多强大的工具可以通过提交信息甚至是diff的内容来找到某个特定的提交。
 例如，如果我们想找到ZLIB_BUF_MAX常量是什么时候引入的，我们可以使用-S选项来显示新增和删除该字符串的提交:   
+
 ```shell
 git log -S ZLIB_BUF_MAX --oneline
+```
+### `git reflog`                
+可以查看所有操作记录包括`commit`和`reset`操作以及删除的`commit`记录
 
+### `git reset`
 
-- `git reflog`                
-    可以查看所有操作记录包括`commit`和`reset`操作以及删除的`commit`记录
-
-### `git reset`       
-    `git reset`命令用于将当前HEAD复位到指定状态。一般用于撤消之前的一些操作(如:`git add`,`git commit`等)。                 
-    在`git`的一般使用中，如果发现错误的将不想暂存的文件被`git add`进入索引之后，想回退取消，则可以使用命令:`git reset HEAD <file>`，
-    同时`git add`完毕之后，`git`也会做相应的提示，比如:    
-    ```shell
-    # Changes to be committed: 
-    #   (use "git reset HEAD <file>..." to unstage) 
-    # 
-    # new file:   test.py
-    ```
-    `git reset [--hard|soft|mixed|merge|keep] [<commit>或HEAD]`:将当前的分支重设`(reset)`到指定的`<commit>`或者`HEAD`(默认，如果不显示指定`<commit>`，默认是`HEAD`，即最新的一次提交)，并且根据`[mode]`有可能更新索引和工作目录。`mode`的取值可以是`hard、soft、mixed、merged、keep`。下面来详细说明每种模式的意义和效果:    
-    - `--hard`:彻底回退到某一个版本，本地的源码也会变为上一个版本的内容。重删除工作空间改动代码，撤销commit，撤销git add .。所有变更集都会被丢弃。
-    - `--mixed`:默认方式，它回退到某个版本，只保留源码，不删除工作空间改动代码，撤销commit，并且撤销git add . 。所有变更集都放在工作区。
-    - `--soft`: 回退到某个版本，不删除工作空间改动代码，撤销commit，不撤销git add . ，所有变更集都放在暂存区，如果还要提交直接重新commit即可。     
-
-    下面是具体一个例子，假设有三个`commit`，执行`git status`结果如下:     
-    ```
-    commit3: add test3.c
-    commit2: add test2.c
-    commit1: add test1.c
-    ```
-    执行`git reset --hard HEAD~1`命令后，
-    显示:`HEAD is now at commit2`，运行`git log`，如下所示:     
-    ```
-    commit2: add test2.c
-    commit1: add test1.c
-    ```
-
-    - 回滚最近一次提交
+`git reset`命令用于将当前HEAD复位到指定状态。一般用于撤消之前的一些操作(如:`git add`,`git commit`等)。                 
+在`git`的一般使用中，如果发现错误的将不想暂存的文件被`git add`进入索引之后，想回退取消，则可以使用命令:`git reset HEAD <file>`，
+同时`git add`完毕之后，`git`也会做相应的提示，比如:    
+```shell
+# Changes to be committed: 
+#   (use "git reset HEAD <file>..." to unstage) 
+# 
+# new file:   test.py
+```
 
-    ```
-    $ git commit -a -m "这是提交的备注信息"
-    $ git reset --soft HEAD^      #(1) 
-    $ edit code                        #(2) 编辑代码操作
-    $ git commit -a -c ORIG_HEAD  #(3)
-    ```
+`git reset [--hard|soft|mixed|merge|keep] [<commit>或HEAD]`:将当前的分支重设`(reset)`到指定的`<commit>`或者`HEAD`(默认，如果不显示指定`<commit>`，默认是`HEAD`，即最新的一次提交)，并且根据`[mode]`有可能更新索引和工作目录。`mode`的取值可以是`hard、soft、mixed、merged、keep`。下面来详细说明每种模式的意义和效果:    
+   - `--hard`:彻底回退到某一个版本，本地的源码也会变为上一个版本的内容。重删除工作空间改动代码，撤销commit，撤销git add .。所有变更集都会被丢弃。
+   - `--mixed`:默认方式，它回退到某个版本，只保留源码，不删除工作空间改动代码，撤销commit，并且撤销git add . 。所有变更集都放在工作区。
+   - `--soft`: 回退到某个版本，不删除工作空间改动代码，撤销commit，不撤销git add . ，所有变更集都放在暂存区，如果还要提交直接重新commit即可。     
 
-    - `Git`中用`HEAD`表示当前版本，上一版本就是`HEAD^`,上上一版本就是`HEAD^^`.如果往前一千个版本呢？ 那就是`HEAD~1000`.             
-    `git reset —-hard HEAD^`       
-    `git reset —-hard commit_id`
-    `git reset HEAD fileName`可以把用`git add`之后但是还没有`commit`之前暂存区中的修改撤销。          
-    说到这里就说一个问题，如果你reset到某一个版本之后，发现弄错了，还想返回去，这时候用`git log`已经找不到之前的`commit id`了。那怎么办？这时候可以使用下面的命令来找。
+#### 示例
 
-假设我们进入到一个新目录，其中有一个文件。 我们称其为该文件的 v1 版本，将它标记为蓝色。 现在运行 git init，这会创建一个 Git 仓库，其中的 HEAD 引用指向未创建的 master 分支。
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-ex1.png?raw=true)        
+假设我们进入到一个新目录，其中有一个文件。 我们称其为该文件的 v1 版本，将它标记为蓝色。 现在运行 git init，这会创建一个 Git 仓库，其中的 HEAD 引用指向未创建的 master 分支。 
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-ex1.png?raw=true)      
 此时，只有工作目录有内容。
 现在我们想要提交这个文件，所以用git add来获取工作目录中的内容，并将其复制到索引中。 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-ex2.png?raw=true)        
@@ -276,7 +248,7 @@ git log -S ZLIB_BUF_MAX --oneline
 此时如果我们运行 git status，会发现没有任何改动，因为现在三棵树完全相同。
 
 现在我们想要对文件进行修改然后提交它。 我们将会经历同样的过程；首先在工作目录中修改文件。 我们称其为该文件的 v2 版本，并将它标记为红色。
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-ex4?raw=true)        
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-ex4.png?raw=true)        
 如果现在运行 git status，我们会看到文件显示在 “Changes not staged for commit” 下面并被标记为红色，因为该条目在索引与工作目录之间存在不同。 接着我们运行 git add 来将它暂存到索引中。
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-ex5.png?raw=true)        
 此时，由于索引和 HEAD 不同，若运行 git status 的话就会看到 “Changes to be committed” 下的该文件变为绿色 ——也就是说，现在预期的下一次提交与上一次提交不同。 最后，我们运行 git commit 来完成提交。
@@ -342,20 +314,21 @@ reset 命令会以特定的顺序重写这三棵树，在你指定以下选项
 
 
 
-- `git checkout`撤销修改或者切换分支           
-    `git checkout -- xx.txt`意思就是将`xx.txt`文件在工作区的修改全部撤销。可能会有两种情况:      
-    
-    - 修改后还没有调用`git add`添加到暂存区，现在撤销后就会和版本库一样的状态。
-    - 修改后已经调用`git add`添加到暂存区后又做了修改，这时候撤销就会回到暂存区的状态。
+### `git checkout`撤销修改或者切换分支           
+`git checkout -- xx.txt`意思就是将`xx.txt`文件在工作区的修改全部撤销。可能会有两种情况:      
+
+- 修改后还没有调用`git add`添加到暂存区，现在撤销后就会和版本库一样的状态。
+- 修改后已经调用`git add`添加到暂存区后又做了修改，这时候撤销就会回到暂存区的状态。
 
-    总的来说`git checkout`就是让这个文件回到最近一次`git commit`或者`git add`的状态。
-    这里还有一个问题就是我胡乱修改了某个文件内容然后调用了`git add`添加到缓存区中，这时候想丢弃修改该怎么办？也是要分两步:
-    - 使用`git reset HEAD file`命令，将暂存区中的内容回退，这样修改的内容会从暂存区回到工作区。             
-    - 使用`git checkout --file`直接丢弃工作区的修改。            
+总的来说`git checkout`就是让这个文件回到最近一次`git commit`或者`git add`的状态。
+这里还有一个问题就是我胡乱修改了某个文件内容然后调用了`git add`添加到缓存区中，这时候想丢弃修改该怎么办？也是要分两步:
 
-    `git checkout`把当前目录所有修改的文件从`HEAD`都撤销修改。        
-    为什么分支的地方也是用`git checkout`这里撤销还是用它呢？他们的区别在于`--`，如果没有`--`那就是检出分支了。
-    `git checkout origin/developer`  // 切换到orgin/developer分支   
+- 使用`git reset HEAD file`命令，将暂存区中的内容回退，这样修改的内容会从暂存区回到工作区。             
+- 使用`git checkout --file`直接丢弃工作区的修改。            
+
+`git checkout`把当前目录所有修改的文件从`HEAD`都撤销修改。        
+为什么分支的地方也是用`git checkout`这里撤销还是用它呢？他们的区别在于`--`，如果没有`--`那就是检出分支了。
+`git checkout origin/developer`  // 切换到orgin/developer分支   
 
 上面介绍了两个回退操作`git reset`和`git checkout`，这里就总结一下如何来对修改进行撤销操作:     
 
@@ -394,7 +367,9 @@ reset 命令会以特定的顺序重写这三棵树，在你指定以下选项
     git reset --hard HEAD^  // HEAD^代表最新提交的前一次  
     git push -f  // 强制推送
     ```
-#### reset checkout的区别
+
+### reset checkout的区别
+
 你大概还想知道 checkout 和 reset 之间的区别。 和 reset 一样，checkout 也操纵三棵树，不过它有一点不同，这取决于你是否传给该命令一个文件路径。
 
 不带路径
@@ -408,21 +383,20 @@ reset 命令会以特定的顺序重写这三棵树，在你指定以下选项
 
 所以，虽然在这两种情况下我们都移动 HEAD 使其指向了提交 A，但 做法 是非常不同的。 reset 会移动 HEAD 分支的指向，而 checkout 则移动 HEAD 自身。
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-checkout.png?raw=true)        
-带路径
+#### 带路径
 运行 checkout 的另一种方式就是指定一个文件路径，这会像 reset 一样不会移动 HEAD。 它就像 git reset [branch] file 那样用该次提交中的那个文件来更新索引，但是它也会覆盖工作目录中对应的文件。 它就像是 git reset --hard [branch] file（如果 reset 允许你这样运行的话）， 这样对工作目录并不安全，它也不会移动 HEAD。
 
 此外，同 git reset 和 git add 一样，checkout 也接受一个 --patch 选项，允许你根据选择一块一块地恢复文件内容。
 
+### `git revert`撤销提交   
+`git revert`在撤销一个提交的同时会创建一个新的提交，这是一个安全的方法，因为它不会重写提交历史。
 
-- `git revert`撤销提交   
-    `git revert`在撤销一个提交的同时会创建一个新的提交，这是一个安全的方法，因为它不会重写提交历史。
+- `git revert`是生成一个新的提交来撤销某次提交，此次提交之前的`commit`都会被保留
+- `git reset`是回到某次提交，提交及之前的`commit`都会被保留，但是此次之后的修改都会被退回到暂存区     
 
-    - `git revert`是生成一个新的提交来撤销某次提交，此次提交之前的`commit`都会被保留
-    - `git reset`是回到某次提交，提交及之前的`commit`都会被保留，但是此次之后的修改都会被退回到暂存区     
-    
-    相比`git reset`它不会改变现在得提交历史。`git reset`是直接删除制定的`commit`
-    并把`HEAD`向后移动了一下。而`git revert`是一次新的特殊的`commit`，`HEAD`继续前进，本质和普通`add commit`一样，仅仅是`commit`内容很特殊。内容是与前面普通`commit`变化的反操作。
-    比如前面普通`commit`是增加一行`a`，那么`revert`内容就是删除一行`a`。
+相比`git reset`它不会改变现在得提交历史。`git reset`是直接删除制定的`commit`
+并把`HEAD`向后移动了一下。而`git revert`是一次新的特殊的`commit`，`HEAD`继续前进，本质和普通`add commit`一样，仅仅是`commit`内容很特殊。内容是与前面普通`commit`变化的反操作。
+比如前面普通`commit`是增加一行`a`，那么`revert`内容就是删除一行`a`。
 在 Git 开发中通常会控制主干分支的质量，但有时还是会把错误的代码合入到远程主干。 虽然可以直接回滚远程分支， 但有时新的代码也已经合入，直接回滚后最近的提交都要重新操作。 那么有没有只移除某些 Commit 的方式呢？可以一次 revert操作来完成。
 
 考虑这个例子，我们提交了 6 个版本，其中 3-4 包含了错误的代码需要被回滚掉。 同时希望不影响到后续的 5-6。
@@ -457,73 +431,75 @@ git commit -a -m 'This reverts commit 7e345c9 and 551c408'
 ```
 现在的 HEAD（8fef80a）就是我们想要的版本，把它 Push 到远程即可。
 
+git revert 命令本质上就是一个逆向的 git cherry-pick 操作。 它将你提交中的变更的以完全相反的方式的应用到一个新创建的提交中，本质上就是撤销或者倒转。
 
+### `git rm`删除文件     
+该文件就不再纳入版本管理了。如果删除之前修改过并且已经放到暂存区域的话，则必须要用强制删除选项 -f（译注：即 force 的首字母），以防误删除文件后丢失修改的内容。
+另外一种情况是，我们想把文件从 Git 仓库中删除（亦即从暂存区域移除），但仍然希望保留在当前工作目录中。换句话说，仅是从跟踪清单中删除。比如一些大型日志文件或者一堆 .a 编译文件，不小心纳入仓库后，要移除跟踪但不删除文件，以便稍后在 .gitignore 文件中补上，用 --cached 选项即可：`git rm --cached readme.txt`   
 
-git revert 命令本质上就是一个逆向的 git cherry-pick 操作。 它将你提交中的变更的以完全相反的方式的应用到一个新创建的提交中，本质上就是撤销或者倒转。
+### 分支                   
+`git`分支的创建和合并都是非常快的，因为增加一个分支其实就是增加一个指针，合并其实就是让某个分支的指针指向某一个位置。        
+ ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_master_branch.png?raw=true) 
 
-- `git rm`删除文件     
-    该文件就不再纳入版本管理了。如果删除之前修改过并且已经放到暂存区域的话，则必须要用强制删除选项 -f（译注：即 force 的首字母），以防误删除文件后丢失修改的内容。
-    另外一种情况是，我们想把文件从 Git 仓库中删除（亦即从暂存区域移除），但仍然希望保留在当前工作目录中。换句话说，仅是从跟踪清单中删除。比如一些大型日志文件或者一堆 .a 编译文件，不小心纳入仓库后，要移除跟踪但不删除文件，以便稍后在 .gitignore 文件中补上，用 --cached 选项即可：`git rm --cached readme.txt`   
+#### 创建分支                   
 
+`git branch devBranch`创建名为`devBranch`的分支。          
+`git checkout devBranch`切换到`devBranch`分支。            
+`git checkout -b devBranch`创建+切换到分支`devBranch`。
+`git branch`查看当前仓库中的分支。                   
+`git branch -r`查看远程仓库的分支。
+`git branch -d devBranch`删除`devBranch`分支。            
 
-- 分支                   
-    `git`分支的创建和合并都是非常快的，因为增加一个分支其实就是增加一个指针，合并其实就是让某个分支的指针指向某一个位置。        
- ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_master_branch.png?raw=true) 
+```
+origin/HEAD -> origin/master
+origin/developer
+origin/developer_sg
+origin/master
+origin/master_sg
+origin/offline
+```
+`git branch -d devBranch`删除`devBranch`分支。           
+当时如果在新建了一个分支后进行修改但是还没有合并到其他分支的时候就去使用`git branch -d xxx`删除的时候系统会手提示说这个分支没有被合并，删除失败。
+这时如果你要强行删除的话可以使用命令`git branch -D xxx`.
+如何删除远程分支呢？
+```
+git branch -r -d origin/developer
+git push origin :developer
+```
+如何本地创建分支并推送给远程仓库？
+```
+// 本地创建分支
+git checkout master //进入master分支
+git checkout -b frommaster //以master为源创建分支frommaster
+// 推送到远程仓库
+git push origin frommaster// 推送到远程仓库所要使用的名字
+```
 
-- 创建分支                   
+如何切到到远程仓库分支进行开发呢？         
+`git checkout -b frommaster origin/frommaster`
+// 本地新建frommaster分支并且与远程仓库的frommaster分支想关联
+提交更改的话就用 
+`git push origin frommaster`
+
+// 重命名分支    
+`git branch -m new_branch wchar_support`
+// 查看每一个分支的最后一次提交
+`git branch -v`
+
+#### `git merge`合并指定分支到当前分支
+
+`git merge devBranch`将`devBranch`分支合并到`master`。          
+
+### 打`tag`                   
+`git tag v1.0`来进行打`tag`，默认为`HEAD`             
+`git tag`查看所有`tag`          
+如果我想在之前提交的某次`commit`上打`tag`，`git tag v1.0 commitID`     
+当然也可以在打`tag`时带上参数 `git tag v1.0 -m "version 1.0 released" commitID`
+`git tag -d xxx`删除xxx
+
+`git show tagName`来查看某`tag`的详细信息。          
 
-    `git branch devBranch`创建名为`devBranch`的分支。          
-    `git checkout devBranch`切换到`devBranch`分支。            
-    `git checkout -b devBranch`创建+切换到分支`devBranch`。
-    `git branch`查看当前仓库中的分支。                   
-    `git branch -r`查看远程仓库的分支。
-    `git branch -d devBranch`删除`devBranch`分支。            
-    ```
-    origin/HEAD -> origin/master
-    origin/developer
-    origin/developer_sg
-    origin/master
-    origin/master_sg
-    origin/offline
-    ```
-    `git branch -d devBranch`删除`devBranch`分支。           
-    当时如果在新建了一个分支后进行修改但是还没有合并到其他分支的时候就去使用`git branch -d xxx`删除的时候系统会手提示说这个分支没有被合并，删除失败。
-    这时如果你要强行删除的话可以使用命令`git branch -D xxx`.
-    如何删除远程分支呢？
-    ```
-    git branch -r -d origin/developer
-    git push origin :developer
-    ```
-    如何本地创建分支并推送给远程仓库？
-    ```
-    // 本地创建分支
-    git checkout master //进入master分支
-    git checkout -b frommaster //以master为源创建分支frommaster
-    // 推送到远程仓库
-    git push origin frommaster// 推送到远程仓库所要使用的名字
-    ```
 
-    如何切到到远程仓库分支进行开发呢？         
-    `git checkout -b frommaster origin/frommaster`
-    // 本地新建frommaster分支并且与远程仓库的frommaster分支想关联
-    提交更改的话就用 
-    `git push origin frommaster`
-
-    // 重命名分支    
-    `git branch -m new_branch wchar_support`
-    // 查看每一个分支的最后一次提交
-    `git branch -v`
-- `git merge`合并指定分支到当前分支                         
-   `git merge devBranch`将`devBranch`分支合并到`master`。          
-
-- 打`tag`                   
-    `git tag v1.0`来进行打`tag`，默认为`HEAD`             
-    `git tag`查看所有`tag`          
-    如果我想在之前提交的某次`commit`上打`tag`，`git tag v1.0 commitID`     
-    当然也可以在打`tag`时带上参数 `git tag v1.0 -m "version 1.0 released" commitID`
-    `git tag -d xxx`删除xxx
-
-    `git show tagName`来查看某`tag`的详细信息。          
 - 打完`tag`后怎么推送到远程仓库         
     `git push origin tagName`      
 
@@ -535,21 +511,19 @@ git revert 命令本质上就是一个逆向的 git cherry-pick 操作。 它将
 
 - 忽略文件                
     在`git`根目录下创建一个特殊的`.gitignore`文件，把想要忽略的文件名填进去就可以了,匹配模式最后跟斜杠(/)说明要忽略的是目录,#是注释 。
-    其实不用一个个的去写，具体可以根据项目参考[https://github.com/github/gitignore](https://github.com/github/gitignore)
-    当然不要忘了把该文件提交上去                
-    在用`linux`的时候会自动生成一些以`~`结尾的备份文件，如果ignore掉呢？[https://github.com/github/gitignore/blob/master/Global/Linux.gitignore](https://github.com/github/gitignore/blob/master/Global/Linux.gitignore)
 
 ### amend修改最后一次提交
-    有时候我们提交完了才发现漏掉了几个文件没有加或者提交信息写错了，想要撤销刚才的的提交操作。可以修改后重新git add 然后使用`--amend`选项重新提交:`git commit --amend`，然后再执行`git push`操作。
 
-修补后的提交可能需要修补提交信息
-当你在修补一次提交时，可以同时修改提交信息和提交内容。 如果你修补了提交的内容，那么几乎肯定要更新提交消息以反映修改后的内容。
+有时候我们提交完了才发现漏掉了几个文件没有加或者提交信息写错了，想要撤销刚才的的提交操作。可以修改后重新git add 然后使用`--amend`选项重新提交:`git commit --amend`，然后再执行`git push`操作。
+
+修补后的提交可能需要修补提交信息，当你在修补一次提交时，可以同时修改提交信息和提交内容。 如果你修补了提交的内容，那么几乎肯定要更新提交消息以反映修改后的内容。
 
 另一方面，如果你的修补是琐碎的（如修改了一个笔误或添加了一个忘记暂存的文件）， 那么之前的提交信息不必修改，你只需作出更改，暂存它们，然后通过以下命令避免不必要的编辑器环节即可：
 
 $ git commit --amend --no-edit
 
 #### 修改多个提交信息
+
 为了修改在提交历史中较远的提交，必须使用更复杂的工具。 Git 没有一个改变历史工具，但是可以使用变基工具来变基一系列提交，基于它们原来的 HEAD 而不是将其移动到另一个新的上面。 通过交互式变基工具，可以在任何想要修改的提交后停止，然后修改信息、添加文件或做任何想做的事情。 可以通过给 git rebase 增加 -i 选项来交互式地运行变基。 必须指定想要重写多久远的历史，这可以通过告诉命令将要变基到的提交来做到。
 
 例如，如果想要修改最近三次提交信息，或者那组提交中的任意一个提交信息， 将想要修改的最近一次提交的父提交作为参数传递给 git rebase -i 命令，即 HEAD~2^ 或 HEAD~3。 记住 ~3 可能比较容易，因为你正尝试修改最后三次提交；但是注意实际上指定了以前的四次提交，即想要修改提交的父提交：
@@ -564,50 +538,45 @@ $ git commit --amend
 $ git rebase --continue
 这个命令将会自动地应用另外两个提交，然后就完成了。 如果需要将不止一处的 pick 改为 edit，需要在每一个修改为 edit 的提交上重复这些步骤。 每一次，Git 将会停止，让你修正提交，然后继续直到完成。
 
-- 查看远程仓库克隆地址
-    `git remote -v`
+### 查看远程仓库克隆地址
+`git remote -v`
 
 关于`git`的工作区、缓存区可以看下图`index`标记部分的区域就是暂存区                     
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_stage.jpg?raw=true)         
 
 从这个图中能看到缓存区的存在，这就是为什么我们新加或者修改之后都要调用`git add`方法后再调用`git commit`。              
-其实我一直有点分不开`reset`和`checkout`的区别，从这个图里能明显看出来了：
 
-- **取消暂存** 当执行`git reset HEAD`命令时，暂存区的目录树会被重写，会被`master`分支指向的目录树所替换，但是工作区不受影响。所以如果我们修改了一个问题，执行了add之后，还没有commit这时候想要取消add，可以执行git reset HEAD XXX
 
-- **撤销对文件的修改，将它还原成上次提交时的样子或者刚克隆完的样** 当执行`git checkout .`或`git checkout -- file`命令是，会用暂存区全部的文件或指定的文件替换工作区的文件。这个操作很危险，会清除工作区中未添加到暂存区的改动。
-  命令时，会用`HEAD`指向的`master`分支中的全部或部分文件替换暂存区和工作区中的文件。这个命令也是极度危险的。因为不但会清楚工作区中未提交的改动，也会清楚暂存区中未提交的改动。
+### stash(贮藏)
 
-- `git reset HEAD <file>` 是在添加到暂存区后，撤出暂存区使用，他只会把文件撤出暂存区，但是你的修改还在，仍然在工作区。当然如果使用`git reset --hard HEAD`这样就完了，工作区所有的内容都会被远程仓库最新代码覆盖。
+stash会处理工作目录的脏的文件--即跟踪文件的修改与暂存的改动--然后将未完成的修改保存到一个栈上，而你可以在任何时候重新应用这些改动（甚至在不同的分支上）。
+假设你现在在`a`分支上开发新版本内容，已经开发了一部分，但是还没有达到可以提交的程度。你需要切换到`b`分支进行另一个升级的开发。那么可以把当前工作的改变隐藏起来，要将一个新的存根推到堆栈上，运行`git stash`命令。   
 
-- `git checkout -- xxx.txt`是用于修改后未添加到暂存区时使用(如果修改后添加到暂存区后就没效果了，必须要先`reset`撤销暂存区后再使用`checkout`)，这时候会把之前的修改覆盖掉。所以是危险的。 你对那个文件在本地的任何修改都会消失——Git 会用最近提交的版本覆盖掉它。 除非你确实清楚不想要对那个文件的本地修改了，否则请不要使用这个命令
+```shell
+$ git stash
+Saved working directory and index state WIP on master: ef07ab5 synchronized with the remote repository
+HEAD is now at ef07ab5 synchronized with the remote repository
+```
 
-### stash(贮藏)     
-stash会处理工作目录的脏的文件--即跟踪文件的修改与暂存的改动--然后将未完成的修改保存到一个栈上，而你可以在任何时候重新应用这些改动（甚至在不同的分支上）。
-    假设你现在在`a`分支上开发新版本内容，已经开发了一部分，但是还没有达到可以提交的程度。你需要切换到`b`分支进行另一个升级的开发。那么可以
-    把当前工作的改变隐藏起来，要将一个新的存根推到堆栈上，运行`git stash`命令。   
+现在，工作目录是干净的，所有更改都保存在堆栈中。 现在使用`git status`命令来查看当前工作区状态:   
 
-    ```shell
-    $ git stash
-    Saved working directory and index state WIP on master: ef07ab5 synchronized with the remote repository
-    HEAD is now at ef07ab5 synchronized with the remote repository
-    ```
-    现在，工作目录是干净的，所有更改都保存在堆栈中。 现在使用`git status`命令来查看当前工作区状态:   
-    ```shell
-    $ git status
-    On branch master
-    Your branch is up-to-date with 'origin/master'.
-    
-    nothing to commit, working directory clean
-    ```
+```shell
+$ git status
+On branch master
+Your branch is up-to-date with 'origin/master'.
 
-    现在，可以安全地切换分支并在其他地方工作。通过使用`git stash list`命令来查看已存在更改的列表。
-    ```shell
-    $ git stash list
-    stash@{0}: WIP on master: ef07ab5 synchronized with the remote repository
-    ```
-    这个命令所储藏的修改可以使用`git stash list`列出，使用`git stash show`进行检查，并使用`git stash apply`或`git stash apply stash@{2}`恢复(可能在不同的提交之上)。或者可以用git stash pop将最近的一次stash恢复。调用没有任何参数的`git stash`相当于`git stash save`。在17年10月下旬Git讨论废弃了git stash save命令，代之以现有的git stash push命令。
-    可以使用git stash drop加上要移除的贮藏的名字来移除它。
+nothing to commit, working directory clean
+```
+
+现在，可以安全地切换分支并在其他地方工作。通过使用`git stash list`命令来查看已存在更改的列表。
+
+```shell
+$ git stash list
+stash@{0}: WIP on master: ef07ab5 synchronized with the remote repository
+```
+
+这个命令所储藏的修改可以使用`git stash list`列出，使用`git stash show`进行检查，并使用`git stash apply`或`git stash apply stash@{2}`恢复(可能在不同的提交之上)。或者可以用git stash pop将最近的一次stash恢复。调用没有任何参数的`git stash`相当于`git stash save`。在17年10月下旬Git讨论废弃了git stash save命令，代之以现有的git stash push命令。
+可以使用git stash drop加上要移除的贮藏的名字来移除它。
 
 
 
@@ -615,7 +584,7 @@ stash会处理工作目录的脏的文件--即跟踪文件的修改与暂存的
 你想要查看 experiment 分支中还有哪些提交尚未被合并入 master 分支。 你可以使用 master..experiment 来让 Git 显示这些提交。也就是“在 experiment 分支中而不在 master 分支中的提交”。 
 ```shell
 git log master..experiment
-```    
+```
 #### 三点
 这个语法可以选择出被两个引用 之一 包含但又不被两者同时包含的提交。 再看看之前双点例子中的提交历史。 如果你想看 master 或者 experiment 中包含的但不是两者共有的提交，你可以执行：
 ```shell
@@ -624,8 +593,9 @@ git log master...experiment
 
 
 ### Rebase操作
-    官网中将rebase翻译为变基，我感觉理解成改变基点，重新实现更容易理解一些。
-    假设目前除master分支之外还有一个experiment分支: 
+官网中将rebase翻译为变基，我感觉理解成改变基点，重新实现更容易理解一些。
+假设目前除master分支之外还有一个experiment分支: 
+
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/basic-rebase-1.png?raw=true)        
 我们现在想要把master分支merge一下experiment分支的最新代码。整合分支最容易的方法是merge命令。它会把这两个分支的最新快照(C3和C4)以及两者最近的共同祖先(C2)进行三方合并，合并的结果是生成一个新的快照(C5)并提交。
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/basic-rebase-2.png?raw=true)        
@@ -722,64 +692,26 @@ git merge server
 
 
 
+### git fetch与git pull的区别
 
+`git`中`fetch`命令是将远程分支的最新内容拉到了本地，但是`fecth`后是看不到变化的，如果查看当前的分支，会发现此时本地多了一个`FETCH_HEAD`的指针，`checkout`到该指针后才可以查看远程分支的最新内容。
 
+而`git pull`的作用相当于`fetch`和`merge`的组合，会自动合并:
 
+```git 
+git fetch origin master
+git merge FETCH_HEAD
+```
 
+### git pull 与git pull --rebase的使用
 
- 
+使用下面的关系区别这两个操作:   
 
-    多人在同一个分支上协作时，很容易出现冲突，即使没有冲突，在`push`代码之前也要先`pull`，在本地合并后再`push`，所以就经常会出现这样的分支:
 ```git
-$ git log --graph --pretty=oneline --abbrev-commit
-* d1be385 (HEAD -> master, origin/master) init hello
-*   e5e69f1 Merge branch 'dev'
-|\  
-| *   57c53ab (origin/dev, dev) fix env conflict
-| |\  
-| | * 7a5e5dd add env
-| * | 7bd91f1 add new env
-| |/  
-* |   12a631b merged bug fix 101
-|\ \  
-| * | 4c805e2 fix bug 101
-|/ /  
-* |   e1e9c68 merge with no-ff
-|\ \  
-| |/  
-| * f52c633 add merge
-|/  
-*   cf810e4 conflict fixed
+git pull = git fetch + git merge
+git pull --rebase = git fetch + git rebase
 ```
-看上去会很乱，有些强迫症的人会问：为什么`Git`的提交历史不能是一条干净的直线？
-`rebase`操作就是解决这个问题的，它可以把分叉的提交历史整理变成一条直线，看上去更直观。缺点是本地的分叉提交已经被修改过了。 
-
-也就是说`gie merge`和`git rebase`做的事情其实是一样的。它们都被设计来将一个分支的更改并入到另一个分支中。
-
-- git fetch与git pull的区别
-
-    `git`中`fetch`命令是将远程分支的最新内容拉到了本地，但是`fecth`后是看不到变化的，如果查看当前的分支，会发现此时本地多了一个`FETCH_HEAD`的指针，`checkout`到该指针后才可以查看远程分支的最新内容。
-
-    而`git pull`的作用相当于`fetch`和`merge`的组合，会自动合并:
-
-    ```git 
-    git fetch origin master
-    git merge FETCH_HEAD
-    ```
-
-- git pull 与git pull --rebase的使用
-
-    使用下面的关系区别这两个操作:   
-
-    ```git
-    git pull = git fetch + git merge
-    git pull --rebase = git fetch + git rebase
-    ```
-    `git rebase`的过程中，有时会有`conflit`这时`Git`会停止`rebase`并让用户去解决冲突，解决完冲突后，用`git add`命令去更新这些内容，然后不用执行`git commit`，直接执行`git rebase --continue`这样`git`会继续`apply`余下的补丁。   
-
-
-
-尝试让每一个提交成为一个逻辑上的独立变更集。 如果可以，尝试让改动可以理解——不要在整个周末编码解决五个问题，然后在周一时将它们提交为一个巨大的提交。 即使在周末期间你无法提交，在周一时使用暂存区域将你的工作最少拆分为每个问题一个提交，并且为每一个提交附带一个有用的信息。 如果其中一些改动修改了同一个文件，尝试使用 git add --patch 来部分暂存文件（在 交互式暂存 中有详细介绍）。 不管你做一个或五个提交，只要所有的改动是在同一时刻添加的，项目分支末端的快照就是独立的，使同事开发者必须审查你的改动时尽量让事情容易些。
+`git rebase`的过程中，有时会有`conflit`这时`Git`会停止`rebase`并让用户去解决冲突，解决完冲突后，用`git add`命令去更新这些内容，然后不用执行`git commit`，直接执行`git rebase --continue`这样`git`会继续`apply`余下的补丁。   
 
 
 
diff --git "a/JavaKnowledge/Vim\344\275\277\347\224\250\346\225\231\347\250\213.md" "b/JavaKnowledge/Vim\344\275\277\347\224\250\346\225\231\347\250\213.md"
index 32f99d97..eef7b2d9 100644
--- "a/JavaKnowledge/Vim\344\275\277\347\224\250\346\225\231\347\250\213.md"
+++ "b/JavaKnowledge/Vim\344\275\277\347\224\250\346\225\231\347\250\213.md"
@@ -42,8 +42,10 @@ Vim使用教程
 - `#l` 移动光标到该行第#个字的位置，如`5l`
 - `ctrl+g` 列出当前光标所在行的行号等信息
 - `: #` 如输入: 15会跳到文章的第15行
-- `ctrl + d`向下翻页
-- `ctrl + u`向上翻页
+- `ctrl+b`:向上滚动一屏
+- `ctrl+f`:向下滚动一屏
+- `ctrl+u`:向上滚动半屏
+- `ctrl+d`:向下滚动半屏
 
 删除文字
 ---
diff --git "a/JavaKnowledge/\345\274\272\345\274\225\347\224\250\343\200\201\350\275\257\345\274\225\347\224\250\343\200\201\345\274\261\345\274\225\347\224\250\343\200\201\350\231\232\345\274\225\347\224\250.md" "b/JavaKnowledge/\345\274\272\345\274\225\347\224\250\343\200\201\350\275\257\345\274\225\347\224\250\343\200\201\345\274\261\345\274\225\347\224\250\343\200\201\350\231\232\345\274\225\347\224\250.md"
index e5dba493..769efa0b 100644
--- "a/JavaKnowledge/\345\274\272\345\274\225\347\224\250\343\200\201\350\275\257\345\274\225\347\224\250\343\200\201\345\274\261\345\274\225\347\224\250\343\200\201\350\231\232\345\274\225\347\224\250.md"
+++ "b/JavaKnowledge/\345\274\272\345\274\225\347\224\250\343\200\201\350\275\257\345\274\225\347\224\250\343\200\201\345\274\261\345\274\225\347\224\250\343\200\201\350\231\232\345\274\225\347\224\250.md"
@@ -23,12 +23,10 @@
   
 - 软引用(SoftReference)
   
-    描述一些还有用，但并非必需的对象。如果一个对象只具有软引用，那就类似于可有可物的生活用品。如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存，但是system.gc对其无效，有点像老板(OOM)的亲戚，在公司表现不好有可能会被开除，即使你投诉他（调用GC)上班看片，但是只要不被老板看到（被JVM检测到）就不会被开除（被虚拟机回收）。
+    描述一些还有用，但并非必需的对象。如果一个对象只具有软引用，那就类似于可有可物的生活用品。如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存，但是system.gc对其无效，有点像老板(OOM)的亲戚，在公司表现不好有可能会被开除，即使你投诉他（调用GC)上班看片，但是只要不被老板看到（被JVM检测到）就不会被开除（被虚拟机回收）。**软引用可用来实现内存敏感的高速缓存**。 软引用可以和一个引用队列`(ReferenceQueue)`联合使用，如果软引用所引用的对象被垃圾回收，`Java`虚拟机就会把这个软引用加入到与之关联的引用队列中。
+        
     
 
-**软引用可用来实现内存敏感的高速缓存**。 软引用可以和一个引用队列`(ReferenceQueue)`联合使用，
-    如果软引用所引用的对象被垃圾回收，`Java`虚拟机就会把这个软引用加入到与之关联的引用队列中。
-    
 - 弱引用(WeakReference)
   
     同软引用，也用来描述非必须对象，但是它的强度比软引用更弱一些，被弱引用关联的对象只能生存到下一次垃圾收集发生之前。所以弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的声明周期。在对象没有其他引用的情况下，调用system.gc对象可被虚拟机回收，就是一个普通的员工，平常如果表现不佳会被开除（对象没有其他引用的情况下），遇到别人投诉（调用GC)上班看片,那开除是肯定了(被虚拟机回收)。
diff --git "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md" "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
index c4e3454b..fe0de1b5 100644
--- "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
+++ "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
@@ -565,7 +565,7 @@ val bird1 = Bird(color = "black")
 val bird2 = Bird(weight = 1000.00, color = "black")
 ```
 
-上面在Bird类中使用了val或者var来声明构造方法的参数。这一方面代表了参数的引用可变性，另一方面也使得我们再构造类的语法上得到了简化。事实上，构造方法的参数名前当然可以没有val和var。然而带上它们之后就等价于在Bird类内部声明了一个同名的属性，我们可以用this来进行调用。比如，上面定义的Bird类就类似于一下实现:  
+上面在Bird类中使用了val或者var来声明构造方法的参数。这一方面代表了参数的引用可变性，另一方面也使得我们在构造类的语法上得到了简化。事实上，构造方法的参数名前当然可以没有val和var。然而带上它们之后就等价于在Bird类内部声明了一个同名的属性，我们可以用this来进行调用。比如，上面定义的Bird类就类似于一下实现:  
 
 ```kotlin
 // 构造方法参数名前没有val
@@ -583,7 +583,7 @@ class Bird (weight: Double = 0.00, age: Int = 0, color: String = "blue"){
 
 #### init语句块
 
-Kotlin引入了一种叫作init语句块的语法，它属于上述构造方法的一部分，两者在表现形式上确实分离的。Bird类的构造方法在类的外部，它只能对参数进行赋值。如果我们需要在初始化时进行其他的额外操作，那么我们就可以使用init语句块来执行。比如:  
+Kotlin引入了一种叫作init语句块的语法，它属于上述构造方法的一部分，两者在表现形式上确是分离的。Bird类的构造方法在类的外部，它只能对参数进行赋值。如果我们需要在初始化时进行其他的额外操作，那么我们就可以使用init语句块来执行。比如:  
 
 ```kotlin
 class Bird(weight: Double, aget: Int, color: String) {
@@ -1092,7 +1092,7 @@ fun main(args: Array<String>) {
 如果你有一个现有的值数组，则可以通过在数组名前加上`*`来将这些值传递给该函数。星号`（*）`被称为扩展运算符，以下是它的一些使用示例：
 
 ```kotlin
-vval myArray = arrayOf(1, 2, 3, 4, 5)
+val myArray = arrayOf(1, 2, 3, 4, 5)
 val mList = vars(*myArray)
 val mList2 = vars(0, *myArray, 6, 7)
 ```
diff --git "a/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md" "b/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
index 78f38efb..00f773c3 100644
--- "a/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
+++ "b/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
@@ -289,7 +289,7 @@ Runnable runnable2=()->{
 - 函数体(如果存在的话)在`->`后面。
 
 `Lambda`表达式是定义匿名函数的简单方法。由于`Lambda`表达式避免在抽象类或接口中编写明确的函数声明，进而也避免了类的实现部分，
-所以它是非常有用的。在`Kotlin`语言中，可以将一函数作为另一函数的参数。
+所以它是非常有用的。在`Kotlin`语言中，可以将一函数作为另一个函数的参数。
 
 `Lambda`表达式由箭头左侧函数的参数（在圆括号里的内容）定义的，将值返回到箭头右侧。
 `view.setOnClickListener({ view -> toast("Click")})`
@@ -373,7 +373,7 @@ Lambda类型也被认为是函数类型。
 
 
 
-## Lambda开销
+### Lambda开销
 
 ```kotlin
 fun foo(int: Int) = {
@@ -388,13 +388,7 @@ listOf(1, 2, 3).forEach { foo(it) } // 对一个整数列表的元素遍历调
 listOf(1, 2, 3).forEach { item -> foo(item) }
 ```
 
-默认情况下，我们可以直接用it来代表item，而不需要用item -> 进行声明。
-
-你可以将单独的参数替换为it。
-
-如果lambda具有一个单独的参数，而且编译器能够推断其类型，你可以省略该参数，并在lambda的主体中使用关键字it指代它。
-
-要了解它是如何工作的，如前所述，假设使用以下代码将lambda赋值给变量：
+如果lambda具有一个单独的参数，而且编译器能够推断其类型，你可以省略该参数，并在lambda的主体中使用关键字it指代它。要了解它是如何工作的，如前所述，假设使用以下代码将lambda赋值给变量：
 
 ```kotlin
 val addFive: (Int) -> Int = { x -> x + 5 }
@@ -445,8 +439,9 @@ Kotlin在JVM层设计了Function类型(Function0、Function1 ... Function22、Fu
 
 ```kotlin
 package kotlin.jvm.functions
-interface Function1<in P1, out R> : kotlin.Function<R> {
-    fun invoke(p1: P1) : R
+public interface Function1<in P1, out R> : Function<R> {
+    /** Invokes the function with the specified argument. */
+    public operator fun invoke(p1: P1): R
 }
 ```
 
@@ -469,13 +464,11 @@ listOf(1, 2, 3).forEach { foo(it).invoke() } // 增加了invoke调用
 listOf(1, 2, 3).forEach{ foo(it)() }
 ```
 
-#### 闭包
+## 闭包
 
-在Kotlin中，你会发现匿名函数体、Lambda在语法上都存在“{}"，由这对花括号包裹的代码如果访问了外部环境变量则被称为一个闭包。
+在Kotlin中，你会发现匿名函数体、Lambda在语法上都存在“{}"，由这对花括号包裹的代码如果访问了外部环境变量则被称为一个闭包。一个闭包可以被当做参数传递或直接使用，它可以简单的看成”访问外部环境变量的函数“。Lambda是Kotlin中最常见的闭包形式。
 
-一个闭包可以被当做参数传递或直接使用，它可以简单的看成”访问外部环境变量的函数“。Lambda是Kotlin中最常见的闭包形式。
-
-与Java不一样的地方在于，Kotlin中的闭包不仅可以访问外部变量，还能够对其进行修改，如下： 
+与Java不一样的地方在于，Kotlin中的闭包不仅可以访问外部变量，还能够对其进行修改(我有点疑惑，Java为啥不能修改？下面说)，如下： 
 
 ```kotlin
 var sum = 0
@@ -485,9 +478,156 @@ listOf(1, 2, 3).filter { it > 0 }.forEach {
 println(sum)  // 6
 ```
 
+看到这里我是懵逼的？ 到底什么是闭包？ 闭包有什么作用？ 
+
+闭包就是能够读取其他函数内部变量的函数。例如在javascript中，只有函数内部的子函数才能读取局部变量，所以闭包可以理解成“定义在一个函数内部的函数“。在本质上，闭包是将函数内部和函数外部连接起来的桥梁。--百度百科
+第一句总结的很简洁了：闭包就是能够读取其他函数内部变量的函数。
+
+### Java实现闭包
+
+在Java8之前，是不支持闭包的，但是可以通过“接口+匿名内部类”来实现一个伪闭包的功能，为什么说是伪闭包？ 
+
+## Anonymous inner class is not closure
+
+Anonymous classes in java are close to being called as a closure. They don’t 100% support the definition but come close to it and thats why we see lot of literature calling anonymous inner classes as closure. Why do I say its not 100%? An anonymous inner class can access “only” the [final](https://javapapers.com/core-java/explain-the-final-keyword-in-java/) local variable of the enclosing method. It is because of this restriction, anonymous inner class in java is not a closure.
+
+If you remember the [memory management in java](https://javapapers.com/core-java/java-jvm-memory-types/), you can recall that the local variables are stored in a stack. These java stacks are created when the method starts and destroyed when it returns. Unlike local variables, final fields are stored in method area which lives longer even after the return of the method. If we want to make anonymous inner class as a closure, then we should allow it to access all the fields surrounding it. But, as per the current memory management, they will be destroyed and will not be accessible after the method has returned.
+
+## Closure in Java
+
+In that case will we get closure in java in future? We have a specification written by Peter Ahe, James Gosling, Neal Gafter and Gilad Bracha on [closures for java](http://www.javac.info/closures-v05.html). It gives detailed description of how a closure can be implemented in java and example code on how to use them. We have JSR 335 for closures in java named as Lambda Expressions for the Java Programming Language.
+
+```java
+class ClosureTest {
+    public interface MutableAdder {
+        int add(int x, boolean change);
+    }
+
+    public MutableAdder makeAdderB(int n) {
+        // Variable 'intHolder' is accessed from within inner class, needs to be declared final
+        final int[] intHolder = new int[]{n};
+        return new MutableAdder() {
+            public int add(int x, boolean change) {
+                if (change) {
+                    intHolder[0] = x;
+                    return x;
+                } else {
+                    return intHolder[0] + x;
+                }
+            }
+        };
+    }
+}
+```
+
+OK，实现看完了，那这么做有什么用呢？ 反正我平时没用到...
+
+现在继续来说上面提到的与Java不一样的地方在于，Kotlin中的闭包不仅可以访问外部变量，还能够对其进行修改。
+
+#### 为什么java中内部类访问外部局部变量需要用final修饰
+
+我学java的时候我就记着这种情况一定要加final，但是我不知道为啥。 今天就仔细看看
+
+Variable 'a' is accessed from within inner class, needs to be final or effectively final(java 8)。
+
+Java doesn't support closures, i.e. local variable can’t be accessed outside the method, but fields of class can be accessed from outside the class.
+
+
+
+What are local variables in java?
+
+All variables of the method are called local variables in java.
+
+
+
+Where do local variables live in java?
+
+[Methods are pushed on **stack**](http://www.javamadesoeasy.com/2015/03/threads-implement-their-own-stack.html) so local variables live on the stack.
+
+Local variables of the method are kept on the stack and are lost as soon as the method ends in java.
+
+
+
+Where do object of local inner class live in java?
+
+As object of local inner class live on the **heap**, objects may be alive even after method ends in which local inner class have been defined.
+
+**As, local variables of the method are kept on the stack and are lost as soon as the method ends,** **but even after the method ends, the local inner class object may still be alive on the heap.** 
+
+
+
+What java docs says about “Local Inner class cannot access the non-final local variables but can access final local variables.”
+
+**A local class can only access local variables that are declared final in java**. When a local class accesses a local variable or parameter of the enclosing block, it captures that variable or parameter in java.
+
+
+
+JVM create create a synthetic field inside the inner class in java -
+
+As final variable will not change after initialization, when a inner class access final local variables **compiler create a synthetic field inside the inner class and also copy that variable into the heap.** So, these synthetic fields can be accessed inside local inner class even when execution of method is over in java.
+
+
+
+You must be wondering, **What are synthetic fields in java?**
+
+Synthetic fields are created by compiler and they actually doesn’t exist in source code in java.
+
+
+
+The reason is that after the enclosing method returns, the local variable no longer exists. Therefore a copy of the variable is created when the anonymous class is instanciated. If Java allowed the local variable to be changed afterwards, the anonymous class would only know the old value.
+
+简单的说就是： JVM在内部类初始化的时候帮我们拷贝了一个局部变量的备份到内部类中，并且把它的值复制到了堆内存中(变量有两份，同样的名字，一个在局部变量中用，一个在内部类中)。所以要是不用final修饰，那你后面把外部类中的变量的值修改了，而内部类中拷贝的值还是原来的，那这样岂不是两边的值不一样了？ 所以不能让你改，必须加final。The solution was to required that captured variables are final (before JDK 8) or effectively final (since JDK 8), which means they cannot be assigned to.
+
+
+
+### Kotlin中的闭包
+
+想要理解kotlin中闭包的实现，首先要懂kotlin中的一个概念：在Kotlin中，函数是“一等公民”。
+
+对比一下java和kotlin更好理解：
+
+java代码：
+
+```java
+public class TestJava{
+    private void test(){
+        private void test(){//错误，因为Java中不支持函数包含函数
+ 
+        }
+    }
+}
+```
+
+在java中是不支持这种写法的，因为函数是“二等公民”。
+
+下面再看下kotlin代码：
+
+```kotlin
+fun test(): () -> Unit {
+    var a = 0
+    return fun() {
+        a++
+        println(a)
+    }
+}
+
+fun main() {
+    val t = test()
+    t()
+}
+```
+
+是不是发现了新世界的大门，内部函数很轻松地调用了外部变量a。
+
+这只是一个最简单的闭包实现。按照这种思想，其他的实现例如：函数、条件语句、Lambda表达式等等都可以理解为闭包，这里不再赘述。不过万变不离其宗，只要记得一句话：**闭包就是能够读取其他函数内部变量的函数**。就是一个函数A可以访问另一个函数B的局部变量，即便另一个函数B执行完成了也没关系。目前把满足这样条件的函数A叫做闭包。
+
+
+
+
+
 ## 内联函数
 
-在我开始学的时候，一直没搞明白内联函数到底是干什么？ 有什么作用？Kotlin中的内联函数其实显得有点尴尬，因为它之所以被设计出来，主要是为了优化Kotlin支持Lambda表达式之后所带来的开销。然而，在Java中我们似乎并不需要特别关注这个问题，因为在Java 7之后，JVM引入了一种叫做invokedynamic的技术，它会自动帮助我们做Lambda优化。但是为什么Kotlin要引入内联函数这种手动的语法呢？ 这主要还是因为Kotlin要兼容Java 6。
+刚被闭包搞蒙，这里又没搞明白内联函数到底是干什么？ 有什么作用？Kotlin中的内联函数其实显得有点尴尬，因为它之所以被设计出来，主要是为了优化Kotlin支持Lambda表达式之后所带来的开销。然而，在Java中我们似乎并不需要特别关注这个问题，因为在Java 7之后，JVM引入了一种叫做invokedynamic的技术，它会自动帮助我们做Lambda优化。但是为什么Kotlin要引入内联函数这种手动的语法呢？ 这主要还是因为Kotlin要兼容Java 6。
 
 
 
diff --git "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md" "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
index 1933e2d0..b95e65a4 100644
--- "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
+++ "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
@@ -1,14 +1,18 @@
+# 1.操作系统简介
 
+操作系统(Operating System, 简称OS)是管理和控制计算机硬件与软件资源的计算机程序。
+它是一种由引导程序（bootloader）启动并管理计算机中所有程序生命周期的系统程序。任何其他软件都必须在操作系统的支持下才能运行，操作系统能有效组织和管理系统中的各种软、硬件资源，合理组织计算机系统的工作流程并控制程序的执行，为用户提供一个良好的操作环境。 目前比较为人所知的操作系统有Microsoft的Windows系统、Apple的Mac及以Linux为内核的各种Linux发行版(Centos/Ubuntu等)。 现代计算机系统由一个或多个处理器、主存、打印机、键盘、鼠标、显示器、网络接口及各种输入\输出设备构成。
 
-# 1.操作系统简介
 
-操作系统(Operating System, 简称OS)是管理和控制计算机硬件与软件资源的计算机程序，是一种由引导程序（bootloader）启动并管理计算机中所有程序生命周期的系统程序。任何其他软件都必须在操作系统的支持下才能运行，操作系统能有效组织和管理系统中的各种软、硬件资源，合理组织计算机系统的工作流程并控制程序的执行，为用户提供一个良好的操作环境。 目前比较为人所知的操作系统有Microsoft的Windows系统、Apple的Mac及以Linux为内核的各种Linux发行版(Centos/Ubuntu等)。 现代计算机系统由一个或多个处理器、主存、打印机、键盘、鼠标、显示器、网络接口及各种输入\输出设备构成。
+操作系统这个术语听上去稀松平常，并不给人任何兴奋的感觉，甚至有点俗气。原因在于中文的“操作”这个词：提到操作员，通常让人想起操作车床、磨床和起重机的穿着油腻工作服的工人，这自然让人兴奋不起来。将英文的Operating翻译为中文的“操作”，是因为翻译的人没有理解英文Operating Systems（OS，操作系统）这个名字所蕴涵的精髓。那么英文的Operating Systems意味着什么呢？各位见过手术过程吗？在手术室里，主刀大夫称为Operating Surgeon。在整个手术过程中，主刀大夫具有至高无上的权威：他说要打麻药，麻醉师便要赶紧打麻药；他说需要手术钳，助理大夫就赶忙递给他手术钳；他说需要止血，护士就要忙不迭地拿止血药棉来止血。整个手术最关键的部分，切开皮肤、拿掉器官、安装移植器官等均由主刀大夫完成。当然，主刀大夫有时候也会将某些任务，如缝合创口，交给助理大夫或护士来做，但整个手术的过程皆由其主控。一句话，Operating Surgeon就是掌控整个手术过程、具有精湛技术和敏锐判断力的医师。
+
+引申至非医学领域，Operating Person意思是操刀手，就是掌控事情的人。再将Person这个词换成System，则Operating Systems指的就是掌控局势的一种系统。也就是说计算机里面的一切事情均由Operating Systems来掌控。那么，我们现在面临两个问题：第一个问题是，操作系统到底是什么东西？第二个问题是，操作系统到底操控什么事情？我们先回答第一个问题。既然操作系统是掌控计算机局势的一个系统，自然很重要。但这个说法并不能帮助读者理解操作系统，也无法形成有形的概念。如果我们换个说法：操作系统是介于计算机和应用软件之间的一个软件系统，则概念就具体多了。从这个定义出发，我们知道操作系统的上面和下面都有别的对象存在：下面是硬件平台，上面是应用软件，现在回答第二个问题。我们知道操作系统代表的是掌控事情的系统，掌控什么事情呢？当然是计算机上或计算机里发生的一切事情。最原始的计算机并没有操作系统，而是直接由人来掌控事情，即所谓的单一控制终端、单一操作员模式。但是随着计算机复杂性的增长，人已经不能胜任直接掌控计算机了。于是我们编写出操作系统这个“软件”来掌控计算机，将人类从日益复杂的掌控任务中解脱出来。这个掌控有着多层深远的意义。首先，由于计算机的功能和复杂性不断发生变化（趋向更加复杂），操作系统所掌控的事情也就越来越多，越来越复杂。同时，操作系统本身能够使用的资源也不断增多（如内存容量）。这是早期驱动操作系统不断改善的根本原因。其次，既然操作系统是专门掌控计算机的，那么计算机上发生的所有事情自然需要操作系统的知晓和许可，未经操作系统同意的任何事情均视为非法的，也就是病毒和入侵攻击所试图运作的事情。作为操作系统的设计人员，我们当然要确保计算机不发生任何我们不知情或不同意的事情。但是人的能力是有限的，人的思维也是有缺陷的，我们设计出的系统自然不会十全十美，也会有缺陷，这就给了攻击者可乘之机。操作系统设计人员和攻击者之间的博弈是当前驱动操作系统改善的一个重要动力。再次，掌控事情的水平有高低之分，有效率不同之分。就像手术大夫之间也有水平高低之分。为了更好地掌控事情，同时也为了更好地满足人类永不知足的各种越来越苛刻的要求，操作系统自然需要不断改善。这种改善在过去、现在和将来都会继续下去的。最后，我们可以给操作系统下定义了：操作系统是一个软件系统；操作系统使计算机变得好用（将人类从繁琐、复杂的对机器掌控的任务中解脱）；操作系统使计算机运作变得有序（操作系统掌控计算机上所有的事情）。总结起来就是：操作系统是掌控计算机上所有事情的软件系统。
 
-作用:    它可以帮我们管理计算机的各种资源，协助我们完成各种复杂繁琐的任务。
 
+作用:它可以帮我们管理计算机的各种资源，协助我们完成各种复杂繁琐的任务。
 
 
-操作系统也是一种软件，但是操作系统是一种非常复杂的软件。操作系统提供了几种抽象模型
+操作系统也是一种软件，但是操作系统是一种非常复杂的软件。操作系统提供了几种抽象模型:    
 
 - 文件：对 I/O 设备的抽象
 - 虚拟内存：对程序存储器的抽象
@@ -17,9 +21,6 @@
 
 
 
-操作系统这个术语听上去稀松平常，并不给人任何兴奋的感觉，甚至有点俗气。原因在于中文的“操作”这个词：提到操作员，通常让人想起操作车床、磨床和起重机的穿着油腻工作服的工人，这自然让人兴奋不起来。将英文的Operating翻译为中文的“操作”，是因为翻译的人没有理解英文Operating Systems（OS，操作系统）这个名字所蕴涵的精髓。那么英文的Operating Systems意味着什么呢？各位见过手术过程吗？在手术室里，主刀大夫称为Operating Surgeon。在整个手术过程中，主刀大夫具有至高无上的权威：他说要打麻药，麻醉师便要赶紧打麻药；他说需要手术钳，助理大夫就赶忙递给他手术钳；他说需要止血，护士就要忙不迭地拿止血药棉来止血。整个手术最关键的部分，切开皮肤、拿掉器官、安装移植器官等均由主刀大夫完成。当然，主刀大夫有时候也会将某些任务，如缝合创口，交给助理大夫或护士来做，但整个手术的过程皆由其主控。一句话，Operating Surgeon就是掌控整个手术过程、具有精湛技术和敏锐判断力的医师。
-
-引申至非医学领域，Operating Person意思是操刀手，就是掌控事情的人。再将Person这个词换成System，则Operating Systems指的就是掌控局势的一种系统。也就是说计算机里面的一切事情均由Operating Systems来掌控。那么，我们现在面临两个问题：第一个问题是，操作系统到底是什么东西？第二个问题是，操作系统到底操控什么事情？我们先回答第一个问题。既然操作系统是掌控计算机局势的一个系统，自然很重要。但这个说法并不能帮助读者理解操作系统，也无法形成有形的概念。如果我们换个说法：操作系统是介于计算机和应用软件之间的一个软件系统，则概念就具体多了。从这个定义出发，我们知道操作系统的上面和下面都有别的对象存在：下面是硬件平台，上面是应用软件，现在回答第二个问题。我们知道操作系统代表的是掌控事情的系统，掌控什么事情呢？当然是计算机上或计算机里发生的一切事情。最原始的计算机并没有操作系统，而是直接由人来掌控事情，即所谓的单一控制终端、单一操作员模式。但是随着计算机复杂性的增长，人已经不能胜任直接掌控计算机了。于是我们编写出操作系统这个“软件”来掌控计算机，将人类从日益复杂的掌控任务中解脱出来。这个掌控有着多层深远的意义。首先，由于计算机的功能和复杂性不断发生变化（趋向更加复杂），操作系统所掌控的事情也就越来越多，越来越复杂。同时，操作系统本身能够使用的资源也不断增多（如内存容量）。这是早期驱动操作系统不断改善的根本原因。其次，既然操作系统是专门掌控计算机的，那么计算机上发生的所有事情自然需要操作系统的知晓和许可，未经操作系统同意的任何事情均视为非法的，也就是病毒和入侵攻击所试图运作的事情。作为操作系统的设计人员，我们当然要确保计算机不发生任何我们不知情或不同意的事情。但是人的能力是有限的，人的思维也是有缺陷的，我们设计出的系统自然不会十全十美，也会有缺陷，这就给了攻击者可乘之机。操作系统设计人员和攻击者之间的博弈是当前驱动操作系统改善的一个重要动力。再次，掌控事情的水平有高低之分，有效率不同之分。就像手术大夫之间也有水平高低之分。为了更好地掌控事情，同时也为了更好地满足人类永不知足的各种越来越苛刻的要求，操作系统自然需要不断改善。这种改善在过去、现在和将来都会继续下去的。最后，我们可以给操作系统下定义了：操作系统是一个软件系统；操作系统使计算机变得好用（将人类从繁琐、复杂的对机器掌控的任务中解脱）；操作系统使计算机运作变得有序（操作系统掌控计算机上所有的事情）。总结起来就是：操作系统是掌控计算机上所有事情的软件系统。
 
 ### 操作系统三要素: 
 
@@ -164,7 +165,7 @@
 
 目前的Android系统大多运行在ARM处理器之上。ARM本身是一个公司的名称，从技术的角度来看，它又是一种微处理器内核的架构。
 
-对于ARM处理器，当复位完毕后，处理器首先还行其片上ROM中的一小块程序。这块ROM的大小一般只有几KB，该段程序就是Bootloader程序，这段程序执行时会根据处理器上一些特定引脚的高低电平状态，选择从何种物理接口上装载用户程序，比如USB口、SD卡、并口Flash等。
+对于ARM处理器，当复位完毕后，处理器首先执行芯片上ROM中的一小块程序。这块ROM的大小一般只有几KB，该段程序就是Bootloader程序，这段程序执行时会根据处理器上一些特定引脚的高低电平状态，选择从何种物理接口上装载用户程序，比如USB口、SD卡、并口Flash等。
 
 多数基于ARM的实际硬件系统，会从并口NAND Flash芯片上的0x00000000地址处装载程序。对于一些小型嵌入式系统而言，该地址中的程序就是最终要执行的用户程序；而对于Android而言，该地址中的程序还不是Android程序，而是一个叫做uboot或者fastboot的程序，其作用是初始化硬件设备，比如网口、SDRAM、RS232等，并提供一些调试功能，比如向NAND Flash中写入新的数据，这可用于开发过程中的内核烧写、升级等。
 
@@ -209,13 +210,15 @@ Android平台的基础是Linux内核，比如ART虚拟机最终调用底层Linux
 
 ### 程序运行时会发生什么？
 
-首先，当然得进行编程，而编程需要计算机程序设计语言作为基础。对于绝大多数编写程序的人来说，使用的编程语言称为高级程序设计语言，如C、C++、Java等。但由于计算机并不认识高级语言编写的程序，编好的程序需要进行编译变成计算机能够识别的机器语言程序，而这需要编译器和汇编器的帮助。其次，机器语言程序需要加载到内存，形成一个运动中的程序，即进程，而这需要操作系统的帮助。进程需要在计算机芯片CPU上执行才算是真正在执行，而将进程调度到CPU上运行也由操作系统完成。最后，在CPU上执行的机器语言指令需要变成能够在一个个时钟脉冲里执行的基本操作，这需要指令集结构和计算机硬件的支持，而整个程序的执行过程还需要操作系统提供的服务和程序语言提供的执行环境（runtime environment）。这样，一个从程序到微指令执行的过程就完成了。
+- 首先，当然得进行编程，而编程需要计算机程序设计语言作为基础。对于绝大多数编写程序的人来说，使用的编程语言称为高级程序设计语言，如C、C++、Java等。但由于计算机并不认识高级语言编写的程序，编好的程序需要进行编译变成计算机能够识别的机器语言程序，而这需要编译器和汇编器的帮助。
+- 其次，机器语言程序需要加载到内存，形成一个运动中的程序，即进程，而这需要操作系统的帮助。进程需要在计算机芯片CPU上执行才算是真正在执行，而将进程调度到CPU上运行也由操作系统完成。
+- 最后，在CPU上执行的机器语言指令需要变成能够在一个个时钟脉冲里执行的基本操作，这需要指令集结构和计算机硬件的支持，而整个程序的执行过程还需要操作系统提供的服务和程序语言提供的执行环境（runtime environment）。这样，一个从程序到微指令执行的过程就完成了。
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/app_process.jpg?raw=true)        
 
 简单的来说一个正在运行的程序会做一件非常简单的事情：执行指令。处理器从内存中获取（fetch）一条指令，对其进行解码（decode）（弄清楚这是哪条指令），然后执行（execute）它（做它应该做的事情，如两个数相加、访问内存、检查条件、跳转到函数等）。完成这条指令后，处理器继续执行下一条指令，依此类推，直到程序最终完成。
 
-这样，我们就描述了冯·诺依曼（Von Neumann）计算模型的基本概念。听起来很简单，对吧？但在这门课中，我们将了解到在一个程序运行的同时，还有很多其他疯狂的事情也在同步进行——主要是为了让系统易于使用。
+这样，我们就描述了冯·诺依曼（Von Neumann）计算模型的基本概念。听起来很简单，对吧？但是在一个程序运行的同时，还有很多其他疯狂的事情也在同步进行——主要是为了让系统易于使用。
 
 实际上，有一类软件负责让程序运行变得容易（甚至允许你同时运行多个程序），允许程序共享内存，让程序能够与设备交互，以及其他类似的有趣的工作。这些软件称为操作系统（Operating System，OS），因为它们负责确保系统既易于使用又正确高效地运行。
 
@@ -227,7 +230,7 @@ Android平台的基础是Linux内核，比如ART虚拟机最终调用底层Linux
 
 假设我们有一个桃子，我们称之为物理（physical）的桃子。但有很多想吃这个桃子的人，我们希望向每个想吃的人提供一个属于他的桃子，这样才能皆大欢喜。我们把给每个人的桃子称为虚拟（virtual）桃子。我们通过某种方式，从这个物理桃子创造出许多虚拟桃子。重要的是，在这种假象中，每个人看起来都有一个物理桃子，但实际上不是。每个人都不知道他在和别人一起分享这个桃子，但是如果我和别人分享同一个桃子我一定会发现这个问题。但是只有吃的人多才有这样的问题。多数时间他们都在打盹或者做其他事情，所以，你可以在他们打盹的时候把他手中的桃子拿过来分给其他人，这样我们就创造了有许多虚拟桃子的假象，每个人有一个桃子。
 
-以最基本的计算机资源CPU为例，假设一个计算机只有一个CPU(尽管现在计算机一班拥有2个、4个或更多CPU)，虚拟化要做的就是将这个CPU虚拟成多个虚拟CPU并分给每一个进程使用，因此，每个应用都以为自己在独占CPU，但实际上只有一个CPU。这样操作系统就创造了美丽的假象--它虚拟化了CPU。
+以最基本的计算机资源CPU为例，假设一个计算机只有一个CPU(尽管现在计算机一般拥有2个、4个或更多CPU)，虚拟化要做的就是将这个CPU虚拟成多个虚拟CPU并分给每一个进程使用，因此，每个应用都以为自己在独占CPU，但实际上只有一个CPU。这样操作系统就创造了美丽的假象--它虚拟化了CPU。
 
 操作系统通过进程抽象让每一个用户感觉有一台自己独享的CPU；通过虚拟内存抽象，让用户感觉物理内存空间具有无限扩张性，这就是把少变多。当然，操作系统的把少变多不是无中生有，变多也不是无限多，只是针对磁盘容量的大小。
 
@@ -242,14 +245,6 @@ CPU(中央处理器)是计算机的大脑，它主要和内存进行交互，从
 为了驱动CPU运转，称为“时钟信号”的电信号必不可少。这种电信号就好像带有一个时钟，滴答滴答地每隔一定时间就变换一次电压的高低。输出时钟信号的元件叫作“时钟发生器”。时钟发生器中带有晶振，根据其自身的频率（振动的次数）产生时钟信号。时钟信号的频率可以衡量CPU的运转速度。这里使用的是2.5MHz（兆赫兹）的时钟发生器。最大时钟频率(maximum clock speed)，也称主频，是影响处理器速度的决定性因素之一。时钟频率决定了执行一条指令所需要的时间，处理器的数据位宽也影响处理器的速度。
 
 
-
-CPU 主要由两部分构成：`控制单元` 和 `算术逻辑单元（ALU）`
-
-- 控制单元：从内存中提取指令并解码执行
-- 算数逻辑单元（ALU）：处理算数和逻辑运算
-
-CPU 是计算机的心脏和大脑，它和内存都是由许多晶体管组成的电子部件。它接收数据输入，执行指令并处理信息。它与输入/输出（I / O）设备进行通信，这些设备向 CPU 发送数据和从 CPU 接收数据。
-
 CPU 的内部由**寄存器、控制器、运算器和时钟**四部分组成，各部分之间通过电信号连通。
 
 - `寄存器`是中央处理器内的组成部分。它们可以用来暂存指令、数据和地址。可以将其看作是内存的一种。根据种类的不同，一个 CPU 内部会有 20 - 100个寄存器。
@@ -258,7 +253,6 @@ CPU 的内部由**寄存器、控制器、运算器和时钟**四部分组成，
 - `时钟` 负责发出 CPU 开始计时的时钟信号
 
 
-
 **程序是把寄存器作为对象来描述的**
 
 使用高级语言编写的程序会在编译后转化成机器语言，然后通过CPU内部的寄存器来处理。不同类型的CPU，其内部寄存器的数量，种类以及寄存器存储的数值范围都是不同的。根据功能的不同，我们可以将寄存器大致划分为八类: 
@@ -339,13 +333,16 @@ CPU 的内部由**寄存器、控制器、运算器和时钟**四部分组成，
 
 - 内核态(Kernel Mode):运行操作系统程序
 
-    内核态就是拥有资源多的状态，或者说访问资源多的状态，称为特权态。
+    内核态就是拥有资源多的状态，或者说访问资源多的状态，又称为特权态。
 
 - 用户态(User Mode):运行用户程序
 
     用户态就是非特权态，在此种状态下访问的资源将受到限制。
 
-如果一个程序运行在特权态，则该程序就可以访问计算机的任何资源，即它的资源访问不受限制。如果一个程序运行在用户态，则其资源需求将受到各种限制。很显然，内核态和用户态各有优势：运行在内核态的程序可以访问的资源多，但可靠性、安全性要求高，维护管理都较复杂；用户态程序程序访问的资源有限，但可靠性、安全性要求低，自然编写维护起来比较简单。一个程序到底应该运行在内核态还是用户态则取决于其对资源和效率的需求。一般来说，如果一个程序能够运行于用户态，就应该让它运行在用户态。只在迫不得已的情况下，才让程序运行于内核态。凡是牵扯到计算机本体根本运行的事情都应该在内核态下执行，只与用户数据和应用相关的东西则放在用户态执行。另外，对时序要求特别高的操作，也应该在内核态完成。
+如果一个程序运行在特权态，则该程序就可以访问计算机的任何资源，即它的资源访问不受限制。如果一个程序运行在用户态，则其资源需求将受到各种限制。很显然，内核态和用户态各有优势：
+- 运行在内核态的程序可以访问的资源多，但可靠性、安全性要求高，维护管理都较复杂；
+- 用户态程序程序访问的资源有限，但可靠性、安全性要求低，自然编写维护起来比较简单。
+一个程序到底应该运行在内核态还是用户态则取决于其对资源和效率的需求。一般来说，如果一个程序能够运行于用户态，就应该让它运行在用户态。只在迫不得已的情况下，才让程序运行于内核态。凡是牵扯到计算机本体根本运行的事情都应该在内核态下执行，只与用户数据和应用相关的东西则放在用户态执行。另外，对时序要求特别高的操作，也应该在内核态完成。
 
 
 
@@ -378,7 +375,7 @@ CPU 的内部由**寄存器、控制器、运算器和时钟**四部分组成，
 
 可以说操作系统是由“中断驱动”或者“时间驱动”的。中断/异常是CPU对系统发生的某个事件作出的一种反应。
 
-所有计算机都提供了允许其他模块（I/O、存储器)中断处理器正常处理过程的机制。中断最初是用于提高处理器效率的一种手段。例如，多数I/O设备都要远慢于处理器，处理器必须暂停并保持空闲，直到打印机完成工作。暂停的时间长度可能相当于成百上千个不涉及存储器的指令周期，显然，这对于处理器的使用来说是非常浪费的。这种只有一个单独程序的情况，称为单道程序设计。在单道程序设计中处理器话费一定的运行时间进行计算，直到遇到一个I/O指令，这时它必须等到该I/O指令结束后才能继续执行。这种问题是可以避免的，就是存储器可以保存多个程序，在一个程序等待时通过切换去执行其他的程序，这种处理称为多道程序设计或多任务处理。它是现代操作系统的主要方案。多道程序设计的目的是为了让处理器和I/O设备（包括存储设备）同时保持忙状态，以实现最大的效率。
+所有计算机都提供了允许其他模块（I/O、存储器)中断处理器正常处理过程的机制。中断最初是用于提高处理器效率的一种手段。例如，多数I/O设备都要远慢于处理器，处理器必须暂停并保持空闲，直到打印机完成工作。暂停的时间长度可能相当于成百上千个不涉及存储器的指令周期，显然，这对于处理器的使用来说是非常浪费的。这种只有一个单独程序的情况，称为单道程序设计。在单道程序设计中处理器花费一定的运行时间进行计算，直到遇到一个I/O指令，这时它必须等到该I/O指令结束后才能继续执行。这种问题是可以避免的，就是存储器可以保存多个程序，在一个程序等待时通过切换去执行其他的程序，这种处理称为多道程序设计或多任务处理。它是现代操作系统的主要方案。多道程序设计的目的是为了让处理器和I/O设备（包括存储设备）同时保持忙状态，以实现最大的效率。
 
 
 
@@ -406,21 +403,14 @@ CPU 的内部由**寄存器、控制器、运算器和时钟**四部分组成，
 
 中断的出现解决了主机和外围设备并行工作的问题，消除了因外围设备的慢速而使得主机等待的现象，提高了可靠性，为多机操作和实时处理提供了硬件基础。引起中断的那些事件称为中断事件或中断源，中断源向CPU发出的请求信号称为中断请求，而处理中断事件的那段程序称为中断处理程序。发生中断时正在执行的程序的暂停点称为中断断点，CPU暂停当前程序转而处理中断的过程称为中断响应，中断处理结束之后恢复原来程序的执行称为中断返回。
 
+### 中断系统
 
+中断系统包括量大组成部分：
 
-### 中断/异常机制工作原理
-
-硬件和软件相互配合而使计算机系统得以充分发挥能力。
-
-- 硬件的作用 -- 中断/异常响应
-
-    捕获中断源发出的中断/异常请求，以一定方式响应，将处理器控制权交给特定的处理程序。发现中断、接受中断都是由硬件来完成。
-
-- 软件的作用 -- 中断/异常处理程序
-
-    识别中断/异常类型并完成相应的处理。
-
+- 中断系统的硬件中断装置
+- 软件中断处理程序
 
+中断装置负责捕获中断源发出的中断请求，并以一定的方式响应中断源，然后将CPU的控制权移交给特定的中断处理程序。中断处理程序负责辨别中断类型，并根据请求作出相应的操作。中断装置提供了中断系统的基本框架，是中断系统的机制部分。中断处理程序是利用中断机制对处理能力的扩展和对多种处理需求的适应，属于中断系统的策略部分。
 
 
 
@@ -440,7 +430,7 @@ CPU 的内部由**寄存器、控制器、运算器和时钟**四部分组成，
 
 
 
-与每一 I/O 类相关联的是一个称作 `中断向量(interrupt vector)` 的位置（靠近内存底部的固定区域）。它包含中断服务程序的入口地址。假设当一个磁盘中断发生时，用户进程 3 正在运行，则中断硬件将程序计数器、程序状态字、有时还有一个或多个寄存器压入堆栈，计算机随即跳转到中断向量所指示的地址。这就是硬件所做的事情。然后软件就随即接管一切剩余的工作。
+与每一 I/O 类相关联的是一个称作 `中断向量(interrupt vector)` 的位置（靠近内存底部的固定区域）。它包含中断服务程序的入口地址。假设当一个磁盘中断发生时，用户进程正在运行，则中断硬件将程序计数器、程序状态字、有时还有一个或多个寄存器压入堆栈，计算机随即跳转到中断向量所指示的地址。这就是硬件所做的事情。然后软件就随即接管一切剩余的工作。
 
 当中断结束后，操作系统会调用一个 C 程序来处理中断剩下的工作。在完成剩下的工作后，会使某些进程就绪，接着调用调度程序，决定随后运行哪个进程。然后将控制权转移给一段汇编语言代码，为当前的进程装入寄存器值以及内存映射并启动该进程运行，下面显示了中断处理和调度的过程。
 
@@ -455,15 +445,6 @@ CPU 的内部由**寄存器、控制器、运算器和时钟**四部分组成，
 
 一个进程在执行过程中可能被中断数千次，但关键每次中断后，被中断的进程都返回到与中断发生前完全相同的状态。
 
-### 中断系统
-
-中断系统包括量大组成部分：
-
-- 中断系统的硬件中断装置
-- 软件中断处理程序
-
-中断装置负责捕获中断源发出的中断请求，并以一定的方式响应中断源，然后将CPU的控制权移交给特定的中断处理程序。中断处理程序负责辨别中断类型，并根据请求作出相应的操作。中断装置提供了中断系统的基本框架，是中断系统的机制部分。中断处理程序是利用中断机制对处理能力的扩展和对多种处理需求的适应，属于中断系统的策略部分。
-
 
 
 
@@ -510,13 +491,13 @@ CPU 的内部由**寄存器、控制器、运算器和时钟**四部分组成，
 
 
 
-内存实际上是一种名为内存IC的电子元件。虽然内存IC包括DRAM、SRAM、ROM[插图]等多种形式，但从外部来看，其基本机制都是一样的。内存IC中有电源、地址信号、数据信号、控制信号等用于输入输出的大量引脚（IC的引脚），通过为其指定地址（address），来进行数据的读写。
+内存实际上是一种名为内存IC的电子元件。虽然内存IC包括DRAM、SRAM、ROM等多种形式，但从外部来看，其基本机制都是一样的。内存IC中有电源、地址信号、数据信号、控制信号等用于输入输出的大量引脚（IC的引脚），通过为其指定地址（address），来进行数据的读写。
 
-下内存IC（在这里假设它为RAM）的引脚配置示例。虽然这是一个虚拟的内存IC，但它的引脚和实际的内存IC是一样的。VCC和GND是电源，A0～A9是地址信号的引脚，D0～D7是数据信号的引脚，RD和WR是控制信号的引脚(读取或写入)。将电源连接到VCC和GND后，就可以给其他引脚传递比如0或者1这样的信号。大多数情况下，+ 5V的直流电压表示1,0V表示0。
+下面是内存IC（在这里假设它为RAM）的引脚配置示例。虽然这是一个虚拟的内存IC，但它的引脚和实际的内存IC是一样的。VCC和GND是电源，A0～A9是地址信号的引脚，D0～D7是数据信号的引脚，RD和WR是控制信号的引脚(读取或写入)。将电源连接到VCC和GND后，就可以给其他引脚传递比如0或者1这样的信号。大多数情况下，+ 5V的直流电压表示1,0V表示0。
 
 ![内存IC的引脚配置示例](https://raw.githubusercontent.com/CharonChui/Pictures/master/ram.jpg?raw=true)        
 
-那么，这个内存IC中能存储多少数据呢？数据信号引脚有D0～D7共八个，表示一次可以输入输出8位（=1字节）的数据。此外，地址信号引脚有A0～A9共十个，表示可以指定0000000000～1111111111共1024个地址。而地址用来表示数据的存储场所，因此我们可以得出这个内存IC中可以存储1024个1字节的数据。因为1024=1K[插图]，所以该内存IC的容量就是1KB。
+那么，这个内存IC中能存储多少数据呢？数据信号引脚有D0～D7共八个，表示一次可以输入输出8位（=1字节）的数据。此外，地址信号引脚有A0～A9共十个，表示可以指定0000000000～1111111111共1024个地址。而地址用来表示数据的存储场所，因此我们可以得出这个内存IC中可以存储1024个1字节的数据。因为1024=1K，所以该内存IC的容量就是1KB。
 
 虽然内存的实体是内存IC，不过从程序员的角度来看，也可以把它假想成每层都存储着数据的楼房，并不需要过多地关注内存IC的电源和控制信号等。
 
@@ -611,33 +592,6 @@ Android在Linux内核中增加了两个提升电源管理能力的新功能： 
 
 
 
-## 一个程序的执行过程
-
-```c
-#include <stdio.h>
-int main(int argc, char *argv[]) {
-    puts("hello world");
-    return 0;
-}
-```
-
-
-
-1. 用户通过命令或者图标点击等通知操作系统执行hello world程序。
-2. 操作系统会去找到hello world程序的相关信息，检查其类型是否是可执行文件，并通过程序的首部信息，确定代码和数据在可执行文件中的位置并计算出对应的磁盘块地址。
-3. 操作系统创建一个新的进程，并将hello world程序的执行文件映射到该进程结构，表示由该进程执行该hello world程序。
-4. 操作系统为hello world程序设置cpu上下文环境并跳到程序开始处。
-5. 执行hello world程序的第一条指令，这时候会发生缺页异常(内存中没有该程序)
-6. 操作系统开始分配一页物理内存，并将前面计算出的磁盘块地址将代码从磁盘读入内存，然后继续执行hello world程序。
-7. hello world程序执行puts函数(系统调用)，想要在显示器上写入字符串。
-8. 操作系统找到要将字符串送往的显示设备，通常设备是由一个进程控制的，所以，操作系统将要写的字符串送给该进程。
-9. 控制设备的进程告诉设备的窗口系统它要显示字符串。窗口系统确定这是一个合法的操作，然后将字符串转换成像素，将像素写入设备的存储影响区。
-10. 视频硬件将像素转换成显示器可接收的一组控制/数据信号。
-11. 显示器解释信号，激发液晶屏。
-12. 这样我们就能在屏幕上看到了"hello world"。
-
-
-
 ## Linux操作系统特点
 
 Linux是类Unix系统，借鉴了Unix的设计并实现相关接口，但并非Unix。Linux是由Linus Torvalds于1991年创造的开源免费系统，采用GNU GPL协议保护，下面列举Linux的一些主要特点：
diff --git "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md" "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
index 4cba483b..a273dd1f 100644
--- "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
+++ "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
@@ -14,7 +14,10 @@
 
 为了虚拟化CPU，操作系统需要以某种方式让许多任务共享物理CPU，让它们看起来像是同时运行。基本思想很简单：运行一个进程一段时间，然后运行另一个进程，如此轮换。通过以这种方式时分共享（time sharing）CPU，就实现了虚拟化。然而，在构建这样的虚拟化机制时存在一些挑战。第一个是性能：如何在不增加系统开销的情况下实现虚拟化？第二个是控制权：如何有效地运行进程，同时保留对CPU的控制？控制权对于操作系统尤为重要，因为操作系统负责资源管理。如果没有控制权，一个进程可以简单地无限制运行并接管机器，或访问没有权限的信息。因此，在保持控制权的同时获得高性能，这是构建操作系统的主要挑战之一。
 
-
+#### 多道程序系统与分时操作系统
+- 所谓多道程序设计指的是允许多个程序同时进入一个计算机系统的主存储器并启动进行计算的方法。也就是说，计算机内存中可以同时存放多道（两个以上相互独立的）程序，它们都处于开始和结束之间。从宏观上看是并行的，多道程序都处于运行中，并且都没有运行结束；从微观上看是串行的，各道程序轮流使用CPU，交替执行。引入多道程序设计技术的根本目的是为了提高CPU的利用率，充分发挥计算机系统部件的并行性，现代计算机系统都采用了多道程序设计技术。
+- 分时操作系统是使一台计算机同时为几个、几十个甚至几百个用户服务的一种操作系统。把计算机与许多终端用户连接起来，分时操作系统将系统处理机时间与内存空间按一定的时间间隔，轮流地切换给各终端用户的程序使用。由于时间间隔很短，每个用户的感觉就像他独占计算机一样。分时操作系统的特点是可有效增加资源的使用率。例如UNIX系统就采用剥夺式动态优先的CPU调度，有力地支持分时操作。
+- 分时操作系统是给不同用户提供程序的使用，而多道程序系统则是不同程序间的穿插运行。
 
 ## 进程概念
 
@@ -24,7 +27,9 @@
 
 广义定义：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是[操作系统](https://baike.baidu.com/item/操作系统/192)动态执行的[基本单元](https://baike.baidu.com/item/基本单元)，在传统的[操作系统](https://baike.baidu.com/item/操作系统)中，进程既是基本的[分配单元](https://baike.baidu.com/item/分配单元)，也是基本的执行单元。
 
-进程的概念主要有两点：第一，进程是一个实体。每一个进程都有它自己的地址空间，一般情况下，包括[文本](https://baike.baidu.com/item/文本)区域（text region）、数据区域（data region）和[堆栈](https://baike.baidu.com/item/堆栈)（stack region）。文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分配的内存；堆栈区域存储着活动过程调用的指令和本地变量。第二，进程是一个“执行中的程序”。程序是一个没有生命的实体，只有[处理](https://baike.baidu.com/item/处理)器赋予程序生命时（操作系统执行之），它才能成为一个活动的实体，我们称其为[进程](https://baike.baidu.com/item/进程)。可以简单的理解为：进程 = 资源 + 指令执行序列。
+进程的概念主要有两点：    
+- 第一，进程是一个实体。每一个进程都有它自己的地址空间，一般情况下，包括[文本](https://baike.baidu.com/item/文本)区域（text region）、数据区域（data region）和[堆栈](https://baike.baidu.com/item/堆栈)（stack region）。文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分配的内存；堆栈区域存储着活动过程调用的指令和本地变量。
+- 第二，进程是一个“执行中的程序”。程序是一个没有生命的实体，只有[处理](https://baike.baidu.com/item/处理)器赋予程序生命时（操作系统执行之），它才能成为一个活动的实体，我们称其为[进程](https://baike.baidu.com/item/进程)。可以简单的理解为：进程 = 资源 + 指令执行序列。
 
 进程是60年代初首先由[麻省理工学院](https://baike.baidu.com/item/麻省理工学院)的[MULTICS系统](https://baike.baidu.com/item/MULTICS系统)和IBM公司的[CTSS](https://baike.baidu.com/item/CTSS)/360系统引入的。
 
@@ -42,7 +47,7 @@
 
 上图是一种进程管理方法。两个进程A和B存在于内存中的某些部分，给每个进程（包含程序、数据和上下文信息）分配了一块存储器区域，并且在由操作系统建立和维护的进程表中进行了记录。进程表包含记录每个进程的表项，表项内容包括指向包含进程的存储块地址的指针，还包括该进程的部分和全部上下文。执行上下文的其余部分存放在别处，可能和进程本身存在一起，通常还可能保存在内存中的一块独立区域。进程索引寄存器（process index register）包含当前正在控制处理器的进程在进程表中的索引。程序计数器（program counter）指向该进程中下一条待执行的指令。基址寄存器中保存该存储器区域的开始地址。
 
-图中表示，进程索引寄存器表明进程B正在执行。以前执行的进程被临时中断，在A中断的同时，所有寄存器的内容被记录在其执行上下文环境中，以后操作系统就可以执行进程切换。恢复进程A的执行。进程切换过程中包括保存B的上下文和恢复A的上下文。在程序计数器中载入指向A的程序区域的值时，进程A自动恢复执行。
+图中表示，进程索引寄存器表明进程B正在执行。以前执行的进程被临时中断，在A中断的同时，所有寄存器的内容被记录在其执行上下文环境中，以后操作系统就可以执行进程切换来恢复进程A的执行。进程切换过程中包括保存B的上下文和恢复A的上下文。在程序计数器中载入指向A的程序区域的值时，进程A自动恢复执行。
 
 在任何多道程序设计系统中，CPU由一个进程快速切换至另一个进程，使每个进程各运行几十或几百毫秒。严格来说，在某一个瞬间，CPU只能运行一个进程。但在1秒钟内，它可能运行多个进程，这样就产生并行的错觉。CPU在各进程之间来回切换，这种快速的切换称为多道程序设计。
 
@@ -209,6 +214,22 @@
 
 以Linux为例，进程间的信息交换，具体内容分为：控制信息交换和数据交换，控制信息的交换为低级通信，数据的交换为高级通信。
 
+- Pipe管道通信
+
+    人们最常使用的通信手段就是对白。对白的特点就是一方发出声音，另一方接收声音。而声音的传递则通过空气（当面或无线交谈）、线缆（有线电话）进行传递。类似，进程对白就是一个进程发出某种数据信息，另外一方接收数据信息，而这些数据信息通过一片共享的存储空间进行传递。在这种方式下，一个进程向这片存储空间的一端写入信息，另一个进程从存储空间的另外一端读取信息。这看上去像什么？管道。管道所占的空间既可以是内存，也可以是磁盘。就像两人对白的媒介可以是空气，也可以是线缆一样。要创建一个管道，一个进程只需调用管道创建的系统调用即可。该系统调用所做的事情就是在某种存储介质上划出一片空间，赋给其中一个进程写的权利，另一个进程读的权利即可。
+
+    从根本上说，管道是一个线性字节数组，类似文件，可以使用文件读写的方式进行访问。但却不是文件。因为通过文件系统看不到管道的存在。另外，我们前面说了，管道可以设在内存里，而文件很少设在内存里
+
+    在两个进程之间，可以建立一个通道，一个进程向这个通道里写入字节流，另一个进程从这个管道中读取字节流。管道是同步的，当进程尝试从空管道读取数据时，该进程会被阻塞，直到有可用数据为止。发送进程以字符流形式将大量数据送入管道，接收进程可从管道接收数据，二者利用管道进行通信，管道是单向的、先进先出的，它把一个进程的输出和另一个进程的输入连接在一起。一个进程（写进程）在管道的尾部写入数据，另一个进程（读进程）从管道的头部读出数据。每次只有一个进程能够真正地进入管道，其他的只能等待。
+
+    
+
+    管道分为无名管道和命名管道，前者用于父子进程通信，后者用于任意进程通信。
+
+    入先出队列 FIFO 通常被称为 `命名管道(Named Pipes)`，命名管道的工作方式与常规管道非常相似，但是确实有一些明显的区别。未命名的管道没有备份文件：操作系统负责维护内存中的缓冲区，用来将字节从写入器传输到读取器。一旦写入或者输出终止的话，缓冲区将被回收，传输的数据会丢失。相比之下，命名管道具有支持文件和独特 API ，命名管道在文件系统中作为设备的专用文件存在。当所有的进程通信完成后，命名管道将保留在文件系统中以备后用。命名管道具有严格的 FIFO 行为，写入的第一个字节是读取的第一个字节，写入的第二个字节是读取的第二个字节，依此类推。
+
+    
+
 - Socket套接字
 
     套接字的功能非常强大，可以支持不同层面、不同应用、跨网络的通信。使用套接字进行通信需要双方均创建一个套接字，其中一方作为服务器方，另外一方作为客户方。服务器方必须先创建一个服务区套接字，然后在该套接字上进行监听，等待远方的连接请求。欲与服务器通信的客户则创建一个客户套接字，然后向服务区套接字发送连接请求。服务器套接字在收到连接请求后，将在服务器方机器上创建一个客户套接字，与远方的客户机上的客户套接字形成点到点的通信通道。之后，客户方和服务器方就可以通过send和recv命令在这个创建的套接字通道上进行交流了。
@@ -233,7 +254,7 @@
 
 - 信号量
 
-    信号量（semaphore）是由荷兰人E.W.Dijkstra在20世纪60年代所构思出的一种程序设计构造。其原型来源于铁路的运行：在一条单轨铁路上，任何时候只能有一列列车行驶在上面（如图6-9）。而管理这条铁路的系统就是信号量。任何一列火车必须等到表明铁路可以行驶的信号后才能进入轨道。当一列列车进入单轨运行后，需要将信号改为禁止进入，从而防止别的火车同时进入轨道。而当列车驶出单轨后，则需要将信号变回允许进入状态。这很像以前的旗语，在计算机里，信号量实际上就是一个简单整数。一个进程在信号变为0或者1的情况下推进，并且将信号变为1或0来防止别的进程推进。当进程完成任务后，则将信号再改变为0或1，从而允许其他进程执行。需要注意的是，信号量不只是一种通信机制，更是一种同步机制。
+    信号量（semaphore）是由荷兰人E.W.Dijkstra在20世纪60年代所构思出的一种程序设计构造。其原型来源于铁路的运行：在一条单轨铁路上，任何时候只能有一列列车行驶在上面。而管理这条铁路的系统就是信号量。任何一列火车必须等到表明铁路可以行驶的信号后才能进入轨道。当一列列车进入单轨运行后，需要将信号改为禁止进入，从而防止别的火车同时进入轨道。而当列车驶出单轨后，则需要将信号变回允许进入状态。这很像以前的旗语，在计算机里，信号量实际上就是一个简单整数。一个进程在信号变为0或者1的情况下推进，并且将信号变为1或0来防止别的进程推进。当进程完成任务后，则将信号再改变为0或1，从而允许其他进程执行。需要注意的是，信号量不只是一种通信机制，更是一种同步机制。
 
 - Shared Memory共享内存
 
@@ -247,31 +268,6 @@
 
     进程与其它的进程进行通信而不必借助共享数据，通过互相发送和接收消息，建立一条通信链路。
 
-    一听到消息队列这个名词你可能不知道是什么意思，消息队列是用来描述内核寻址空间内的内部链接列表。可以按几种不同的方式将消息按顺序发送到队列并从队列中检索消息。每个消息队列由 IPC 标识符唯一标识。消息队列有两种模式，一种是`严格模式`， 严格模式就像是 FIFO 先入先出队列似的，消息顺序发送，顺序读取。还有一种模式是 `非严格模式`，消息的顺序性不是非常重要。
-
-- Pipe管道通信
-
-    人们最常使用的通信手段就是对白。对白的特点就是一方发出声音，另一方接收声音。而声音的传递则通过空气（当面或无线交谈）、线缆（有线电话）进行传递。类似，进程对白就是一个进程发出某种数据信息，另外一方接收数据信息，而这些数据信息通过一片共享的存储空间进行传递。在这种方式下，一个进程向这片存储空间的一端写入信息，另一个进程从存储空间的另外一端读取信息。这看上去像什么？管道。管道所占的空间既可以是内存，也可以是磁盘。就像两人对白的媒介可以是空气，也可以是线缆一样。要创建一个管道，一个进程只需调用管道创建的系统调用即可。该系统调用所做的事情就是在某种存储介质上划出一片空间，赋给其中一个进程写的权利，另一个进程读的权利即可。
-
-    从根本上说，管道是一个线性字节数组，类似文件，可以使用文件读写的方式进行访问。但却不是文件。因为通过文件系统看不到管道的存在。另外，我们前面说了，管道可以设在内存里，而文件很少设在内存里
-    
-    在两个进程之间，可以建立一个通道，一个进程向这个通道里写入字节流，另一个进程从这个管道中读取字节流。管道是同步的，当进程尝试从空管道读取数据时，该进程会被阻塞，直到有可用数据为止。shell 中的`管线 pipelines` 就是用管道实现的，当 shell 发现输出
-    
-    发送进程以字符流形式将大量数据送入管道，接收进程可从管道接收数据，二者利用管道进行通信，管道是单向的、先进先出的，它把一个进程的输出和另一个进程的输入连接在一起。一个进程（写进程）在管道的尾部写入数据，另一个进程（读进程）从管道的头部读出数据。每次只有一个进程能够真正地进入管道，其他的只能等待。
-    
-    
-    
-    管道分为无名管道和命名管道，前者用于父子进程通信，后者用于任意进程通信。
-    
-    入先出队列 FIFO 通常被称为 `命名管道(Named Pipes)`，命名管道的工作方式与常规管道非常相似，但是确实有一些明显的区别。未命名的管道没有备份文件：操作系统负责维护内存中的缓冲区，用来将字节从写入器传输到读取器。一旦写入或者输出终止的话，缓冲区将被回收，传输的数据会丢失。相比之下，命名管道具有支持文件和独特 API ，命名管道在文件系统中作为设备的专用文件存在。当所有的进程通信完成后，命名管道将保留在文件系统中以备后用。命名管道具有严格的 FIFO 行为，写入的第一个字节是读取的第一个字节，写入的第二个字节是读取的第二个字节，依此类推。
-    
-    
-    
-    
-    
-    
-    
-    
 
 
 
@@ -322,7 +318,7 @@
 
 - 轮转法
   
-    一种最古老、最简单、最公平并且最广泛使用的算法就是轮询算法(round-robin)。每个进程都会被分配一个时间段，称为时间片(quantum)，在这个时间片内允许进程运行。如果时间片结束时进程还在运行的话，则抢占一个 CPU 并将其分配给另一个进程。如果进程在时间片结束前阻塞或结束，则 CPU 立即进行切换。轮询算法比较容易实现。调度程序所做的就是维护一个可运行进程的列表，就像下图中的 a，当一个进程用完时间片后就被移到队列的末尾。
+    一种最古老、最简单、最公平并且最广泛使用的算法就是轮询算法(round-robin)。每个进程都会被分配一个时间段，称为时间片(quantum)，在这个时间片内允许进程运行。如果时间片结束时进程还在运行的话，则抢占一个 CPU 并将其分配给另一个进程。如果进程在时间片结束前阻塞或结束，则 CPU 立即进行切换。轮询算法比较容易实现。调度程序所做的就是维护一个可运行进程的列表，当一个进程用完时间片后就被移到队列的末尾。
     
     - 简单轮转： 就绪进程按FIFO排队，按照一定时间间隔让处理机分配给队列中的进程，就绪队列中所有队列均可获得一个时间片的处理器运行。
     - 多级队列： 让系统中所有进程分成若干类，每类一级。
@@ -350,84 +346,12 @@
 
 用户栈是用户进程空间中的一块区域，用于保存用户进程的子程序间相互作用的参数、返回值以及相关局部变量
 
-**当进程因为中断或者系统调用而陷入内核态，进程所使用的堆栈也要从用户栈转到内核栈**。进程陷入内核态后，先把用户态堆栈的地址保存在内核栈中，然后设置堆栈指针寄存器的内容为内核栈的地址，这样就完成了用户栈到内核栈的转换。**当进程从内核态回复为用户态时，在内核态之后的最后将保存在内核栈里面的用户栈地址恢复到堆栈指针寄存器即可**。这样就实现了内核栈和用户栈的互转。
+**当进程因为中断或者系统调用而陷入内核态，进程所使用的堆栈也要从用户栈转到内核栈**。进程陷入内核态后，先把用户态堆栈的地址保存在内核栈中，然后设置堆栈指针寄存器的内容为内核栈的地址，这样就完成了用户栈到内核栈的转换。**当进程从内核态恢复为用户态时，在内核态之后的最后将保存在内核栈里面的用户栈地址恢复到堆栈指针寄存器即可**。这样就实现了内核栈和用户栈的互转。
 
 注意：**每次进程从用户态陷入内核的时候得到的内核栈都是空的，所以在进程陷入内核的时候，直接把内核栈的栈顶地址给堆栈指针寄存器即可。**
 
 
 
-## 死锁
-
-两个以上的进程相互请求对方已经占有的资源，导致无限期的等待。
-
-### 产生条件
-
-死锁有三个必要条件： 
-
-- 互斥。一次只有一个进程可以使用一个资源。其他进程不能访问已分配给其他进程的资源。
-- 占有且等待。当一个进程等待其他进程时，继续占有已分配的资源。
-- 不可抢占。不能强行抢占进程已占有的资源。
-
-前三个条件都只是死锁存在的必要条件而非充分条件。要产生死锁，还需要第四个条件： 
-
-- 循环等到。存在一个闭合的进程链，每个进程至少占有此链中下一个进程所需的一个资源。
-
-
-
-### 解决方法
-
-- 鸵鸟策略：不理睬
-- 预防策略：破坏产生条件中任意一个
-- 避免策略： 精心分配资源，动态避免死锁
-- 检测与解除死锁：系统自动检测，并且解除
-
-
-
-## Linux并发机制
-
-Linux为进程间通信和同步提供了各种机制。这里只是几种。
-
-- 管道
-
-    管道是一个环形缓冲区，它允许两个进程以生产者/消费者的模型进行通信。因此，这是一个先进先出的队列，由一个进程写，由另一个进程度。
-
-- 消息
-
-    每个进程都有一个与之相关联的消息队列。当程序视图给一个满队列发送信息时，它会被堵塞。当进程视图从一个空队列读取消息时也回被堵塞。
-
-- 共享内存
-
-    这是虚存中由多个进程共享的一个公共内存块。进程读写共享内存所用的机器指令，与读写虚存空间的其他部分所用的指令相同。每个进程有一个只读或读写的权限。互斥约束不属于共享内存机制的一部分，但必须由使用共享内存的进程提供。
-
-- 信号量
-
-    信号量实际上是以集合的形式创建的，一个信号量集合中有一个或多个信号量。内核自动完成所有需要的操作，在所有操作完成前，任何其他进程都不能访问信号量。
-
-    信号量由如下元素组成: 
-
-    - 信号量的当前值
-    - 在信号量上操作的最后一个进程的进程ID
-    - 等待该信号量的值大于当前值的进程数
-    - 等待该信号量的值为零的进程数
-
-- 信号
-
-    信号是用于向一个进程通知发生异步事件的机制。信号类似于硬件中断，但没有优先级，即内核公平地对待所有的信号。
-
-- 自旋锁
-
-    在Linux中保护临界区的常用技术是自旋锁。在同一个时刻，只有一个线程能够获得自旋锁。其他任何试图获得自旋锁的线程将一直进行尝试（即自旋），知道获得了该锁。
-
-
-
-### Android进程间通信
-
-虽然Linux内核包含很多用于进程间通信（IPC）的机制，但是Adnroid系统在IPC中仍然新增了一个连接器。连接器提供了一个轻量级的远程程序调用功能，它在内存和事务处理方面非常高效，非常适合嵌入式系统。
-
-连接器被用来传递两个进程之间的交互。进程（客户端）组件发起一个调用，调用直接传递给位于内核的连接器，连接器将其传递给目标进程（服务器端）的目标组件，目标进程返回的结果通过连接器传递给发起调用的进程组件。
-
-
-
 ## Android进程结构
 
 如同传统的Linux系统一样，Android的第一个用户空间进程是init（init的PID值是0），它是所有其他进程的根。然而，Android的init启动的守护进程是不同的，这些守护进程更多的聚焦于底层细节（管理文件系统和硬件访问），而不是高层用户设施，例如调度定时任务。Android还有一层额外的进程，它们运行Dalvik的Java语言环境，负责执行系统中所有以Java实现的部分。
@@ -442,7 +366,7 @@ Linux为进程间通信和同步提供了各种机制。这里只是几种。
 
 其他进程在需要的时候由zygote创建。这些进程中有一些是“持久的”进程，它们是基本操作系统的组成部分，例如phone进程中的电话栈，它必须保持始终运行。另外的应用程序进程将在系统运行的过程中按需创建和终止。
 
-应用程序通过调用操作系统提供的库与操作系统进行交互，这些库合起来构成Android框架（Android framework）。这些库中有一些可以在进程内部执行其工作，但是许多库需要与其他进程执行进程间通信，作者通常是在system_server进程中提供服务的。
+应用程序通过调用操作系统提供的库与操作系统进行交互，这些库合起来构成Android框架（Android framework）。这些库中有一些可以在进程内部执行其工作，但是许多库需要与其他进程执行进程间通信，或者通常是在system_server进程中提供服务的。
 
 ### ServiceManager
 
@@ -580,27 +504,19 @@ Android使用的进程有些不同。活动管理器是Android负责正在运行
 
 
 简而言之，由于进程是一个资源拥有者，因而在进程的创建、撤销和切换中，系统必须为之付出较大的时空开销。也正因如此，在系统中所设置的进程数目不宜过多，进程切换的频率也不宜过高，但这也就限制了并发程度的进一步提高。
-如何能使多个程序更好地并发执行，同时又尽量减少系统的开销，这已成为近年来设计操作系统时所追求的重要目标。有不少操作系统的学者们考虑：可否将进程的上述两个属性分开，由操作系统分开进行处理？即对作为调度和分派的基本单位，不同时作为独立分配资源的单位，以使之轻装运行；而对拥有资源的基本单位，又不频繁地对之进行切换。正是在这种思想的指导下，产生了线程概念。在传统的操作系统中，每个进程都有一个地址空间和一个控制线程。事实上，这是大部分进程的定义。不过，在许多情况下，经常存在同一地址空间中运行多个控制线程的情形，这些线程就像是分离的进程。
-
-上面说到进程 = 资源 + 指令执行序列。那能不能将资源和指令执行分开，组合成一个资源 + 多个指令执行序列的方式？ 这种不切换资源，只切换执行指令的方式就是线程。线程保留了并发的优点，避免了进程切换的代价。
+如何能使多个程序更好地并发执行，同时又尽量减少系统的开销，这已成为近年来设计操作系统时所追求的重要目标。有不少操作系统的学者们考虑：可否将进程的上述两个属性分开，由操作系统分开进行处理？即对作为调度和分派的基本单位，不同时作为独立分配资源的单位，以使之轻装运行。正是在这种思想的指导下，产生了线程概念。这样线程就保留了并发的优点，避免了进程切换的代价。
 
 
 
 #### 线程的定义
 
-在引入线程的操作系统中，线程是进程的一个实体，是被系统独立调度和分派的基本单位。线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源（如程序计数器、一组寄存器和栈），但它可与同属一个进程的其他线程共享进程所拥有的全部资源。一个线程可以创建和撤销另一个线程；同一进程中的多个线程之间可以并发执行。
-
-
-
-在传统的操作系统中，拥有资源的基本单位和独立调度、分派的基本单位都是进程。而在引入线程的操作系统中，则把线程作为调度和分派的基本单位，而把进程作为资源拥有的基本单位，使传统进程的两个属性分开，线程便能轻装运行，从而可显著地提高系统的并发程度。在同一进程中，线程的切换不会引起进程切换；在由一个进程中的线程切换到另一个进程中的线程时，将会引起进程切换。
-
-
+在引入线程的操作系统中，线程是进程的一个实体，是被系统独立调度和分派的基本单位。线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源（如程序计数器、一组寄存器和栈），但它可与同属一个进程的其他线程共享进程所拥有的全部资源。一个线程可以创建和撤销另一个线程；同一进程中的多个线程之间可以并发执行。    
 
-多线程技术是指把执行一个应用程序的进程划分为可以同时运行的多个线程。
+在传统的操作系统中，拥有资源的基本单位和独立调度、分派的基本单位都是进程。而在引入线程的操作系统中，则把线程作为调度和分派的基本单位，而把进程作为资源拥有的基本单位，使传统进程的两个属性分开，线程便能轻装运行，从而可显著地提高系统的并发程度。在同一进程中，线程的切换不会引起进程切换；在由一个进程中的线程切换到另一个进程中的线程时，将会引起进程切换。所以多线程技术是指把执行一个应用程序的进程划分为可以同时运行的多个线程。
 
 
 
-线程不像是进程那样具备较强的独立性。同一个进程中的所有线程都会有完全一样的地址空间，这意味着它们也共享同样的全局变量。由于每个线程都可以访问进程地址空间内每个内存地址，**「因此一个线程可以读取、写入甚至擦除另一个线程的堆栈」**。线程之间除了共享同一内存空间外，还具有如下不同的内容
+线程不像是进程那样具备较强的独立性。同一个进程中的所有线程都会有完全一样的地址空间，这意味着它们也共享同样的全局变量。由于每个线程都可以访问进程地址空间内每个内存地址，**「因此一个线程可以读取、写入甚至擦除另一个线程的堆栈」**。线程之间除了共享同一内存空间外，还具有如下不同的内容： 
 
 
 
@@ -610,7 +526,7 @@ Android使用的进程有些不同。活动管理器是Android负责正在运行
 
 **「线程之间的状态转换和进程之间的状态转换是一样的」**。
 
-每个线程都会有自己的堆栈，如下图所示
+每个线程都会有自己的堆栈，如下图所示： 
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/thread_heap.png?raw=true)  
 
@@ -626,11 +542,7 @@ Android使用的进程有些不同。活动管理器是Android负责正在运行
 
 ### 线程实现
 
-线程的调度却与进程调度有稍许不同。由于线程是在进程的基础上产生的概念（进程里面的一个执行序列），其调度可以由进程负责。当然，我们也可以将线程的调度交给操作系统。而这两种不同的调度推手就形成了线程的两种实现：用户态实现和内核态实现。由进程自己管理就是用户态线程的实现，由操作系统管理就是内核态线程实现。用户态和内核态的判断以线程表所处的位置为依据：位于内核叫内核态实现，位于用户层叫用户态实现。前面我们在讲述进程时没有提到过实现方式的问题，即应该是在用户态还是在内核态实现的问题。这是因为进程是在CPU上实现并发（多道编程），而CPU是由操作系统管理的，因此，进程的实现只能由操作系统内核来进行，而不存在用户态实现的情况，根本没有这种探讨的需要。但对于线程就不同了，因为线程是进程内部的东西，当然存在由进程直接管理线程的可能性。因此，线程存在着内核态与用户态两种实现可能。
-
-
-
-主要有三种实现方式
+线程的调度却与进程调度有稍许不同。由于线程是在进程的基础上产生的概念（进程里面的一个执行序列），其调度可以由进程负责。当然，我们也可以将线程的调度交给操作系统。而这两种不同的调度推手就形成了线程的两种实现：用户态实现和内核态实现。由进程自己管理就是用户态线程的实现，由操作系统管理就是内核态线程实现。用户态和内核态的判断以线程表所处的位置为依据：位于内核叫内核态实现，位于用户层叫用户态实现。所以线程的实现主要有三种实现方式：   
 
 - 在用户空间中实现线程；
 - 在内核空间中实现线程；
@@ -640,7 +552,11 @@ Android使用的进程有些不同。活动管理器是Android负责正在运行
 
 #### 在内核中实现线程
 
-由操作系统来管理线程有很多好处，最重要的好处是用户编程简单。因为线程的复杂性由操作系统承担，用户程序员在编程时无需管理线程的调度，即无需担心线程什么时候会执行、什么时候会挂起。另外一个重要好处是，如果一个线程执行阻塞操作，操作系统可以从容地调度另外一个线程执行。因为操作系统能够监控所有的线程。那么内核态线程实现有什么缺点呢？首先是效率较低。因为线程在内核态实现，每次线程切换都需要陷入到内核，由操作系统来进行调度。而从用户态陷入到内核态是要花时间的。另外，内核态实现占用内核稀缺的内存资源，因为操作系统需要维护线程表。操作系统所占内存空间一旦装载结束后就已经固定，无法动态改变。由于线程的数量通常大大多于进程的数量，因此随着线程数量的增加，操作系统内核空间将迅速耗尽。那么内核态线程实现有什么缺点呢？首先是效率较低。因为线程在内核态实现，每次线程切换都需要陷入到内核，由操作系统来进行调度。而从用户态陷入到内核态是要花时间的。另外，内核态实现占用内核稀缺的内存资源，因为操作系统需要维护线程表。操作系统所占内存空间一旦装载结束后就已经固定，无法动态改变。由于线程的数量通常大大多于进程的数量，因此随着线程数量的增加，操作系统内核空间将迅速耗尽。如果要建立进程线程，但内核空间不够了，怎么办？我们可以做的选择有：“杀死”别的进程；创建失败；让它等一下。前面说过，“杀死”别的进程是一件很不好的事情，因为将造成服务不确定性。宣称创建失败也很差。因为创建失败有可能意味着某个进程无法往前推进，这违反了我们前面说过的进程模型的时序推进要求。让创建者等一下，这要看创建的是什么进程和线程了。如果是系统进程线程，等一下可能意味着关键服务无法按时启动；如果是用户进程线程，等一下可能引起用户的强烈不满。而且，等多久谁也不知道。那在内核空间满了后，应该怎么办呢？打一个战场上的比方就清楚了。如果战场上对手太厉害了，想再调个师的军队，结果没有，怎么办？投降。也就是说，如果内核空间溢出，操作系统将停止运转。因为要创立的进程可能很重要，所以不能不创建。所以最好的结局是“死掉”。别人发现系统“死了”就会采取行动来补救。如果操作系统还要运转，却不能正确地运转，那是很危险的事情。操作系统采取的这种行动在灾难应对领域称为“无害遽止”。但上面两个缺点还不是最致命的。最致命的是内核态实现需要修改操作系统，这在线程概念提出之初是一件很难办到的事情。试想，如果你作为研究人员提出了线程概念，然后你去找一家操作系统研发商，要求其修改操作系统，加入线程的管理，结果会怎样？操作系统开发商会请你走开。有谁敢把一个还未经证明的新概念加入到对计算机影响甚大的操作系统里？除非我们先证明线程的有效性，否则很难说服他人修改操作系统。这样，就有了线程的用户态实现。
+由操作系统来管理线程有很多好处，最重要的好处是用户编程简单。因为线程的复杂性由操作系统承担，用户程序员在编程时无需管理线程的调度，即无需担心线程什么时候会执行、什么时候会挂起。另外一个重要好处是，如果一个线程执行阻塞操作，操作系统可以从容地调度另外一个线程执行。因为操作系统能够监控所有的线程。
+
+那么内核态线程实现有什么缺点呢？首先是效率较低。因为线程在内核态实现，每次线程切换都需要陷入到内核，由操作系统来进行调度。而从用户态陷入到内核态是要花时间的。另外，内核态实现占用内核稀缺的内存资源，因为操作系统需要维护线程表。操作系统所占内存空间一旦装载结束后就已经固定，无法动态改变。由于线程的数量通常大大多于进程的数量，因此随着线程数量的增加，操作系统内核空间将迅速耗尽。
+
+如果要建立进程线程，但内核空间不够了，怎么办？我们可以做的选择有：“杀死”别的进程；创建失败；让它等一下。前面说过，“杀死”别的进程是一件很不好的事情，因为将造成服务不确定性。宣称创建失败也很差。因为创建失败有可能意味着某个进程无法往前推进，这违反了我们前面说过的进程模型的时序推进要求。让创建者等一下，这要看创建的是什么进程和线程了。如果是系统进程线程，等一下可能意味着关键服务无法按时启动；如果是用户进程线程，等一下可能引起用户的强烈不满。而且，等多久谁也不知道。那在内核空间满了后，应该怎么办呢？打一个战场上的比方就清楚了。如果战场上对手太厉害了，想再调个师的军队，结果没有，怎么办？投降。也就是说，如果内核空间溢出，操作系统将停止运转。因为要创立的进程可能很重要，所以不能不创建。所以最好的结局是“死掉”。别人发现系统“死了”就会采取行动来补救。如果操作系统还要运转，却不能正确地运转，那是很危险的事情。操作系统采取的这种行动在灾难应对领域称为“无害遽止”。但上面两个缺点还不是最致命的。最致命的是内核态实现需要修改操作系统，这在线程概念提出之初是一件很难办到的事情。试想，如果你作为研究人员提出了线程概念，然后你去找一家操作系统研发商，要求其修改操作系统，加入线程的管理，结果会怎样？操作系统开发商会请你走开。有谁敢把一个还未经证明的新概念加入到对计算机影响甚大的操作系统里？除非我们先证明线程的有效性，否则很难说服他人修改操作系统。这样，就有了线程的用户态实现。
 
 现在我们考虑使用内核来实现线程的情况，此时不再需要运行时环境了。另外，每个进程中也没有线程表。相反，在内核中会有用来记录系统中所有线程的线程表。当某个线程希望创建一个新线程或撤销一个已有线程时，它会进行一个系统调用，这个系统调用通过对线程表的更新来完成线程创建或销毁工作。
 
@@ -650,11 +566,7 @@ Android使用的进程有些不同。活动管理器是Android负责正在运行
 
 内核中的线程表持有每个线程的寄存器、状态和其他信息。这些信息和用户空间中的线程信息相同，但是位置却被放在了内核中而不是用户空间中。另外，内核还维护了一张进程表用来跟踪系统状态。
 
-所有能够阻塞的调用都会通过系统调用的方式来实现，当一个线程阻塞时，内核可以进行选择，是运行在同一个进程中的另一个线程（如果有就绪线程的话）还是运行一个另一个进程中的线程。但是在用户实现中，运行时系统始终运行自己的线程，直到内核剥夺它的 CPU 时间片（或者没有可运行的线程存在了）为止。
-
-
-
-由于在内核中创建或者销毁线程的开销比较大，所以某些系统会采用可循环利用的方式来回收线程。当某个线程被销毁时，就把它标志为不可运行的状态，但是其内部结构没有受到影响。稍后，在必须创建一个新线程时，就会重新启用旧线程，把它标志为可用状态。
+所有能够阻塞的调用都会通过系统调用的方式来实现，当一个线程阻塞时，内核可以进行选择，是运行在同一个进程中的另一个线程（如果有就绪线程的话）还是运行一个另一个进程中的线程。由于在内核中创建或者销毁线程的开销比较大，所以某些系统会采用可循环利用的方式来回收线程。当某个线程被销毁时，就把它标志为不可运行的状态，但是其内部结构没有受到影响。稍后，在必须创建一个新线程时，就会重新启用旧线程，把它标志为可用状态。
 
 如果某个进程中的线程造成缺页故障后，内核很容易的就能检查出来是否有其他可运行的线程，如果有的话，在等待所需要的页面从磁盘读入时，就选择一个可运行的线程运行。这样做的缺点是系统调用的代价比较大，所以如果线程的操作（创建、终止）比较多，就会带来很大的开销。
 
@@ -662,13 +574,7 @@ Android使用的进程有些不同。活动管理器是Android负责正在运行
 
 #### 在用户空间中实现线程
 
-线程在刚刚出现时，由于无法说服操作系统人员修改操作系统，其实现的方式只能是在用户态。（谁提出谁举证。）那么用户态实现意味着什么呢？或者说用户态实现是什么意思呢？就是用户自己做线程的切换，自己管理线程的信息，而操作系统无须知道线程的存在。那么在用户态如何进行线程调度呢？那就是用户自己写一个执行系统（runtimesystem）作调度器，即除了正常执行任务的线程外，还有一个专门负责线程调度的线程。由于大家都在用户态下运行，谁也不比谁占优势，要想取得CPU控制权只能靠大家的自愿合作。一个线程在执行完一段时间后主动把资源释放给别人使用，而在内核态下则无须如此。因为操作系统可通过周期性的时钟中断把控制权夺过来。在用户态实现情况下，执行系统的调度器（runtime scheduler）也是线程，没有能力强行夺走控制权，所以必须合作。
-
-那么用户态实现有什么优点呢？有。首先是灵活性。因为操作系统无须知道线程的存在，所以在任何操作系统上都能应用；其次是线程切换快。因为切换在用户态进行，无须陷入到内核态。最后是不用修改操作系统，实现容易。
-
-那么这种实现方式有什么缺点吗？有。首先，编程序变得很诡异。我们前面说过，用户态线程需要相互合作才能运转。这样，我们在写程序时，必须仔细斟酌在什么时候应该让出CPU给别的线程使用。而让出时机的选择对线程的效率和可靠性有很大的影响。这并不是一件容易的事。另外一个更为严重的问题是，用户态线程实现无法完全达到线程提出所要达到的目的：进程级多道编程。如果在执行过程中一个线程受阻，它将无法将控制权交出来（因为受阻后无法执行交出CPU的指令了），这样整个进程都无法推进。操作系统随即把CPU控制权交给另外一个进程。这样，一个线程受阻造成整个进程都受阻，我们期望通过线程对进程实施分身的计划就失败了。这是用户态线程的致命弱点。
-
-第一种方法是把整个线程包放在用户空间中，内核对线程一无所知，它不知道线程的存在。所有的这类实现都有同样的通用结构
+把整个线程包放在用户空间中，内核对线程一无所知，它不知道线程的存在。所有的这类实现都有同样的通用结构： 
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/thread_user.png?raw=true)  
 
@@ -767,7 +673,18 @@ Android使用的进程有些不同。活动管理器是Android负责正在运行
 
 
 
-### 进程和线程的区别
+### 死锁解决方法
+
+- 鸵鸟策略：不理睬
+- 预防策略：破坏产生条件中任意一个
+- 避免策略： 精心分配资源，动态避免死锁
+- 检测与解除死锁：系统自动检测，并且解除
+
+
+
+
+
+## 进程和线程的区别
 
 进程有如下两个特点: 
 
@@ -793,6 +710,33 @@ Android使用的进程有些不同。活动管理器是Android负责正在运行
 
 
 
+
+
+## 一个程序的执行过程
+
+```c
+#include <stdio.h>
+int main(int argc, char *argv[]) {
+    puts("hello world");
+    return 0;
+}
+```
+
+
+
+1. 用户通过命令或者图标点击等通知操作系统执行hello world程序。
+2. 操作系统会去找到hello world程序的相关信息，检查其类型是否是可执行文件，并通过程序的首部信息，确定代码和数据在可执行文件中的位置并计算出对应的磁盘块地址。
+3. 操作系统创建一个新的进程，并将hello world程序的执行文件映射到该进程结构，表示由该进程执行该hello world程序。
+4. 操作系统为hello world程序设置cpu上下文环境并跳到程序开始处。
+5. 执行hello world程序的第一条指令，这时候会发生缺页异常(内存中没有该程序)
+6. 操作系统开始分配一页物理内存，并将前面计算出的磁盘块地址将代码从磁盘读入内存，然后继续执行hello world程序。
+7. hello world程序执行puts函数(系统调用)，想要在显示器上写入字符串。
+8. 操作系统找到要将字符串送往的显示设备，通常设备是由一个进程控制的，所以，操作系统将要写的字符串送给该进程。
+9. 控制设备的进程告诉设备的窗口系统它要显示字符串。窗口系统确定这是一个合法的操作，然后将字符串转换成像素，将像素写入设备的存储影响区。
+10. 视频硬件将像素转换成显示器可接收的一组控制/数据信号。
+11. 显示器解释信号，激发液晶屏。
+12. 这样我们就能在屏幕上看到了"hello world"。
+
 ---
 
 
diff --git "a/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md" "b/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
index 6d8e055e..8088adec 100644
--- "a/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
+++ "b/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
@@ -36,35 +36,6 @@
 
 上述几种内存区域中数据段、BSS和堆通常是被连续存储的——内存位置上是连续的，而代码段和栈往往会被独立存放。有趣的是，堆和栈两个区域关系很“暧昧”，他们一个向下“长”（i386体系结构中栈向下、堆向上），一个向上“长”，相对而生。但你不必担心他们会碰头，因为他们之间间隔很大（到底大到多少，你可以从下面的例子程序计算一下），绝少有机会能碰到一起。
 
-## 地址空间
-
-如果要使多个应用程序同时运行在内存中，必须要解决两个问题：`保护`和 `重定位`。第一种解决方式是用`保护密钥标记内存块`，并将执行过程的密钥与提取的每个存储字的密钥进行比较。这种方式只能解决第一种问题（破坏操作系统），但是不能解决多进程在内存中同时运行的问题。
-
-还有一种更好的方式是创造一个存储器抽象：`地址空间(the address space)`。就像进程的概念创建了一种抽象的 CPU 来运行程序，地址空间也创建了一种抽象内存供程序使用。
-
-#### 基址寄存器和变址寄存器
-
-在多道编程环境下，由于程序加载到内存的地址不是固定的（有多个地方可加载），我们必须对地址进行翻译。那么如何来翻译呢？我们看到，一个程序是加载到内存里事先划分好的某片区域，而且该程序是整个加载进去。该程序里面的虚地址只要加上其所占区域的起始地址即可获得物理地址。因此，我们的翻译过程非常简单：物理地址=虚拟地址+程序所在区域的起始地址
-
-程序所在区域的起始地址称为（程序）基址。另外，由于有多个程序在内存空间中，我们需要进行地址保护。由于每个程序占用连续的一片内存空间，因此只要其访问的地址不超出该片连续空间，则为合法访问。因此，地址保护也变得非常简单，只要访问的地址满足下列条件即为合法访问：
-
-程序所在区域的起始地址≤有效地址≤程序所在区域的起始地址+程序长度
-
-由此可见，我们只需要设置两个端值：基址和变址，即可达到地址翻译和地址保护的目的。这两个端值可以由两个寄存器来存放，分别称为基址寄存器和变址寄存器。在固定分区下，基址就是固定内存分区中各个区域的起始内存地址，而变址则是所加载程序的长度（记住，不是内存各个分区的上限）。
-
-这样，每次程序发出的地址需要和极限比较大小；如果大于极限，则属非法访问。在这个时候我们将陷入内核，终止进程（在个别操作系统上，也可能进入一个异常处理的过程）；否则将基址加上偏移获得物理地址，就可以合法访问这个物理地址。
-
-`动态重定位(dynamic relocation)`技术，它就是通过一种简单的方式将每个进程的地址空间映射到物理内存的不同区域。
-
-- 基址寄存器：存储数据内存的起始位置
-- 变址寄存器：存储应用程序的长度。
-
-每当进程引用内存以获取指令或读取、写入数据时，CPU 都会自动将`基址值`添加到进程生成的地址中，然后再将其发送到内存总线上。同时，它检查程序提供的地址是否大于或等于`变址寄存器` 中的值。如果程序提供的地址要超过变址寄存器的范围，那么会产生错误并中止访问。
-
-
-
-
-
 ## 内存的演变
 
 在早些的操作系统中，并没有引入内存抽象的概念。程序直接访问和操作的都是物理内存，内存的管理也非常简单，除去操作系统所用的内存之外，全部给用户程序使用，想怎么折腾都行，只要别超出最大的容量。这种内存操作方式使得操作系统中存在多进程变得完全不可能，比如MS-DOS，你必须执行完一条指令后才能接着执行下一条。如果是多进程的话，由于直接操作物理内存地址，当一个进程给内存地址1000赋值后，另一个进程也同样给内存地址赋值，那么第二个进程对内存的赋值会覆盖第一个进程所赋的值，这回造成两条进程同时崩溃。随着计算机技术发展，要求操作系统支持多进程的需求，所谓多进程，并不需要同时运行这些进程，只要它们都处于ready 状态，操作系统快速地在它们之间切换，就能达到同时运行的假象。每个进程都需要内存，Context Switch时，之前内存里的内容怎么办？简单粗暴的方式就是先dump到磁盘上，然后再从磁盘上restore之前dump的内容（如果有的话），但效果并不好，太慢了！那怎么才能不慢呢？把进程对应的内存依旧留在物理内存中，需要的时候就切换到特定的区域。这就涉及到了内存的保护机制，毕竟进程之间可以随意读取、写入内容就乱套了，非常不安全。因此操作系统需要对物理内存做一层抽象，也就是「地址空间」(Address Space)，一个进程的地址空间包含了该进程所有相关内存，比如code/stack/heap。一个16KB的地址空间可能长这样：
@@ -91,8 +62,6 @@ Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自
 
 ### 固定分区
 
-
-
 大多数内存管理方案都假定操作系统占据内存中的某些固定部分，而内存中的其余部分则供多个用户进程使用。管理用户内存空间的最简单的方案就是对它分区，以形成若干边界固定的区域。
 
 固定分区分为两种： 
@@ -149,6 +118,33 @@ Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自
 
 
 
+### 地址空间
+
+如果要使多个应用程序同时运行在内存中，必须要解决两个问题：`保护`和 `重定位`。第一种解决方式是用`保护密钥标记内存块`，并将执行过程的密钥与提取的每个存储字的密钥进行比较。这种方式只能解决第一种问题（破坏操作系统），但是不能解决多进程在内存中同时运行的问题。
+
+还有一种更好的方式是创造一个存储器抽象：`地址空间(the address space)`。就像进程的概念创建了一种抽象的 CPU 来运行程序，地址空间也创建了一种抽象内存供程序使用。
+
+#### 基址寄存器和变址寄存器
+
+在多道编程环境下，由于程序加载到内存的地址不是固定的（有多个地方可加载），我们必须对地址进行翻译。那么如何来翻译呢？我们看到，一个程序是加载到内存里事先划分好的某片区域，而且该程序是整个加载进去。该程序里面的虚地址只要加上其所占区域的起始地址即可获得物理地址。因此，我们的翻译过程非常简单：物理地址=虚拟地址+程序所在区域的起始地址
+
+程序所在区域的起始地址称为（程序）基址。另外，由于有多个程序在内存空间中，我们需要进行地址保护。由于每个程序占用连续的一片内存空间，因此只要其访问的地址不超出该片连续空间，则为合法访问。因此，地址保护也变得非常简单，只要访问的地址满足下列条件即为合法访问：
+
+程序所在区域的起始地址≤有效地址≤程序所在区域的起始地址+程序长度
+
+由此可见，我们只需要设置两个端值：基址和变址，即可达到地址翻译和地址保护的目的。这两个端值可以由两个寄存器来存放，分别称为基址寄存器和变址寄存器。在固定分区下，基址就是固定内存分区中各个区域的起始内存地址，而变址则是所加载程序的长度（记住，不是内存各个分区的上限）。
+
+这样，每次程序发出的地址需要和极限比较大小；如果大于极限，则属非法访问。在这个时候我们将陷入内核，终止进程（在个别操作系统上，也可能进入一个异常处理的过程）；否则将基址加上偏移获得物理地址，就可以合法访问这个物理地址。
+
+`动态重定位(dynamic relocation)`技术，它就是通过一种简单的方式将每个进程的地址空间映射到物理内存的不同区域。
+
+- 基址寄存器：存储数据内存的起始位置
+- 变址寄存器：存储应用程序的长度。
+
+每当进程引用内存以获取指令或读取、写入数据时，CPU 都会自动将`基址值`添加到进程生成的地址中，然后再将其发送到内存总线上。同时，它检查程序提供的地址是否大于或等于`变址寄存器` 中的值。如果程序提供的地址要超过变址寄存器的范围，那么会产生错误并中止访问。
+
+
+
 ### 分页
 
 大小不等的固定分区和大小可变的分区技术在内存的使用上都是低效的，前者会产生内部碎片，后者会产生外部碎片。但是，如果内存被划分成大小固定、相等的块，切块相对比较小，每个进程也被分成同样大小的小块，那么进程中称为页的块可以分配到内存中称为页框的可用块。这样在使用分页技术时，每个进程在内存中浪费的空间，仅仅是进程最后一页的一小部分形成的内部碎片。没有任何外部碎片。
@@ -428,7 +424,7 @@ void func() {
 
 
 
-**补充：**为什么在你的进程退出时没有内存泄露当你编写一个短时间运行的程序时，可能会使用malloc()分配一些空间。程序运行并即将完成：是否需要在退出前调用几次free()？虽然不释放似乎不对，但在真正的意义上，没有任何内存会“丢失”。原因很简单：系统中实际存在两级内存管理。第一级是由操作系统执行的内存管理，操作系统在进程运行时将内存交给进程，并在进程退出（或以其他方式结束）时将其回收。第二级管理在每个进程中，例如在调用malloc()和free()时，在堆内管理。即使你没有调用free()（并因此泄露了堆中的内存），操作系统也会在程序结束运行时，收回进程的所有内存（包括用于代码、栈，以及相关堆的内存页）。无论地址空间中堆的状态如何，操作系统都会在进程终止时收回所有这些页面，从而确保即使没有释放内存，也不会丢失内存。因此，对于短时间运行的程序，泄露内存通常不会导致任何操作问题（尽管它可能被认为是不好的形式）。如果你编写一个长期运行的服务器（例如Web服务器或数据库管理系统，它永远不会退出），泄露内存就是很大的问题，最终会导致应用程序在内存不足时崩溃。当然，在某个程序内部泄露内存是一个更大的问题：操作系统本身。这再次向我们展示：编写内核代码的人，工作是辛苦的...
+***补充：***为什么在你的进程退出时没有内存泄露当你编写一个短时间运行的程序时，可能会使用malloc()分配一些空间。程序运行并即将完成：是否需要在退出前调用几次free()？虽然不释放似乎不对，但在真正的意义上，没有任何内存会“丢失”。原因很简单：系统中实际存在两级内存管理。第一级是由操作系统执行的内存管理，操作系统在进程运行时将内存交给进程，并在进程退出（或以其他方式结束）时将其回收。第二级管理在每个进程中，例如在调用malloc()和free()时，在堆内管理。即使你没有调用free()（并因此泄露了堆中的内存），操作系统也会在程序结束运行时，收回进程的所有内存（包括用于代码、栈，以及相关堆的内存页）。无论地址空间中堆的状态如何，操作系统都会在进程终止时收回所有这些页面，从而确保即使没有释放内存，也不会丢失内存。因此，对于短时间运行的程序，泄露内存通常不会导致任何操作问题（尽管它可能被认为是不好的形式）。如果你编写一个长期运行的服务器（例如Web服务器或数据库管理系统，它永远不会退出），泄露内存就是很大的问题，最终会导致应用程序在内存不足时崩溃。当然，在某个程序内部泄露内存是一个更大的问题：操作系统本身。这再次向我们展示：编写内核代码的人，工作是辛苦的...
 
 
 
@@ -451,7 +447,7 @@ Android包含了标准Linux内核中内存管理设施的许多扩展，具体
 
     让RAM内存不足时，系统已经完成了进程的配置，使得内存溢出强制结束命令优先中止缓存(cache)类型的进程，尝试重新取得足够的所需内存，随后中止界面(home)类别、服务(service)类别，以此类推。在同一个oom_adj水平中，它将优先中止内存占用较大的进程。
 
-    Android的底层Linux未采用磁盘虚拟内存机制，程序只能使用屋里内存作为最大内存，所以AmS中采用了自动杀死优先级较低进程的方法以达到释放内存的目的。
+    Android的底层Linux未采用磁盘虚拟内存机制，程序只能使用物理内存作为最大内存，所以AmS中采用了自动杀死优先级较低进程的方法以达到释放内存的目的。
 
 
 
diff --git a/OperatingSystem/5.I:O.md b/OperatingSystem/5.I:O.md
index 8b52065c..4ed8964e 100644
--- a/OperatingSystem/5.I:O.md
+++ b/OperatingSystem/5.I:O.md
@@ -18,20 +18,6 @@
 
 - 直接存储器访问（DMA）：一个DMA模块控制内存和I/O模块之间的数据交换。为传送一块数据，处理器给DMA模块发请求，且只有在整个数据块传送结束后，它才被中断。
 
-    DMA技术工作流程如下： 
-
-    如果处理器想读或写一块数据时，它通过向DMA模块发送以下信息来给DMA模块发出一条命令: 
-
-    - 请求读操作或写操作的信号，通过在处理器和DMA模块之间使用读写控制线发送。
-    - 相关I/O设备地址，通过数据线发送。
-    - 从存储器中读或向存储器中写的起始地址，在数据线上传送，并由DMA模块保存在其地址寄存器中。
-    - 读或写的字数，也通过数据线传送，并由DMA模块保存在其数据计数寄存器中
-
-    然后处理器继续执行其他工作，此时它已把这个I/O操作委托给DMA模块。DMA模块直接从存储器中或向存储器中逐字传送整块数据，并且数据不再需要通过处理器。传送结束后，DMA模块给处理器发送一个中断信号。因此，只有在传送开始和结束时才会用到处理器。
-    
-    由于DMA需要使用内存总线，而CPU也需要使用内存总线，这样将形成内存总线竞争。那么DMA使用总线的模式将依赖于CPU使用内存的模式。根据这些模式的不同，我们可以选择周期盗用（cycle stealing）或者爆发模式（burst mode）。由于DMA传输的数据量通常较大，数据存放何处就是一个需要考虑的因素。我们既可以将数据直接存入内存，也可以存入DMA缓冲区，然后通过中断让CPU一次性将DMA缓冲区的数据拷入内存。另外一个考虑因素就是如何寻址内存。是使用虚拟地址还是物理地址？使用物理地址的好处是速度快，缺点是绕过MMU存在安全和可靠性风险。
-    
-    DMA模式的优缺点优点就是将主CPU从I/O中解脱出来。而缺点自然是增加了成本和复杂性。而且，由于DMA需要与CPU竞争内存总线，其效率的提高不如理论上的期望。因此，并不是任何I/O都应该使用DMA。
 
 ## I/O进程
 
@@ -69,12 +55,6 @@ I/O进程是专门处理系统中的I/O请求和I/O中断工作的。是系统
 
 
 
-
-
-
-
-
-
 每个设备控制器都会有一个应用程序与之对应，设备控制器通过应用程序的接口通过中断与操作系统进行通信。设备控制器是硬件，而设备驱动程序是软件。
 
 ### 内存映射 I/O
@@ -83,17 +63,13 @@ I/O进程是专门处理系统中的I/O请求和I/O中断工作的。是系统
 
 为了控制`寄存器`，许多设备都会有`数据缓冲区(data buffer)`，来供系统进行读写。
 
-那么问题来了，CPU 如何与设备寄存器和设备数据缓冲区进行通信呢？存在两个可选的方式。第一种方法是，每个控制寄存器都被分配一个 `I/O 端口(I/O port)`号，这是一个 8 位或 16 位的整数。所有 I/O 端口的集合形成了受保护的 I/O 端口空间，以便普通用户程序无法访问它（只有操作系统可以访问）。使用特殊的 I/O 指令像是
-
-- 
+那么问题来了，CPU 如何与设备寄存器和设备数据缓冲区进行通信呢？存在两个可选的方式。第一种方法是，每个控制寄存器都被分配一个 `I/O 端口(I/O port)`号，这是一个 8 位或 16 位的整数。所有 I/O 端口的集合形成了受保护的 I/O 端口空间，以便普通用户程序无法访问它（只有操作系统可以访问）。使用特殊的 I/O 指令像是：
 
 ```
 IN REG,PORT
 ```
 
-CPU 可以读取控制寄存器 PORT 的内容并将结果放在 CPU 寄存器 REG 中。类似的，使用
-
-- 
+CPU 可以读取控制寄存器 PORT 的内容并将结果放在 CPU 寄存器 REG 中。类似的，使用：
 
 ```
 OUT PORT,REG
@@ -101,7 +77,7 @@ OUT PORT,REG
 
 CPU 可以将 REG 的内容写到控制寄存器中。大多数早期计算机，包括几乎所有大型主机，如 IBM 360 及其所有后续机型，都是以这种方式工作的。
 
-第二个方法是 PDP-11 引入的，它将**「所有控制寄存器映射到内存空间」**中。
+第二个方法是 PDP-11 引入的，它将***「所有控制寄存器映射到内存空间」***中。
 
 ### 直接内存访问
 
@@ -113,9 +89,20 @@ CPU 可以将 REG 的内容写到控制寄存器中。大多数早期计算机
 
 首先 CPU 通过设置 DMA 控制器的寄存器对它进行编程，所以 DMA 控制器知道将什么数据传送到什么地方。DMA 控制器还要向磁盘控制器发出一个命令，通知它从磁盘读数据到其内部的缓冲区并检验校验和。当有效数据位于磁盘控制器的缓冲区中时，DMA 就可以开始了。
 
-DMA 控制器通过在总线上发出一个`读请求`到磁盘控制器而发起 DMA 传送，这是第二步。这个读请求就像其他读请求一样，磁盘控制器并不知道或者并不关心它是来自 CPU 还是来自 DMA 控制器。通常情况下，要写的内存地址在总线的地址线上，所以当磁盘控制器去匹配下一个字时，它知道将该字写到什么地方。写到内存就是另外一个总线循环了，这是第三步。当写操作完成时，磁盘控制器在总线上发出一个应答信号到 DMA 控制器，这是第四步。
+DMA技术工作流程如下：   
+
+如果处理器想读或写一块数据时，它通过向DMA模块发送以下信息来给DMA模块发出一条命令: 
+
+- 请求读操作或写操作的信号，通过在处理器和DMA模块之间使用读写控制线发送。
+- 相关I/O设备地址，通过数据线发送。
+- 从存储器中读或向存储器中写的起始地址，在数据线上传送，并由DMA模块保存在其地址寄存器中。
+- 读或写的字数，也通过数据线传送，并由DMA模块保存在其数据计数寄存器中
+
+然后处理器继续执行其他工作，此时它已把这个I/O操作委托给DMA模块。DMA模块直接从存储器中或向存储器中逐字传送整块数据，并且数据不再需要通过处理器。传送结束后，DMA模块给处理器发送一个中断信号。因此，只有在传送开始和结束时才会用到处理器。
+
+由于DMA需要使用内存总线，而CPU也需要使用内存总线，这样将形成内存总线竞争。那么DMA使用总线的模式将依赖于CPU使用内存的模式。根据这些模式的不同，我们可以选择周期盗用（cycle stealing）或者爆发模式（burst mode）。由于DMA传输的数据量通常较大，数据存放何处就是一个需要考虑的因素。我们既可以将数据直接存入内存，也可以存入DMA缓冲区，然后通过中断让CPU一次性将DMA缓冲区的数据拷入内存。另外一个考虑因素就是如何寻址内存。是使用虚拟地址还是物理地址？使用物理地址的好处是速度快，缺点是绕过MMU存在安全和可靠性风险。
 
-然后，DMA 控制器会增加内存地址并减少字节数量。如果字节数量仍然大于 0 ，就会循环步骤 2 - 步骤 4 ，直到字节计数变为 0 。此时，DMA 控制器会打断 CPU 并告诉它传输已经完成了。
+DMA模式的优缺点优点就是将主CPU从I/O中解脱出来。而缺点自然是增加了成本和复杂性。而且，由于DMA需要与CPU竞争内存总线，其效率的提高不如理论上的期望。因此，并不是任何I/O都应该使用DMA。
 
 
 
diff --git "a/OperatingSystem/6.\346\226\207\344\273\266\347\256\241\347\220\206.md" "b/OperatingSystem/6.\346\226\207\344\273\266\347\256\241\347\220\206.md"
index c39742af..4597c5f1 100644
--- "a/OperatingSystem/6.\346\226\207\344\273\266\347\256\241\347\220\206.md"
+++ "b/OperatingSystem/6.\346\226\207\344\273\266\347\256\241\347\220\206.md"
@@ -1,8 +1,6 @@
 # 6.文件管理
 
-操作系统为磁盘提供的抽象就是：文件及文件系统，或者说，文件系统就是磁盘的抽象。
-
-文件系统是操作系统提供的另一个抽象。它是一个子虚乌有的东西，看不见、摸不着，但却可以使用的介于磁盘与用户之间的界面。
+操作系统为磁盘提供的抽象就是：文件及文件系统，或者说，文件系统就是磁盘的抽象。它是一个子虚乌有的东西，看不见、摸不着，但却可以使用的介于磁盘与用户之间的界面。
 
 文件管理系统是一组系统软件，它为使用文件的用户和应用程序提供服务，包括文件访问、目录维护和访问控制。文件管理系统通常被视为一个由操作系统提供服务的系统服务，而不是操作系统的一部分，但是在任何系统中，至少有一部分文件管理功能是由操作系统执行的。
 
@@ -36,9 +34,7 @@
 
 ### 文件
 
-文件是将数据存储在磁盘等存储媒介中的一种形式。文件是字节数据的集合体。程序文件中存储数据的单位是字节。文件的大小之所以用××KB、××MB等来表示，就是因为文件是以字节（B=Byte）为单位来存储的。
-
-文件就是字节数据的集合。用1字节（=8位）表示的字节数据有256种，用二进制数来表示的话，其范围就是00000000～11111111。如果文件中存储的数据是文字，那么该文件就是文本文件。如果是图形，那么该文件就是图像文件。在任何情况下，文件中的字节数据都是连续存储的。
+文件是将数据存储在磁盘等存储媒介中的一种形式。文件是字节数据的集合体。程序文件中存储数据的单位是字节。文件的大小之所以用××KB、××MB等来表示，就是因为文件是以字节（B=Byte）为单位来存储的。用1字节（=8位）表示的字节数据有256种，用二进制数来表示的话，其范围就是00000000～11111111。如果文件中存储的数据是文字，那么该文件就是文本文件。如果是图形，那么该文件就是图像文件。在任何情况下，文件中的字节数据都是连续存储的。
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/file_data.jpg?raw=true)        
 
@@ -64,11 +60,11 @@
 
 文件名"zou/cs307/file.pdf"包括从根目录开始的一个完全路径，因此称为绝对路径。绝对路径是从根目录的视角看一个文件的访问路径。与此相对的是相对路径，即从某个工作目录，如用户当前所处的目录的角度看某一个文件的访问路径。例如，如果我们目前已经在目录"zou/cs307/"下，则只需要给出文件名file.pdf即可访问该文件。使用相对路径的好处是没有必要寻遍整个目录夹，可以节省磁盘访问次数，从而提高文件访问效率。前面讲过，从根目录开始需要3次磁盘访问才能得到文件file.pdf的内容；但如果在工作目录"zou/cs307/"下直接给出文件名file.pdf，则只需要进行一次磁盘访问即可。因为当前目录的内容是已经打开的，即已经加载到内存的，我们无须磁盘访问即可查看当前目录内容，发现file.pdf的文件及其对应的磁盘地址。我们只需要按照该地址对磁盘进行一个访问即可获得file.pdf的内容。
 
-但需要注意的是，相对路径不一定总是比绝对路径节省磁盘访问次数。如果你要访问的文件是当前这个目录的“直系后代”，则将节省磁盘访问次数；否则，即如果不是“直系后代”，你就可能多花费时间。例如，在图16-7的目录树里面，如果当前目录是“目录夹1”，则使用相对路径访问“文件1”将节省磁盘访问次数，而访问“文件2”则比绝对路径更费时间。这一点我们从相对“文件2”的相对路径和绝对路径名就可以看出：文件2的相对路径名：“../目录2/文件2”。文件2的绝对路径名：“/目录2/文件2”。
+但需要注意的是，相对路径不一定总是比绝对路径节省磁盘访问次数。如果你要访问的文件是当前这个目录的“直系后代”，则将节省磁盘访问次数；否则，即如果不是“直系后代”，你就可能多花费时间。
 
 
 
-文件拷贝程序的工作原理很简单：打开源文件和目标文件，循环往复地将源文件的内容读到一个缓冲区，然后将缓冲区的内容写到输出目标文件里。当拷贝结束后，关闭源文件和目标文件。上述程序中使用的文件系统调用包括fin.open、fout.open、fout＜＜、fin.get等。这里需要注意的是，输入文件的打开模式为只读，而输出文件的打开模式是只有创立这个文件的人才能读写，其他人均无访问权限（输出模式0700代表的就是这个意思）。那么上述程序有一个问题，不知读者是否看出？在正确性方面没有问题，但在效率上却不太令人满意。这是因为该程序的系统调用次数太多，而系统调用需要陷入到内核。另外，每次系统调用都需要进行磁盘操作，而磁盘操作的效率远远低于内存操作的效率。解决这个问题的办法是可以将缓冲区变大，从而降低系统调用和磁盘访问的次数。但缓冲区越大，需要的内存就越大，将造成程序的可执行性下降。而且，就算缓冲区很大，文件还可以更大，还是不能从根本上解决效率低的问题。那有没有其他办法解决效率低下的问题呢？当然有，就是不使用系统调用。而是采用我们下面将要讲述的内存映射的文件访问。
+文件拷贝程序的工作原理很简单：打开源文件和目标文件，循环往复地将源文件的内容读到一个缓冲区，然后将缓冲区的内容写到输出目标文件里。当拷贝结束后，关闭源文件和目标文件。上述程序中使用的文件系统调用包括fin.open、fout.open、fin.get等。这里需要注意的是，输入文件的打开模式为只读，而输出文件的打开模式是只有创立这个文件的人才能读写，其他人均无访问权限（输出模式0700代表的就是这个意思）。那么上述程序有一个问题，不知读者是否看出？在正确性方面没有问题，但在效率上却不太令人满意。这是因为该程序的系统调用次数太多，而系统调用需要陷入到内核。另外，每次系统调用都需要进行磁盘操作，而磁盘操作的效率远远低于内存操作的效率。解决这个问题的办法是可以将缓冲区变大，从而降低系统调用和磁盘访问的次数。但缓冲区越大，需要的内存就越大，将造成程序的可执行性下降。而且，就算缓冲区很大，文件还可以更大，还是不能从根本上解决效率低的问题。那有没有其他办法解决效率低下的问题呢？当然有，就是不使用系统调用。而是采用我们下面将要讲述的内存映射的文件访问。
 
 
 
@@ -78,6 +74,40 @@
 
 这样做的好处就是磁盘访问变成了内存访问，效率自然提高。例如，还是我们前面的文件拷贝，这次不用文件系统调用来实现，而是使用内存映射的文件访问来实现。例如，我们可以将文件a和b均映射到同一个进程的不同虚拟地址上。这样读a文件对应的虚地址将把a的内容从磁盘上拷贝到内存，再把内容写到b对应的虚地址上即可。不过需要提醒的是，内存映射的文件访问不是为了文件拷贝而提出的，而是为了文件的共享。具体来说，我们可以将同一个文件映射到两个或多个进程的虚地址空间。这样每个进程对相应的虚地址空间进行访问时就是对同一个文件进行访问。
 
+这里我突然不明白内存映射和DMA有什么区别？
+
+1. https://stackoverflow.com/questions/3851677/what-is-the-difference-between-dma-and-memory-mapped-io
+
+    Memory-mapped I/O allows the CPU to control hardware by reading and writing specific memory addresses. Usually, this would be used for low-bandwidth operations such as changing control bits.
+
+    DMA allows hardware to directly read and write memory *without* involving the CPU. Usually, this would be used for high-bandwidth operations such as disk I/O or camera video input.
+
+
+
+2. https://www.quora.com/What-is-the-difference-between-direct-memory-access-and-memory-mapped-I-O-systems
+
+    Direct memory access and memory-mapped I/O are related as you’ll see below, but they are not opposites and can’t be compared directly.
+
+    **Memory-mapped I/O and port-based I/O**
+
+    There are two principal types of input/output in microprocessors and microcontrollers (and other types of computers too) — memory-mapped I/O and port-based I/O.
+
+    Memory-mapped I/O means a peripheral device is addressed just the same as memory, and resides in the same address space as data memory.
+
+    With port-based I/O, ports are addressed using special instructions such as `in `for input and `out `for output, followed by the port number, usually 0–255 or 0–65535. The port number will usually be output on the same address bus as would be used for a memory reference, but there will be a pin such as [math]M/\overline{IO}[/math] on the microprocessor which is brought high to indicate an peripheral device is being addressed instead of memory.
+
+    Port addressing was popular in early microprocessors, because it didn’t take away addresses from the limited (typically 64K) address map of an 8 or 16-bit processor. Note that any microprocessor that supports port addressing can also use memory-mapped I/O as well.
+
+    **Direct memory access**
+
+    Direct memory access (DMA) allows some peripherals to access RAM memory directly, without the CPU being involved. DMA can also be used to move data from one part of RAM to another.
+
+    Without DMA, an application like streaming I/O would be extremely processor intensive, even with a deep FIFO in the peripheral, since the processor would have to write each datum to the the peripheral.
+
+    Say it is streaming data from a hard drive. With DMA, it can set up a pointer to the beginning of a block of data in memory equal to a sector on the disk, initiate the transfer with the disk controller, and go away until it gets an interrupt that the transfer has completed. The processor may then have to decode the data if it is in a format like MP3. Then it can send the decoded out to a AC97 or I2S codec so the user hears the sound in their headphones, again without the processor actually having to move any data [i](http://itself.so/)tself.
+
+    Without DMA, our machines would feel extremely sluggish or not be usable at all.
+
 
 
 
@@ -178,8 +208,6 @@ inode 节点主要包括了以下信息
 
 
 
-- [参考: ](https://mp.weixin.qq.com/s/oLvTFWibCH53Fv5lj4mTnQ)
-
 
 
 ---
diff --git "a/OperatingSystem/8.\350\231\232\346\213\237\346\234\272.md" "b/OperatingSystem/8.\350\231\232\346\213\237\346\234\272.md"
index e8ba0cbf..ebc16ef3 100644
--- "a/OperatingSystem/8.\350\231\232\346\213\237\346\234\272.md"
+++ "b/OperatingSystem/8.\350\231\232\346\213\237\346\234\272.md"
@@ -107,20 +107,12 @@ DVM运行Java语言的应用和代码。标准的Java编译器将源代码（写
 
 
 
-在了解了通过程序的编译及链接来生成EXE文件的机制后，接下来看一下EXE文件的运行机制。EXE文件是作为单独的文件储存在硬盘中的。通过资源管理器找到并双击EXE文件，就会把EXE文件的内容加载到内存中运行。
-
-请大家思考一下下面的问题。本地代码在对程序中记述的变量进行读写时，是参照数据存储的内存地址来运行命令的。在调用函数时，程序的处理流程就会跳转到存储着函数处理内容的内存地址上。EXE文件作为本地代码的程序，并没有指定变量及函数的实际内存地址。在类似于Windows操作系统这样的可以加载多个可执行程序的运行环境中，每次运行时，程序内的变量及函数被分配到的内存地址都是不同的。那么，在EXE文件中，变量和函数的内存地址的值，是如何来表示的呢？
-
-下面就让我们来揭晓答案。那就是EXE文件中给变量及函数分配了虚拟的内存地址。在程序运行时，虚拟的内存地址会转换成实际的内存地址。链接器会在EXE文件的开头，追加转换内存地址所需的必要信息。这个信息称为再配置信息。
+在了解了通过程序的编译及链接来生成EXE文件的机制后，接下来看一下EXE文件的运行机制。EXE文件是作为单独的文件储存在硬盘中的。通过资源管理器找到并双击EXE文件，就会把EXE文件的内容加载到内存中运行。EXE文件中给变量及函数分配了虚拟的内存地址。在程序运行时，虚拟的内存地址会转换成实际的内存地址。链接器会在EXE文件的开头，追加转换内存地址所需的必要信息。这个信息称为再配置信息。
 
 
 
 EXE文件的再配置信息，就成为了变量和函数的相对地址。相对地址表示的是相对于基点地址的偏移量，也就是相对距离。实现相对地址，也是需要花费一番心思的。在源代码中，虽然变量及函数是在不同位置分散记述的，但在链接后的EXE文件中，变量及函数就会变成一个连续排列的组。这样一来，各变量的内存地址就可以用相对于变量组起始位置这一基点的偏移量来表示，同样，各函数的内存地址也可以用相对于函数组起始位置这一基点的偏移量来表示。而各组基点的内存地址则是在程序运行时被分配的。
 
-
-
-EXE文件的内容分为再配置信息、变量组和函数组，这一点想必大家都清楚了吧。不过，当程序加载到内存后，除此之外还会额外生成两个组，那就是栈和堆。栈是用来存储函数内部临时使用的变量（局部变量），以及函数调用时所用的参数的内存区域。堆是用来存储程序运行时的任意数据及对象的内存领域。
-
 ![加载到内存的程序由4部分构成](https://raw.githubusercontent.com/CharonChui/Pictures/master/progress_memory.jpg?raw=true)        
 
 EXE文件中并不存在栈及堆的组。栈和堆需要的内存空间是在EXE文件加载到内存后开始运行时得到分配的。因而，内存中的程序，就是由用于变量的内存空间、用于函数的内存空间、用于栈的内存空间、用于堆的内存空间这4部分构成的。
diff --git "a/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md" "b/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md"
index 48a912cc..a6c6a9e3 100644
--- "a/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md"
+++ "b/OperatingSystem/AndroidKernal/1.Android\350\277\233\347\250\213\351\227\264\351\200\232\344\277\241.md"
@@ -92,13 +92,6 @@ Linux 使用两级保护机制：0 级供系统内核使用，3 级供用户程
 
 当进程在执行用户自己的代码的时候，我们称其处于用户运行态（用户态）。此时处理器在特权级最低的（3级）用户代码中运行。
 
-系统调用主要通过如下两个函数来实现：
-
-```
-copy_from_user() //将数据从用户空间拷贝到内核空间
-copy_to_user() //将数据从内核空间拷贝到用户空间
-```
-
 
 
 ### 内核模块/驱动
@@ -140,7 +133,7 @@ Binder作为Android系统提供的一种IPC机制。首先一个问题就是为
 
     
 
-    那Binder是怎么操作的呢？这就不得不通道 Linux 下的另一个概念：**内存映射**。
+    那Binder是怎么操作的呢？这就需要知道 Linux 下的另一个概念：**内存映射**。
 
     Binder IPC 机制中涉及到的内存映射通过 mmap() 来实现，mmap()  是操作系统中一种内存映射的方法。内存映射简单的讲就是将用户空间的一块内存区域映射到内核空间。映射关系建立后，用户对这块内存区域的修改可以直接反应到内核空间；反之内核空间对这段区域的修改也能直接反应到用户空间。
 
@@ -185,7 +178,7 @@ Binder作为Android系统提供的一种IPC机制。首先一个问题就是为
 
 到这里又迷糊了，你上面说了这么多Binder这么好，那为啥Android里面还有地方用Socket？SystemServer和Zygote之间的通信为啥不用Binder？
 
-SystemServer和Zygote之间通信不使用Socket的原因是为了要解决fork的问题。UNIX上C++程序设计守则3中规定：多线程程序里不准使用fork。
+SystemServer和Zygote之间通信使用Socket的原因是为了要解决fork的问题。UNIX上C++程序设计守则3中规定：多线程程序里不准使用fork。
 
 而Binder通讯是需要多线程操作的，代理对象对Binder的调用是在Binder线程，需要再通过Handler调用主线程来操作。比如AMS与应用进程通讯，AMS的本地代理IApplicationThread通过调用ScheduleLaunchActivity，调用到的应用进程ApplicationThread的ScheduleLaunchActivity是在Binder线程，需要再把参数封装为一个ActivityClientRecord，sendMessage发送给H类（主线程Handler，ActivityThread内部类）。主要原因是害怕父进程binder线程有锁，然后子进程的主线程一直在等待其子线程（从父进程拷贝过来的子进程）的资源，但是其实父进程的子进程并没有被拷贝过来，造成死锁。
 
@@ -383,7 +376,7 @@ Android的git commit记录：
 
 ​    
 
-**系统定义：**BINDER_VM_SIZE ((1 * 1024 * 1024) - sysconf(_SC_PAGE_SIZE) * 2)  = （1M- sysconf(_SC_PAGE_SIZE) * 2）  
+**系统定义**：BINDER_VM_SIZE ((1 * 1024 * 1024) - sysconf(_SC_PAGE_SIZE) * 2)  = （1M- sysconf(_SC_PAGE_SIZE) * 2）  
 
 **这里的8K，其实就是两个PAGE的SIZE, 物理内存的划分是按PAGE(页)来划分的，一般情况下，一个Page的大小为4K。**
 
@@ -431,15 +424,7 @@ Binder驱动是Android专用的，但底层的驱动架构与Linux驱动一样
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/binder_syscall.png?raw=true)  
 
-简单说，当用户空间调用open()方法，最终会调用binder驱动的binder_open()方法；mmap()/ioctl()方法也是同理，在BInder系列的后续文章从用户态进入内核态，都依赖于系统调用过程。
-
-
-
-
-
-在Android系统开机过程中，Zygote启动时会有一个[虚拟机注册过程](http://gityuan.com/2016/02/13/android-zygote/#jnistartreg)，该过程调用AndroidRuntime::`startReg`方法来完成jni方法的注册。
-
-
+简单说，当用户空间调用open()方法，最终会调用binder驱动的binder_open()方法；mmap()/ioctl()方法也是同理。
 
 
 
diff --git "a/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md" "b/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md"
index ba1a361e..0090c429 100644
--- "a/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md"
+++ "b/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md"
@@ -7,7 +7,7 @@ Binder/Socket用于进程间通信，而Handler消息机制用于同进程的线
 
 ![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/handler_thread_commun.jpg)
 
-由于工作线程与主线程共享地址空间，即Handler实例对象mHandler位于线程间共享的内存堆上，工作线程与主线程都能直接使用该对象，只需要注意多线程的同步问题。工作线程通过mHandler向其成员变量MessageQueue中添加新Message，主线程一直处于loop()方法内，当收到新的Message时按照一定规则分发给相应的handleMessage()方法来处理。所以说，Handler消息机制用于同进程的线程间通信，其核心是线程间共享内存空间，而不同进程拥有不同的地址空间，也就不能用handler来实现进程间通信。
+**由于工作线程与主线程共享地址空间，即Handler实例对象mHandler位于线程间共享的内存堆上，工作线程与主线程都能直接使用该对象**，只需要注意多线程的同步问题。工作线程通过mHandler向其成员变量MessageQueue中添加新Message，主线程一直处于loop()方法内，当收到新的Message时按照一定规则分发给相应的handleMessage()方法来处理。所以说，**Handler消息机制用于同进程的线程间通信，其核心是线程间共享内存空间，而不同进程拥有不同的地址空间，也就不能用handler来实现进程间通信**。
 
 
 
@@ -201,7 +201,7 @@ public static void prepareMainLooper() {
 }
 ```
 
-发现在Looper类中有个prepareMainLooper()的方法，注释上面写的也比较清楚，说这是Android运行环境创建的应用程序的主looper，你不能自己调用这个方法，那我们看一下这个方法是从哪里调用的，ActivityThread类中的main函数，看到这个main函数，就知道这个类不简单， 
+发现在Looper类中有个prepareMainLooper()的方法，注释上面写的也比较清楚，说这是Android运行环境创建的应用程序的主looper，你不能自己调用这个方法，那我们看一下这个方法是从哪里调用的，ActivityThread类中的main函数，看到这个main函数，就知道这个类不简单啊：
 
 ```java
 /**
@@ -546,9 +546,7 @@ public final void removeCallbacksAndMessages(@Nullable Object token) {
 
 ## MessageQueue类的常用方法
 
-MessageQueue非常重要，因为quit、next等都最终调用的是MessageQueue类。
-
-
+MessageQueue非常重要，因为quit、next等都最终调用的是MessageQueue类: 
 
 ```java
 public final class MessageQueue {
@@ -824,7 +822,6 @@ Handler mHandler = new Handler() {
 }
 ```
 当我们这样创建`Handler`的时候`Android Lint`会提示我们这样一个`warning： In Android, Handler classes should be static or leaks might occur.`。       
-     
 一直以来没有仔细的去分析泄露的原因，先把主要原因列一下：    
 - `Android`程序第一次创建的时候，默认会创建一个`Looper`对象，`Looper`去处理`Message Queue`中的每个`Message`,主线程的`Looper`存在整个应用程序的生命周期.
 - `Hanlder`在主线程创建时会关联到`Looper`的`Message Queue`,`Message`添加到消息队列中的时候`Message(排队的Message)`会持有当前`Handler`引用，
diff --git "a/OperatingSystem/AndroidKernal/3.Android Framework\346\241\206\346\236\266.md" "b/OperatingSystem/AndroidKernal/3.Android Framework\346\241\206\346\236\266.md"
index 0e052371..d653e130 100644
--- "a/OperatingSystem/AndroidKernal/3.Android Framework\346\241\206\346\236\266.md"	
+++ "b/OperatingSystem/AndroidKernal/3.Android Framework\346\241\206\346\236\266.md"	
@@ -2,7 +2,7 @@
 
 ## Framework框架
 
-Framework定义了客户端组件和服务端组件功能及接口。后面的阐述中，”应用程序“一般是指”.apk“程序。
+Framework定义了客户端组件和服务端组件功能及接口。
 
 框架中包含三个主要部分，分别是服务端、客户端和Linux驱动。
 
diff --git "a/OperatingSystem/AndroidKernal/6.\345\261\217\345\271\225\347\273\230\345\210\266\345\237\272\347\241\200.md" "b/OperatingSystem/AndroidKernal/6.\345\261\217\345\271\225\347\273\230\345\210\266\345\237\272\347\241\200.md"
index e24311b8..feeb1c49 100644
--- "a/OperatingSystem/AndroidKernal/6.\345\261\217\345\271\225\347\273\230\345\210\266\345\237\272\347\241\200.md"
+++ "b/OperatingSystem/AndroidKernal/6.\345\261\217\345\271\225\347\273\230\345\210\266\345\237\272\347\241\200.md"
@@ -29,7 +29,7 @@ Android的屏幕绘制架构如下图：
 
         该构造函数包含窗口大小相关的参数，使用该构造函数会创建一个真正的Surface对象。
 
-    WindowManager类的addView()函数会创建一个ViewRoot对象，而ViewRoot类则使用Surface的无参数构造函数创建了一个Surface对象，此时该Surface是一个空壳，然后ViewRoot类调用WmS中的IWindowSession服务为该Surface对象分配真正的屏幕缓冲区内容。之后Surface的构造函数回去创建一个Canvas对象，然后调用init()函数来初始化该Surface对象，该函数内部会首先获得一个SurfaceComposerClient对象，该类正式native层面上的SurfaceFlinger服务的客户端对象，然后调用该对象的createSurface()函数创建一个真正的Surface对象。之后调用Surface的lock()函数获取一个SurfaceInfo对象。该SurfaceInfo对象中获取该Surface对应屏幕缓冲区内存地址。再用这个地址构造一个SkBitmap对象，之后用SkBitmap对象构造一个SkCanvas对象，这个SkCanvas对象是底层真正进行绘制的功能类对象，Java层面的Canvas类仅仅是该类的包装而已，之后将Canvas对象返回到Java端。
+    WindowManager类的addView()函数会创建一个ViewRoot对象，而ViewRoot类则使用Surface的无参数构造函数创建了一个Surface对象，此时该Surface是一个空壳，然后ViewRoot类调用WmS中的IWindowSession服务为该Surface对象分配真正的屏幕缓冲区内容。之后Surface的构造函数会去创建一个Canvas对象，然后调用init()函数来初始化该Surface对象，该函数内部会首先获得一个SurfaceComposerClient对象，该类正是native层面上的SurfaceFlinger服务的客户端对象，然后调用该对象的createSurface()函数创建一个真正的Surface对象。之后调用Surface的lock()函数获取一个SurfaceInfo对象。该SurfaceInfo对象中获取该Surface对应屏幕缓冲区内存地址。再用这个地址构造一个SkBitmap对象，之后用SkBitmap对象构造一个SkCanvas对象，这个SkCanvas对象是底层真正进行绘制的功能类对象，Java层面的Canvas类仅仅是该类的包装而已，之后将Canvas对象返回到Java端。
 
 - Canvas类：是一个功能类，该类包含各种绘制函数，例如drawColor()、drawLine()等。构造Canvas对象时，必须为该Canvas指定一段内存地址，因为绘制的结果实际上就是给这段内存地址中填充不同的像素值。这段内存有两种类型，一种是普通的内存，另一种是屏幕缓冲区内存，当Canvas对应的内存为屏幕缓冲区内存时，绘制函数执行后就可以在屏幕上看到，如果是一段普通内存，则不会在屏幕上看到，不过却可以将这段内存复制到拥有屏幕缓冲内存的Canvas中，这种方式就是游戏开发中常用的方式。
 
diff --git "a/OperatingSystem/AndroidKernal/8.WindowManagerService\347\256\200\344\273\213.md" "b/OperatingSystem/AndroidKernal/8.WindowManagerService\347\256\200\344\273\213.md"
index 949eaffd..d3bb82f4 100644
--- "a/OperatingSystem/AndroidKernal/8.WindowManagerService\347\256\200\344\273\213.md"
+++ "b/OperatingSystem/AndroidKernal/8.WindowManagerService\347\256\200\344\273\213.md"
@@ -15,13 +15,13 @@ WmS是Android中图形用户接口的引擎，它管理着所有窗口，包括
 
 
 
-打个比方，就像一出由N个演员参与的话剧：SurfaceFlinger是摄像机，WMS是导演，ViewRoot则是演员个体。摄像机（SurfaceFlinger）的作用是单一而规范的，它负责客观地捕获当前的画面，然后真是的呈现给观众。导演（WMS）则会考虑到话剧的舞台效果和视觉美感，如他需要根据实际情况来安排各个演员的排序站位，谁在前谁在后，都会影响到演出的”画面效果“与”剧情编排“，而各个演员的长相和标清（ViewRoot）则更多的取决于他们自身的条件与努力。正式通过这三者的”各司其职“，才能最终为观众呈现出异常美妙绝伦的”视觉盛宴“。
+打个比方，就像一出由N个演员参与的话剧：SurfaceFlinger是摄像机，WMS是导演，ViewRoot则是演员个体。摄像机（SurfaceFlinger）的作用是单一而规范的，它负责客观地捕获当前的画面，然后真是的呈现给观众。导演（WMS）则会考虑到话剧的舞台效果和视觉美感，如他需要根据实际情况来安排各个演员的排序站位，谁在前谁在后，都会影响到演出的”画面效果“与”剧情编排“，而各个演员的长相和表情（ViewRoot）则更多的取决于他们自身的条件与努力。正式通过这三者的”各司其职“，才能最终为观众呈现出异常美妙绝伦的”视觉盛宴“。
 
 Android采用层叠式布局，这种布局的特点在于允许多个窗口层叠显示。该布局一般都需要一个窗口管理服务端。从程序设计的角度看，有两种设计模式可以实现服务端: 
 
 - 独立进程方式
 
-    使用一个独立的进程专门用于屏幕的绘制和消息处理，所有的其他引用程序当需要创建窗口时，通过进程通信的方式请求管理服务创建窗口。比如Linux上的X-window就是一种独立进程的方式，它使用Socket通信的方式，通知窗口管理服务进行窗口的创建及交互消息传递。
+    使用一个独立的进程专门用于屏幕的绘制和消息处理，所有的其他应用程序当需要创建窗口时，通过进程通信的方式请求管理服务创建窗口。比如Linux上的X-window就是一种独立进程的方式，它使用Socket通信的方式，通知窗口管理服务进行窗口的创建及交互消息传递。
 
 - 共享库方式
 
@@ -34,14 +34,14 @@ Android采用层叠式布局，这种布局的特点在于允许多个窗口层
 在WmS内部逻辑中，会进行三种常见的操作，具体的操作可能会对应不同的函数名称，这三种常见的操作为assign layer、perform layout以及place surface:    
 
 - Assign layer的意思是为窗口分配层值。在WmS中，每个窗口都是用WindowState类来描述，而窗口要在界面上显示时，需要制定窗口的层值。从用户的视角来看，层值越大，其窗口越靠近用户，窗口之间的层叠正式按照层值进行的。
-- perform layout的意思是计算窗口的大小。每个窗口对应都必须有一个大小，即窗口大小，perform layout将根据状态栏大小、输入法窗口的状态、窗口动画状态计算该窗口的大小。
+- perform layout的意思是计算窗口的大小。每个窗口对象都必须有一个大小，即窗口大小，perform layout将根据状态栏大小、输入法窗口的状态、窗口动画状态计算该窗口的大小。
 - place surface的意思是调整Surface对象的属性，并重新将其显示到屏幕上。由于assign layer和perform layout的执行结果影响的仅仅是WindowState中的参数，而能够显示到屏幕上的窗口都包含一个Surface对象，因此只有将以上执行结果的窗口层值、大小设置到Surface对象中，屏幕上才能看出该窗口的变化。place surface的过程就是将这些值赋值给Surface对象，并告诉Surface Flinger服务重新显示这些Surface对象。
 
 
 
 ### WmS接口结构
 
-WmS接口结构是指WmS功能模块与其他模块之间的交互接口，其中主要包括与AmS模块及应用程序客户端的接口，
+WmS接口结构是指WmS功能模块与其他模块之间的交互接口，其中主要包括与AmS模块及应用程序客户端的接口。
 
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/wms_api.png)
 
@@ -137,4 +137,4 @@ Surface的销毁有两种情况:
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/OperatingSystem/AndroidKernal/9.PackageManagerService\347\256\200\344\273\213.md" "b/OperatingSystem/AndroidKernal/9.PackageManagerService\347\256\200\344\273\213.md"
index 83a469b5..d26ae20e 100644
--- "a/OperatingSystem/AndroidKernal/9.PackageManagerService\347\256\200\344\273\213.md"
+++ "b/OperatingSystem/AndroidKernal/9.PackageManagerService\347\256\200\344\273\213.md"
@@ -41,7 +41,7 @@
 
     - 应用程序所使用的数据文件
 
-        应用程序可以使用三种数据保存方式，分为为参数存储、数据库存储、文件存储。这三种存储方式对应的数据文件一般都保存到/data/data/xxx目录下，xxx代表程序的包名。
+        应用程序可以使用三种数据保存方式，分为参数存储、数据库存储、文件存储。这三种存储方式对应的数据文件一般都保存到/data/data/xxx目录下，xxx代表程序的包名。
 
 
 

From 59eab6a22575bb49b07fb03b213ced4117f907dd Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Fri, 23 Apr 2021 15:43:36 +0800
Subject: [PATCH 060/213] =?UTF-8?q?add=20JVM=E6=9E=B6=E6=9E=84.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../JVM\346\236\266\346\236\204.md"           | 221 ++++++++++++++++++
 ...05\345\255\230\346\250\241\345\236\213.md" | 191 +++++++++++++++
 ...76\350\256\241\346\250\241\345\274\217.md" |  18 +-
 ...0\347\273\204&\351\233\206\345\220\210.md" |   8 +-
 ...7&\345\205\263\351\224\256\345\255\227.md" |  26 +--
 ...2\344\270\276&\345\247\224\346\211\230.md" |  39 ++--
 ...47\346\211\277\351\227\256\351\242\230.md" |   6 +-
 ...5\345\260\204&\346\211\251\345\261\225.md" |  26 +--
 .../8.Kotlin_\345\215\217\347\250\213.md"     |  14 +-
 9 files changed, 470 insertions(+), 79 deletions(-)
 create mode 100644 "JavaKnowledge/JVM\346\236\266\346\236\204.md"
 create mode 100644 "JavaKnowledge/Java\345\206\205\345\255\230\346\250\241\345\236\213.md"

diff --git "a/JavaKnowledge/JVM\346\236\266\346\236\204.md" "b/JavaKnowledge/JVM\346\236\266\346\236\204.md"
new file mode 100644
index 00000000..a73cb5b8
--- /dev/null
+++ "b/JavaKnowledge/JVM\346\236\266\346\236\204.md"
@@ -0,0 +1,221 @@
+# JVM架构
+
+Java的主要优势在于，它被设计为可在具有WORA(write once, run anywhere)概念的各种平台上运行-“一次编写，可在任何地方运行”。
+
+Java源代码会被JDK内置的Java编译器(javac)编译成称为字节码(即.class文件)的中间状态，
+
+这些字节码是带有操作码操作数的十六进制格式，并且JVM可以将这些指令（无需进一步重新编译）解释为操作系统和底层硬件平台可以理解的本地语言。因此，字节码充当独立于平台的中间状态，该状态可在任何JVM之间移植，而与底层操作系统和硬件体系结构无关。
+
+但是，由于JVM是为运行基础硬件和OS结构并与之通信而开发的，因此我们需要为我们的OS版本（Windows，Linux，Mac）和处理器体系结构（x86，x64）选择适当的JVM版本。
+
+我们大多数人都知道Java的上述故事，这里的问题是该过程中最重要的组成部分-JVM被当作一个黑匣子教给我们，它可以神奇地解释字节码并执行许多运行时活动，例如JIT（程序执行期间进行实时）编译和GC（垃圾收集）。
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/JVM_Archite    cture.png)
+
+## Class Loader子系统
+
+JVM驻留在内存(RAM)上。在执行过程中，会使用Class Loader子系统将class文件加载到内存中。这称为Java的动态类加载(dynamic class loading)功能。当它在运行时(而非编译时)首次引用类时，它将加载、链接和初始化类文件(.class)。
+
+- 加载
+
+    Class Loader的主要任务就是把编译后的.class文件加载到内存中。通常，class加载过程会从加载main类(有声明static main()的类)。所有后续的类加载尝试都是根据已运行的类中的类引用完成的，如以下情况所述：
+
+    - 当字节码静态引用一个类时
+    - 当字节码创建一个类对象时(例如: Person person = new Person("John"))
+
+    有3种类型的类加载器（与继承属性连接），它们遵循4个主要原则： 
+
+    - 可见性原则
+
+        该原则指出子类加载器可以看到父类加载器加载的类，但是父类加载器找不到子类加载器加载的类。
+
+    - 唯一性原则
+
+        该原则指出，父类加载的类不应再由子类加载器加载，并确保不会发生重复的类加载。
+
+    - 委托层次结构原则
+
+        为了满足上述2个原则，JVM遵循一个委托层次结构来为每个请求装入的类选择类加载器。首先从最低的子级别开始，Application Class Loader将接收到的类加载请求委托给Extension Class Loader，然后Extension Class Loader将该请求委托给Bootstrap Class Loader。如果在Bootstrap路径中找到了所请求的类，则将加载该类。否则，该请求将再次被转移回Extension Class Loader加载器中从该Loader的扩展路径或自定义指定的路径中查找类。如果它也失败，则请求将返回到Application Class Loader中从该Loader的System类路径中查找该类，并且如果Application Class Loader也未能加载所请求的类，则将获得运行时异常— java.lang.ClassNotFoundException。
+
+    - 无卸载原则
+
+        即使类加载器可以加载类，但是无法卸载已加载的类。替代卸载功能的是可以删除当前的类加载器，并创建一个新的类加载器。
+
+    ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/java_class_loaders.png)
+
+    #### 类加载器类型
+
+    - Bootstrap Class Loader
+
+        加载来自rt.jar的标准JDK类，例如引导路径中存在的核心Java API类-$ JAVA_HOME/jre/lib目录（例如java.lang。*包类）。它以C / C ++之类的本地语言实现，并是Java中所有类加载器的父级。
+
+    - Extension Class Loader
+
+        将类加载请求委托给其父类Bootstrap，如果不成功，则从扩展路径中的扩展目录（例如，安全扩展功能）中加载-JAVA_HOME/jre/ext或java.ext.dirs系统指定的任何其他目录的类。该类加载器由Java中的sun.misc.Launcher$ExtClassLoader类实现。
+
+    - System/Application Class Loader
+
+        从系统类路径加载应用程序特定的类，可以使用-cp或-classpath命令来在程序执行时动态设置。它在内部使用映射到java.class.path的环境变量。该类加载器由sun.misc.Launcher$AppClassLoader类用Java实现。
+
+    除了上面讨论的3个主要的类加载器，程序员还可以直接在代码本身上创建用户定义的类加载器。这通过类加载器委托模型保证了应用程序的独立性。这种方法用于Tomcat之类的Web应用程序服务器中，以使Web应用程序和企业解决方案独立运行。
+
+    每个类加载器都有自己的名称空间来保存已加载的类。当类加载器加载类时，它将基于存储在名称空间中的完全合格的类名称（FQCN：Fully Qualified Class Name）搜索该类，以检查该类是否已被加载。即使该类具有相同的FQCN但具有不同的名称空间，也将其视为不同的类。不同的名称空间意味着该类已由另一个类加载器加载。
+
+- 链接
+
+    在遵循以下属性的同时，链接涉及验证和准备已加载的类或接口，其直接超类和超接口以及其元素类型。
+
+    - 在链接一个类或接口之前，必须将其完全加载。
+    - 在初始化类或接口之前，必须对其进行完全验证和准备（在下一步中）。
+    - 如果在链接过程中发生错误，则会将其抛出到程序中的某个位置，在该位置，程序将采取某些操作，这些操作可能直接或间接地需要链接到错误所涉及的类或接口。
+
+    链接分为以下三个阶段： 
+
+    - Verification
+
+        确保.class文件的正确性（代码是否根据Java语言规范正确编写？它是由有效的编译器根据JVM规范生成的吗？）。这是类加载过程中最复杂的测试过程，并且耗时最长。即使链接减慢了类加载过程的速度，它也避免了在执行字节码时多次执行这些检查的需要，从而使整体执行高效而有效。如果验证失败，则会引发运行时错误（java.lang.VerifyError）。例如，执行以下检查: 
+
+        ```java
+        - consistent and correctly formatted symbol table
+        - final methods / classes not overridden
+        - methods respect access control keywords
+        - methods have correct number and type of parameters
+        - bytecode doesn’t manipulate stack incorrectly
+        - variables are initialized before being read
+        - variables are a value of the correct type
+        ```
+
+        
+
+    - Preparation
+
+        为静态存储和JVM使用的任何数据结构（例如方法表）分配内存。静态字段已创建并初始化为其默认值，但是，在此阶段不执行任何初始化程序或代码，因为这是初始化的一部分。
+
+    - Resolution
+
+        用直接引用替换类型中的符号引用。通过搜索方法区域以找到引用的实体来完成此操作。
+
+- 初始化
+
+    在这里，将执行每个加载的类或接口的初始化逻辑（例如，调用类的构造函数）。由于JVM是多线程的，因此应在适当同步的情况下非常仔细地进行类或接口的初始化，以避免其他线程尝试同时初始化同一类或接口（即使其成为线程安全的）。
+
+    这是类加载的最后阶段，所有静态变量都分配有代码中定义的原始值，并且将执行静态块（如果有）。这是在类中从上到下，从类层次结构中的父级到子级逐行执行的。
+
+### 对象的创建
+
+ Java 对象的创建过程： 
+1. 类加载检查
+    虚拟机遇到一条 new 指令时，首先将去检查这个指令的参数是否能在常量池中定位到这个类的符号引用，并且检查这个符号引用代表的类是否已被加载过、解析和初始化过。如果没有，那必须先执行相应的类加载过程。
+2. 分配内存
+    在类加载检查通过后，接下来虚拟机将为新生对象分配内存。对象所需的内存大小在类加载完成后便可确定，为对象分配空间的任务等同于把一块确定大小的内存从 Java 堆中划分出来。分配方式有 “指针碰撞” 和 “空闲列表” 两种，选择那种分配方式由 Java 堆是否规整决定，而Java堆是否规整又由所采用的垃圾收集器是否带有压缩整理功能决定。
+3. 初始化零值
+    内存分配完成后，虚拟机需要将分配到的内存空间都初始化为零值（不包括对象头），这一步操作保证了对象的实例字段在 Java 代码中可以不赋初始值就直接使用，程序能访问到这些字段的数据类型所对应的零值。
+4. 设置对象头
+    初始化零值完成之后，虚拟机要对对象进行必要的设置，例如这个对象是那个类的实例、如何才能找到类的元数据信息、对象的哈希吗、对象的 GC 分代年龄等信息。 这些信息存放在对象头中。 另外，根据虚拟机当前运行状态的不同，如是否启用偏向锁等，对象头会有不同的设置方式。
+5. 执行init方法
+    在上面工作都完成之后，从虚拟机的视角来看，一个新的对象已经产生了，但从 Java 程序的视角来看，对象创建才刚开始，<init> 方法还没有执行，所有的字段都还为零。所以一般来说，执行 new 指令之后会接着执行 <init> 方法，把对象按照程序员的意愿进行初始化，这样一个真正可用的对象才算完全产生出来。
+
+
+### 对象的内存布局
+在 Hotspot 虚拟机中，对象在内存中的布局可以分为3快区域：对象头、实例数据和对齐填充。
+Hotspot虚拟机的对象头包括两部分信息，第一部分用于存储对象自身的自身运行时数据（哈希吗、GC分代年龄、锁状态标志等等），另一部分是类型指针，即对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是那个类的实例。
+实例数据部分是对象真正存储的有效信息，也是在程序中所定义的各种类型的字段内容。
+对齐填充部分不是必然存在的，也没有什么特别的含义，仅仅起占位作用。 因为Hotspot虚拟机的自动内存管理系统要求对象起始地址必须是8字节的整数倍，换句话说就是对象的大小必须是8字节的整数倍。而对象头部分正好是8字节的倍数（1倍或2倍），因此，当对象实例数据部分没有对齐时，就需要通过对齐填充来补全。
+
+
+### 对象的访问定位
+建立对象就是为了使用对象，我们的Java程序通过栈上的 reference 数据来操作堆上的具体对象。对象的访问方式有虚拟机实现而定，目前主流的访问方式有①使用句柄和②直接指针两种：
+1. 句柄
+    如果使用句柄的话，那么Java堆中将会划分出一块内存来作为句柄池，reference 中存储的就是对象的句柄地址，而句柄中包含了对象实例数据与类型数据各自的具体地址信息；
+    
+    ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/java_refe_jubing.png)
+    
+2. **直接指针：** 如果使用直接指针访问，那么 Java 堆对像的布局中就必须考虑如何防止访问类型数据的相关信息，reference 中存储的直接就是对象的地址。
+
+    ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/java_refe_direct.png)
+
+这两种对象访问方式各有优势。使用句柄来访问的最大好处是 reference 中存储的是稳定的句柄地址，在对象被移动时只会改变句柄中的实例数据指针，而 reference 本身不需要修改。使用直接指针访问方式最大的好处就是速度快，它节省了一次指针定位的时间开销。
+
+
+
+## Runtime Data Area
+
+运行时数据区是当JVM程序在OS上运行时分配的存储区。除了读取.class文件之外，Class Loader子系统还会生成相应的二进制数据，并将以下信息分别保存在每个类的Method区域中： 
+
+- 加载的类及其直接父类的全限定名称
+- .class文件是否与Class / Interface / Enum相关
+- 修饰符，静态变量和方法信息等。
+
+然后，对于每个已加载的.class文件，它都会按照java.lang包中的定义，恰好创建一个Class对象来表示堆内存中的文件。稍后，在我们的代码中，可以使用此Class对象读取类级别的信息（类名称，父名称，方法，变量信息，静态变量等）。
+
+
+
+TODO ... 具体可参考
+
+
+
+## Execution Engine
+
+字节码的实际执行在这里进行。执行引擎通过读取分配给上述运行时数据区域的数据逐行执行字节码中的指令。
+
+
+
+### Interpreter
+
+解释器解释字节码并一对一执行指令。因此，它可以快速解释一个字节码行，但是执行解释后的结果是一项较慢的任务。缺点是，当多次调用一个方法时，每次都需要新的解释和较慢的执行速度。
+
+### Just-In-Time (JIT) Compiler
+
+如果只有解释器可用，则当多次调用一个方法时，每次也会进行解释，如果有效处理，这将是多余的操作。使用JIT编译器已经可以做到这一点。首先，它将整个字节码编译为本地代码（机器代码）。然后，对于重复的方法调用，它直接提供了本机代码，使用本机代码的执行比单步解释指令要快得多。本机代码存储在缓存中，因此可以更快地执行编译后的代码。
+
+但是，即使对于JIT编译器，编译所花费的时间也要比解释器所花费的时间更多。对于仅执行一次的代码段，最好对其进行解释而不是进行编译。同样，本机代码也存储在高速缓存中，这是一种昂贵的资源。在这种情况下，JIT编译器会在内部检查每个方法调用的频率，并仅在所选方法发生超过特定时间级别时才决定编译每个方法。自适应编译的想法已在Oracle Hotspot VM中使用。
+
+当JVM供应商引入性能优化时，执行引擎有资格成为关键子系统。在这些工作中，以下4个组件可以大大提高其性能： 
+
+- 中间代码生成器生成中间代码。
+- 代码优化器负责优化上面生成的中间代码。
+- 目标代码生成器负责生成本机代码（即机器代码）。
+- Profiler是一个特殊的组件，负责查找性能热点（例如，多次调用一种方法的实例）
+
+### 供应商的优化方法
+
+- Oracle Hotspot VMs
+
+    Oracle通过流行的JIT编译器模型Hotspot Compiler实现了其标准Java VM的2种实现。通过分析，它可以确定最需要JIT编译的热点，然后将代码的那些性能关键部分编译为本机代码。随着时间的流逝，如果不再频繁调用这种已编译的方法，它将把该方法标识为不再是热点，并迅速从缓存中删除本机代码，并开始在解释器模式下运行。这种方法可以提高性能，同时避免不必要地编译很少使用的代码。此外，Hotspot Compiler可以即时确定使用lining等技术来优化已编译代码的最佳方式。编译器执行的运行时分析使它可以消除在确定哪些优化将产生最大性能收益方面的猜测。
+    这些虚拟机使用相同的运行时（解释器，内存，线程），但是将自定义构建JIT编译器的实现，如下所述。
+
+    Oracle Java Hotspot Client VM是Oracle JDK和JRE的默认VM技术。它通过减少应用程序启动时间和内存占用量而在客户端环境中运行应用程序时进行了优化，以实现最佳性能。
+    Oracle Java Hotspot Server VM旨在为在服务器环境中运行的应用程序提供最高的程序执行速度。此处使用的JIT编译器称为“高级动态优化编译器”，它使用更复杂和多样化的性能优化技术。通过使用服务器命令行选项（例如Java服务器MyApp）来调用Java HotSpot Server VM。
+
+    Oracle的Java Hotspot技术以其快速的内存分配，快速高效的GC以及易于在大型共享内存多处理器服务器中扩展的线程处理能力而闻名。
+
+- IBM AOT (Ahead-Of-Time) Compiling
+
+    这里的特长是这些JVM共享通过共享缓存编译的本机代码，因此已经通过AOT编译器编译的代码可以由另一个JVM使用，而无需编译。另外，IBM JVM通过使用AOT编译器将代码预编译为JXE（Java可执行文件）文件格式，提供了一种快速的执行方式。
+
+
+
+### Garbage Collector (GC)
+
+只要引用了一个对象，JVM就会认为它是活动的。一旦不再引用对象，因此应用程序代码无法访问该对象，则垃圾收集器将其删除并回收未使用的内存。通常，垃圾回收是在后台进行的，但是我们可以通过调用System.gc（）方法来触发垃圾回收（同样，无法保证执行。因此，请调用Thread.sleep（1000）并等待GC完成）。
+
+
+
+
+
+### JVM线程
+
+我们讨论了如何执行Java程序，但没有具体提及执行程序。实际上，为了执行我们前面讨论的每个任务，JVM并发运行多个线程。这些线程中的一些带有编程逻辑，并且是由程序（应用程序线程）创建的，而其余的则是由JVM本身创建的，以承担系统中的后台任务（系统线程）。
+
+主应用程序线程是作为调用公共静态void main（String []）的一部分而创建的主线程，而所有其他应用程序线程都是由该主线程创建的。应用程序线程执行诸如执行以main（）方法开头的指令，在Heap区域中创建对象（如果它在任何方法逻辑中找到新关键字）之类的任务等。
+
+The major system threads are as follows.
+
+- **Compiler threads**: At runtime, compilation of bytecode to native code is undertaken by these threads.
+- **GC threads**: All the GC related activities are carried out by these threads.
+- **Periodic task thread**: The timer events (i.e. interrupts) to schedule execution of periodic operations are performed by this thread.
+- **Signal dispatcher thread**: This thread receives signals sent to the JVM process and handle them inside the JVM by calling the appropriate JVM methods.
+- **VM thread**: As a pre-condition, some operations need the JVM to arrive at a safe  point where modifications to the Heap area does no longer happen.  Examples for such scenarios are “stop-the-world” garbage collections,  thread stack dumps, thread suspension and biased locking revocation.  These operations can be performed on a special thread called VM thread.
+
+
+
diff --git "a/JavaKnowledge/Java\345\206\205\345\255\230\346\250\241\345\236\213.md" "b/JavaKnowledge/Java\345\206\205\345\255\230\346\250\241\345\236\213.md"
new file mode 100644
index 00000000..a6791057
--- /dev/null
+++ "b/JavaKnowledge/Java\345\206\205\345\255\230\346\250\241\345\236\213.md"
@@ -0,0 +1,191 @@
+Java内存模型
+===
+
+# Java内存结构
+
+在说Java内存模型之前，我们先说一下Java的内存结构，也就是运行时的数据区域，Java虚拟机在执行Java程序的过程中，会把它管理的内存划分为五个不同的数据区域(Heap Memory、Stack Memory、Method Area、PC、Native Stack Memory)，这些区域都有各自的用途、创建时间、销毁时间:     
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/jvm_memory_model.jpeg)
+
+
+## Heap Memory
+- 堆内存在JVM启动的时候被加载(初始大小: -Xms)
+- 堆内存在程序运行时会增加或减少
+- 最小值: -Xmx
+- 从结构上来分，可以分为新生代和老年代。而新生代又可以分为Eden 空间、From Survivor 空间（s0）、To Survivor 空间（s1）。 所有新生成的对象首先都是放在新生代的。需要注意，Survivor的两个区是对称的，没先后关系，所以同一个区中可能同时存在从Eden复制过来的对象，和从前一个Survivor复制过来的对象，而复制到老年代的只有从第一个Survivor区过来的对象。而且，Survivor区总有一个是空的。在 JDK 1.8中移除整个永久代，取而代之的是一个叫元空间（Metaspace）的区域（永久代使用的是JVM的堆内存空间，而元空间使用的是物理内存，直接受到本机的物理内存限制）。
+所有的对象实例和数组都存放到Heap内存中。Heap内存也称为共享内存。多线程可以共享这里面的数据。 在并发编程中，多个线程之间采取什么机制进行通信（信息交换），什么机制进行数据的同步？
+
+在Java语言中，采用的是共享内存模型来实现多线程之间的信息交换和数据同步的。
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/jvm_heap_memory.png)
+## PC(Program Counter Register)
+程序计数器是一块较小的内存空间，可以看作是当前线程所执行的字节码的行号指示器。字节码解释器工作时通过改变这个计数器的值来选取下一条需要执行的字节码指令，分支、循环、跳转、异常处理、线程恢复等功能都需要依赖这个计数器来完。
+另外，为了线程切换后能恢复到正确的执行位置，每条线程都需要有一个独立的程序计数器，各线程之间计数器互不影响，独立存储，我们称这类内存区域为“线程私有”的内存。
+从上面的介绍中我们知道程序计数器主要有两个作用：
+
+字节码解释器通过改变程序计数器来依次读取指令，从而实现代码的流程控制，如：顺序执行、选择、循环、异常处理。
+在多线程的情况下，程序计数器用于记录当前线程执行的位置，从而当线程被切换回来的时候能够知道该线程上次运行到哪儿了。
+
+注意：程序计数器是唯一一个不会出现OutOfMemoryError的内存区域，它的生命周期随着线程的创建而创建，随着线程的结束而死亡。
+
+严格来说是一个数据结构，用于保存当前正在执行的程序的内存地址，由于Java是支持多线程执行的，所以程序执行的轨迹不可能一直都是线性执行。当有多个线程交叉执行时，被中断的线程的程序当前执行到哪条内存地址必然要保存下来，以便用于被中断的线程恢复执行时再按照被中断时的指令地址继续执行下去。为了线程切换后能恢复到正确的执行位置，每个线程都需要有一个独立的程序计数器，各个线程之间计数器互不影响，独立存储，我们称这类内存区域为“线程私有”的内存,这在某种程度上有点类似于“ThreadLocal”，是线程安全的。
+
+它的作用可以看做是当前线程所执行的字节码的行号指示器。
+
+## Stack Memory
+
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/stack_heap.png)
+
+Java栈总是与线程关联在一起的，每当创建一个线程，JVM就会为该线程创建对应的Java栈，在这个Java栈中又会包含多个栈帧(Stack Frame)，栈是由一个个栈帧组成，而每个栈帧中都拥有：局部变量表、操作数栈、动态链接、方法出口信息。局部变量表主要存放了编译器可知的各种数据类型（boolean、byte、char、short、int、float、long、double）、对象引用（reference类型，它不同于对象本身，可能是一个指向对象起始地址的引用指针，也可能是指向一个代表对象的句柄或其他与此对象相关的位置）。
+
+这些栈帧是与每个方法关联起来的，每运行一个方法就创建一个栈帧，每个栈帧会含有一些局部变量、操作栈和方法返回值等信息。每当一个方法执行完成时，该栈帧就会弹出栈帧的元素作为这个方法的返回值，并且清除这个栈帧，Java栈的栈顶的栈帧就是当前正在执行的活动栈，也就是当前正在执行的方法，PC寄存器也会指向该地址。只有这个活动的栈帧的本地变量可以被操作栈使用，当在这个栈帧中调用另外一个方法时，与之对应的一个新的栈帧被创建，这个新创建的栈帧被放到Java栈的栈顶，变为当前的活动栈。同样现在只有这个栈的本地变量才能被使用，当这个栈帧中所有指令都完成时，这个栈帧被移除Java栈，刚才的那个栈帧变为活动栈帧，前面栈帧的返回值变为这个栈帧的操作栈的一个操作数。
+
+JVM内部使用的Java内存模型在线程堆栈和堆之间分配内存。    
+Java虚拟机中的每个线程都有它自己的线程stack。线程stack中包含有关线程调用了哪些方法以达到当前执行点的信息。，也可以称之为调用栈，只要线程执行代码，调用栈就会发生改变。    
+线程stack中同样会包含该线程调用栈中所有方法执行所需要的本地变量，一个线程只能获取到它自己对应的线程stack。一个线程创建的本地变量对于其他任何线程都是不可见的。即使两个线程执行完全相同的代码，这两个线程仍然会在各自自己对应的线程stack中创建自己的本地变量。
+所有基础类型的局部变量(boolean,byte,short,char,int,long,float,double)都被保存在自己的线程stack中。一个线程可以将一个基础变量的副本传递给另一个线程，但是它不能共享原始局部变量本身。    
+堆内存包含在Java应用程序中创建的所有对象，而不管创建该对象的线程是什么。这包括基本类型的对象版本（例如Byte，Integer，Long等）。创建对象并将其分配给局部变量，或者将其创建为另一个对象的成员变量都没有关系，该对象仍存储在堆中。
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/java-memory-model-1.png)
+
+
+局部变量可以是原始类型，在这种情况下，它完全保留在线程堆栈中。
+
+局部变量也可以是对对象的引用。在这种情况下，引用（局部变量）存储在线程堆栈中，但是对象本身（如果存储在堆中）。
+
+一个对象可能包含方法，而这些方法可能包含局部变量。即使该方法所属的对象存储在堆内存中，这些局部变量也存储在线程堆内存中。
+对象的成员变量与对象本身一起存储在堆中。不管成员变量是原始类型时，以及它是对对象的引用时，都是如此。    
+静态类变量也与类定义一起存储在堆中。    
+引用对象的所有线程都可以访问堆上的对象。当线程可以访问对象时，它也可以访问该对象的成员变量。如果两个线程同时在同一个对象上调用一个方法，则它们都将有权访问该对象的成员变量，但是每个线程将拥有自己的局部变量副本。
+
+Java 虚拟机栈会出现两种异常：StackOverFlowError 和 OutOfMemoryError。
+
+StackOverFlowError： 若Java虚拟机栈的内存大小不允许动态扩展，那么当线程请求栈的深度超过当前Java虚拟机栈的最大深度的时候，就抛出StackOverFlowError异常。
+OutOfMemoryError： 若 Java 虚拟机栈的内存大小允许动态扩展，且当线程请求栈时内存用完了，无法再动态扩展了，此时抛出OutOfMemoryError异常。
+
+
+## Method Area
+
+方法区存放了要加载的类的信息（名称、修饰符等）、类中的静态变量、类中定义为final类型的常量、类中的属性(Field)信息(属性信息包括属性名、属性类型、属性修饰符(public, private, protected,static,final volatile,transient的某个子集))、类中的方法信息(方法的相关信息包括：方法名， 方法的返回类型(或 void)， 方法参数的数量和类型(有序的)，方法的修饰符(public, private, protected, static, final, synchronized, native, abstract的一个子集))，以及即时编译器编译后的代码(每个方法：字节码，操作数堆栈大小，局部变量大小，局部变量表，异常表；异常表中的每个异常处理程序：起点，终点，处理程序代码的PC偏移，捕获到的异常类的常量池索引)，当在程序中通过Class对象的getName.isInterface等方法来获取信息时，这些数据都来源于方法区。方法区是被Java线程锁共享的，不像Java堆中其他部分一样会频繁被GC回收，它存储的信息相对比较稳定，在一定条件下会被GC，当方法区要使用的内存超过其允许的大小时，会抛出OutOfMemory的错误信息。方法区也是堆中的一部分，就是我们通常所说的Java堆中的永久区 Permanet Generation，大小可以通过参数来设置,可以通过-XX:PermSize指定初始值，-XX:MaxPermSize指定最大值。
+
+方法区与堆有很多共性：线程共享、内存不连续、可扩展、可垃圾回收，同样当无法再扩展时会抛出OutOfMemoryError异常。
+
+正因为如此相像，Java虚拟机规范把方法区描述为堆的一个逻辑部分，但目前实际上是与Java堆分开的（Non-Heap）。
+方法区的内存回收目标主要是针对常量池的回收和对类型的卸载，一般来说这个区域的回收“成绩”比较难以令人满意，尤其是类型的卸载，条件相当苛刻，但是回收确实是有必要的。
+
+
+很多人愿意把方法区称为“永久代”（Permanent Generation），本质上两者并不等价，仅仅是因为HotSpot虚拟机的设计团队选择把GC 分代收集扩展至方法区，或者说使用永久代来实现方法区而已。对于其他虚拟机（如BEA JRockit、IBM J9 等）来说是不存在永久代的概念的。在Java8中永生代彻底消失了。
+
+#### Constant Pool
+常量池也称为运行时常量池(Runtime Constant Pool),用于存放编译期生成的各种字面量和符号引用。常量池本身是方法区中的一个数据结构。常量池中存储了如字符串、final变量值、类名和方法名常量。常量池在编译期间就被确定，并保存在已编译的.class文件中。一般分为两类：字面量和应用量。字面量就是字符串、final变量等。类名和方法名属于引用量。引用量最常见的是在调用方法的时候，根据方法名找到方法的引用，并以此定为到函数体进行函数代码的执行。引用量包含：类和接口的权限定名、字段的名称和描述符，方法的名称和描述符。
+既然运行时常量池时方法区的一部分，自然受到方法区内存的限制，当常量池无法再申请到内存时会抛出 OutOfMemoryError 异常。
+JDK1.7及之后版本的 JVM 已经将运行时常量池从方法区中移了出来，在 Java 堆（Heap）中开辟了一块区域存放运行时常量池。
+```java
+String str1 = "abcd";
+String str2 = new String("abcd");
+System.out.println(str1==str2);//false
+```
+这两种不同的创建方法是有差别的，第一种方式是在常量池中拿对象，第二种方式是直接在堆内存空间创建一个新的对象。
+```java
+String str1 = "str";
+String str2 = "ing";
+		  
+String str3 = "str" + "ing";//常量池中的对象
+String str4 = str1 + str2; //在堆上创建的新的对象	  
+String str5 = "string";//常量池中的对象
+System.out.println(str3 == str4);//false
+System.out.println(str3 == str5);//true
+System.out.println(str4 == str5);//false
+```
+尽量避免多个字符串拼接，因为这样会重新创建对象。如果需要改变字符串的话，可以使用StringBuilder或者StringBuffer。
+
+Java 基本类型的包装类的大部分都实现了常量池技术，即Byte,Short,Integer,Long,Character,Boolean；这5种包装类默认创建了数值[-128，127]的相应类型的缓存数据，但是超出此范围仍然会去创建新的对象。
+两种浮点数类型的包装类 Float,Double 并没有实现常量池技术。
+```java
+Integer i1 = 33;
+Integer i2 = 33;
+System.out.println(i1 == i2);// 输出true
+Integer i11 = 333;
+Integer i22 = 333;
+System.out.println(i11 == i22);// 输出false
+Double i3 = 1.2;
+Double i4 = 1.2;
+System.out.println(i3 == i4);// 输出false
+```
+
+## Native Method Stack
+本地方法栈和Java栈所发挥的作用非常相似，区别不过是Java栈为JVM执行Java方法服务，而本地方法栈为JVM执行Native方法服务。如Java使用c或c++编写的接口服务时，代码在此区运行，本地方法栈也会抛出StackOverflowError和OutOfMemoryError异常。
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/RDA.png)
+先看一张图，这张图能很清晰的说明JVM内存结构的布局和相应的控制参数：
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/jvm_memory_archi_param.jpeg)
+
+
+主内存和工作内存：
+
+　　Java内存模型的主要目标是定义程序中各个变量的访问规则，即在JVM中将变量存储到内存和从内存中取出变量这样的底层细节。此处的变量与Java编程里面的变量有所不同步，它包含了实例字段、静态字段和构成数组对象的元素，但不包含局部变量和方法参数，因为后者是线程私有的，不会共享，当然不存在数据竞争问题（如果局部变量是一个reference引用类型，它引用的对象在Java堆中可被各个线程共享，但是reference引用本身在Java栈的局部变量表中，是线程私有的）。为了获得较高的执行效能，Java内存模型并没有限制执行引起使用处理器的特定寄存器或者缓存来和主内存进行交互，也没有限制即时编译器进行调整代码执行顺序这类优化措施。
+
+　　JMM规定了所有的变量都存储在主内存（Main Memory）中。每个线程还有自己的工作内存（Working Memory）,线程的工作内存中保存了该线程使用到的变量的主内存的副本拷贝，线程对变量的所有操作（读取、赋值等）都必须在工作内存中进行，而不能直接读写主内存中的变量（volatile变量仍然有工作内存的拷贝，但是由于它特殊的操作顺序性规定，所以看起来如同直接在主内存中读写访问一般）。不同的线程之间也无法直接访问对方工作内存中的变量，线程之间值的传递都需要通过主内存来完成。
+
+
+# Java内存模型
+由上述对JVM内存结构的描述中，我们知道了堆和方法区是线程共享的。而局部变量，方法定义参数和异常处理器参数就不会在线程之间共享，它们不会有内存可见性问题，也不受内存模型的影响。
+
+
+
+Java线程之间的通信由Java内存模型（本文简称为JMM）控制，JMM决定一个线程对共享变量的写入何时对另一个线程可见。从抽象的角度来看，JMM定义了线程和主内存之间的抽象关系：线程之间的共享变量存储在主内存（main memory）中，每个线程都有一个私有的本地内存（local memory），本地内存中存储了该线程以读/写共享变量的副本。本地内存是JMM的一个抽象概念，并不真实存在。它涵盖了缓存，写缓冲区，寄存器以及其他的硬件和编译器优化。Java内存模型的抽象示意图如下：
+
+线程A与线程B之间如要通信的话，必须要经历下面2个步骤：
+
+首先，线程A把本地内存A中更新过的共享变量刷新到主内存中去。
+然后，线程B到主内存中去读取线程A之前已更新过的共享变量。
+
+## 重排
+
+重排序
+在执行程序时为了提高性能，编译器和处理器常常会对指令做重排序。
+
+
+
+这里说的重排序可以发生在好几个地方：编译器、运行时、JIT等，比如编译器会觉得把一个变量的写操作放在最后会更有效率，编译后，这个指令就在最后了（前提是只要不改变程序的语义，编译器、执行器就可以这样自由的随意优化），一旦编译器对某个变量的写操作进行优化（放到最后），那么在执行之前，另一个线程将不会看到这个执行结果。
+
+
+
+当然了，写入动作可能被移到后面，那也有可能被挪到了前面，这样的“优化”有什么影响呢？这种情况下，其它线程可能会在程序实现“发生”之前，看到这个写入动作（这里怎么理解，指令已经执行了，但是在代码层面还没执行到）。通过内存屏障的功能，我们可以禁止一些不必要、或者会带来负面影响的重排序优化，在内存模型的范围内，实现更高的性能，同时保证程序的正确性。
+
+下面我们来看一个重排序的例子：
+```java
+Class Reordering {
+  int x = 0, y = 0;
+  public void writer() {
+    x = 1;
+    y = 2;
+  }
+  public void reader() {
+    int r1 = y;
+    int r2 = x;
+  }
+}
+```
+假设这段代码有2个线程并发执行，线程A执行writer方法，线程B执行reader方法，线程B看到y的值为2，因为把y设置成2发生在变量x的写入之后（代码层面），所以能断定线程B这时看到的x就是1吗？
+
+
+
+当然不行！ 因为在writer方法中，可能发生了重排序，y的写入动作可能发在x写入之前，这种情况下，线程B就有可能看到x的值还是0。
+
+
+
+在Java内存模型中，描述了在多线程代码中，哪些行为是正确的、合法的，以及多线程之间如何进行通信，代码中变量的读写行为如何反应到内存、CPU缓存的底层细节。
+
+
+
+在Java中包含了几个关键字：volatile、final和synchronized，帮助程序员把代码中的并发需求描述给编译器。JMM中定义了它们的行为，确保正确同步的Java代码在所有的处理器架构上都能正确执行。
+参考
+---
+- [Java (JVM) Memory Types](https://javapapers.com/core-java/java-jvm-memory-types/)
+
+
+		
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/KotlinCourse/10.Kotlin_\350\256\276\350\256\241\346\250\241\345\274\217.md" "b/KotlinCourse/10.Kotlin_\350\256\276\350\256\241\346\250\241\345\274\217.md"
index e7afcfdc..f2daad86 100644
--- "a/KotlinCourse/10.Kotlin_\350\256\276\350\256\241\346\250\241\345\274\217.md"
+++ "b/KotlinCourse/10.Kotlin_\350\256\276\350\256\241\346\250\241\345\274\217.md"
@@ -4,8 +4,7 @@
 
 ## 工厂模式
 
-简单工厂的模式，它的核心作用是通过一个工厂类隐藏对象实例的创建逻辑，而不需要暴露给客户端。典型的使用场景就是当拥有一个父类
-与多个子类的时候，我们可以通过这种模式来创建子类对象。
+简单工厂的模式，它的核心作用是通过一个工厂类隐藏对象实例的创建逻辑，而不需要对外暴露。典型的使用场景就是当拥有一个父类与多个子类的时候，我们可以通过这种模式来创建子类对象。
 
 假设现在有一个电脑加工厂，同时生产个人电脑和服务器主机。我们用熟悉的工厂模式设计描述其业务逻辑:  
 
@@ -29,7 +28,7 @@ class ComputerFactory {
     }
 }
 fun main() {
-	val pc = ComputerFactory().produce(ComputerType.PC)
+    val pc = ComputerFactory().produce(ComputerType.PC)
     println(pc.cpu) // Core	
 }
 ```
@@ -53,7 +52,7 @@ object ComputerFactory {
 }
 fun main() {
     // 这样我们就不用再每次都创建对象了
-	val pc = ComputerFactory.produce(ComputerType.PC)
+    val pc = ComputerFactory.produce(ComputerType.PC)
     println(pc.cpu)
 }
 ```
@@ -72,7 +71,7 @@ object ComputerFactory {
 }
 fun main() {
     // 这样就会非常简洁
-	val pc = ComputerFactory(ComputerType.PC)
+    val pc = ComputerFactory(ComputerType.PC)
     println(pc.cpu)
 }
 ```
@@ -99,7 +98,7 @@ interface Computer {
 }
 
 fun main() {
-	val pc = Computer(ComputerType.PC)
+    val pc = Computer(ComputerType.PC)
     println(pc.cpu)
 }
 ```
@@ -121,7 +120,7 @@ interface Computer {
 }
 
 fun main() {
-	val pc = Computer.Factory(ComputerType.PC)
+    val pc = Computer.Factory(ComputerType.PC)
     println(pc.cpu)
 }
 ```
@@ -143,7 +142,7 @@ fun Computer.Factory.fromCPU(cpu: String) : ComputerType? = when(cpu) {
     else -> null
 }
 fun main() {
-	val pc = Computer.Factory.fromCPU("Core")
+    val pc = Computer.Factory.fromCPU("Core")
     println(pc)
 }
 ```
@@ -153,8 +152,7 @@ fun main() {
 ### 内联函数简化抽象工厂
 
 Kotlin中的内联函数有一个很大的作用，就是可以具体化参数类型。利用这一特性，可以改进一种更复杂的工厂模式，称为抽象工厂。 
-上面的例子中已经用工厂模式很好的处理了一个产品登记结构的问题。但是如果现在引入了品牌商的概念，我们有好几个不同的电脑品牌，
-比如Dell、Asus、Acer，那么就有必要再增加一个工厂类。然而，我们并不希望对每个模型都建立一个工厂，这会让代码变得难以维护，
+上面的例子中已经用工厂模式很好的处理了一个产品等级结构的问题。但是如果现在引入了品牌商的概念，我们有好几个不同的电脑品牌，比如Dell、Asus、Acer，那么就有必要再增加一个工厂类。然而，我们并不希望对每个模型都建立一个工厂，这会让代码变得难以维护，
 所以这时候我们就需要引入抽象工厂模式。 
 
 
diff --git "a/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md" "b/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md"
index 2a31cef7..2a3ed383 100644
--- "a/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md"
+++ "b/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md"
@@ -508,7 +508,7 @@ var value2 : String?
 value2 = null       // 编译通过
 ```
 
-在对变量进行操作时，如果变量是可能为空的，那么将不能直接调用，因为编译器不知道你的变量是否为空，所以编译器就要求你一定要对变量进行判断
+在对变量进行操作时，如果变量是可能为空的，那么将不能直接调用，因为编译器不知道你的变量是否为空，所以编译器就要求你一定要对变量进行判断: 
 
 ```kotlin
 var str : String? = null
@@ -612,18 +612,18 @@ class MyRomable {
     
     fun myFunction() {
         if (r is Wolf) {
-            r.eat() // 编译器无法智能的将Roamable的r属性转换成一个Wolf对象，这事因为编译器不能保证在判断r属性类型和使用它的器件，其它代码不会更新该属性，因此这段代码不能编译成功。
+            r.eat() // 编译器无法智能的将Roamable的r属性转换成一个Wolf对象，这是因为编译器不能保证在判断r属性类型和使用它的器件，其它代码不会更新该属性，因此这段代码不能编译成功。
         }
     }
 }
 ```
 
-那么遇到这种情况我们应该如何处理呢？你无须记住所有不能使用智能转换的场景。如果你尝试使用智能转换的方式不合理，编译器会提醒你。编译器会提醒你。
+那么遇到这种情况我们应该如何处理呢？你无须记住所有不能使用智能转换的场景。如果你尝试使用智能转换的方式不合理，编译器会提醒你。
 
 #### 安全的类型转换
 
 如果对象不是目标类型，那么常规类型转换可能会导致`ClassCastException`。
-另一个选择是使用安全的类型转换，如果尝试转换不成功则返回`null{: .keyword }`:    
+另一个选择是使用安全的类型转换，如果尝试转换不成功则返回`null`:    
 
 ```kotlin
 val aInt: Int? = a as? Int
diff --git "a/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md" "b/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md"
index 7c3921ea..4210b7a1 100644
--- "a/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md"
+++ "b/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md"
@@ -18,7 +18,7 @@ val max = if (a > b) {
 
 ## `when`表达式
 
-`when`表达式与`Java`中的`switch/case`类似，但是要强大得多。这个表达式会去试图匹配所有可能的分支直到找到满意的一项。
+`when`表达式与`Java`中的`switch/case`类似，但是要强大的多。这个表达式会去试图匹配所有可能的分支直到找到满意的一项。
 然后它会运行右边的表达式。      
 与`Java`的`switch/case`不同之处是参数可以是任何类型，并且分支也可以是一个条件。
 
@@ -34,8 +34,7 @@ when (x){
 }
 ```
 
-因为它是一个表达式，它也可以返回一个值。我们需要考虑什么时候作为一个表达式使用，它必须要覆盖所有分支的可能性或者实现`else`分支。否则它不会被
-编译成功:   
+因为它是一个表达式，它也可以返回一个值。我们需要考虑什么时候作为一个表达式使用，它必须要覆盖所有分支的可能性或者实现`else`分支。否则它不会被编译成功:   
 
 ```kotlin
 val result = when (x) {
@@ -44,7 +43,7 @@ val result = when (x) {
 }
 ```
 
-如你所见，条件可以是一系列被逗号分割的值。但是它可以更多的匹配方式。比如，我们可以检测参数类型并进行判断:  
+如你所见，条件可以是一系列被逗号分割的值。但是它可以有更多的匹配方式。比如，我们可以检测参数类型并进行判断:  
 
 ```kotlin
 when(view) {
@@ -123,13 +122,13 @@ for (i in array.indices)
 
 ### Ranges
 
-`Range`表达式使用一个`..`操作符。表示就是一个该范围内的数据的数组，包含头和尾
+`Range`表达式使用一个`..`操作符。表示就是一个该范围内的数据的数组，包含头和尾:     
 
 ```kotlin
 var nums = 1..100 
 for(num in nums) {
-	println(num)
-	// 打印出1 2 3 ....100
+    println(num)
+    // 打印出1 2 3 ....100
 }
 ```
 
@@ -168,7 +167,7 @@ for (i in 4 downTo 1 step 2) println(i)
 
 ### Until
 
-上面的`Range`是包含了头和尾，那如果只想包含头不包含尾呢？ 就要用`until`
+上面的`Range`是包含了头和尾，那如果只想包含头不包含尾呢？ 就要用`until`:    
 
 ```kotlin
 var nums = 1 until 100
@@ -205,18 +204,17 @@ for(num in nums) {
 - `public`所有调用的地方都可见
 - `internal`同一个模块中可见
 - `abstract`抽象类标示
-- `final`标示类不可继承，默认属性
-- `enum`标示类为枚举
+- `final`标识类不可继承，默认属性
+- `enum`标识类为枚举
 - `open`类可继承，类默认是`final`的
 - `annotation`注解类
 - `init`主构造函数不能包含任何的代码。初始化的代码可以放到以`init`关键字作为前缀的初始化块(`initializer blocks`)中
-- `field`只能用在属性的访问器内。特别注意的是，`get set`方法中只能能使用`filed`。属性访问器就是`get set`方法。
+- `field`只能用在属性的访问器内。特别注意的是，`get set`方法中只能使用`filed`。属性访问器就是`get set`方法。
 - `:`用于类的继承，变量的定义 
-- `..`围操作符(递增的) `1..5`，`2..6`千万不要`6..2`
+- `..`范围操作符(递增的) `1..5`，`2..6`千万不要`6..2`
 - `::`作用域限定符
 - `inner`类可以标记为`inner {: .keyword }`以便能够访问外部类的成员。内部类会带有一个对外部类的对象的引用
-- `object`对象声明并且它总是在`object{: .keyword }`关键字后跟一个名称。对象表达式：在要创建一个继承自某个(或某些)类型的匿名类的对象会
-    用到
+- `object`对象声明并且它总是在`object{: .keyword }`关键字后跟一个名称。对象表达式：在要创建一个继承自某个(或某些)类型的匿名类的对象会用到
 
 
 
diff --git "a/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md" "b/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
index 1d18d2c4..17884439 100644
--- "a/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
+++ "b/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
@@ -108,7 +108,7 @@ outter.Inner().execute()
 #### 匿名内部类
 
 ```kotlin
-// 通过对象表达式来 创建匿名内部类的对象，可以避免重写抽象类的子类和接口的实现类，这和Java中匿名内部类的是接口和抽象类的延伸一致。
+// 通过对象表达式来创建匿名内部类的对象，可以避免重写抽象类的子类和接口的实现类，这和Java中匿名内部类的是接口和抽象类的延伸一致。
 text.setOnClickListener(object : View.OnClickListener{
     override fun onClick(p0: View?) {
         Log.d("test", p0.string())
@@ -146,7 +146,7 @@ enum class Day {
 
 ```kotlin
 enum class DayOfWeek(val day: Int) {
-	MON(1),
+    MON(1),
     TUE(2),
     WEN(3),
     THU(4),
@@ -162,8 +162,8 @@ enum class DayOfWeek(val day: Int) {
 ```
 枚举可以通过`String`匹配名字来获取，我们也可以获取包含所有枚举的`Array`，所以我们可以遍历它。
 ```kotlin
-val search: Icon = Icon.valueOf("SEARCH")
-val iconList: Array<Icon> = Icon.values()
+val search: DayOfWeek = DayOfWeek.valueOf("MON")
+val iconList: Array<DayOfWeek> = DayOfWeek.values()
 ```
 而且每一个枚举都有一些函数来获取它的名字、声明的位置:    
 ```kotlin
@@ -259,14 +259,9 @@ public abstract class Bird {
 ```
 
 
-密封类用来表示受限的类继承结构:当一个值为有限集中的
-类型、而不能有任何其他类型时。在某种意义上，他们是枚举类的扩展:枚举类型的值集合
-也是受限的，但每个枚举常量只存在一个实例，而密封类
-的一个子类可以有可包含状态的多个实例。
+密封类用来表示受限的类继承结构:当一个值为有限几种的类型、而不能有任何其他类型时。在某种意义上，他们是枚举类的扩展:枚举类型的值集合也是受限的，但每个枚举常量只存在一个实例，而密封类的一个子类可以有可包含状态的多个实例。
 
-要声明一个密封类，需要在类名前面添加`sealed`修饰符。虽然密封类也可以
-有子类，但是所有子类都必须在与密封类自身相同的文件中声明。(在`Kotlin 1.1`之前，
-该规则更加严格:子类必须嵌套在密封类声明的内部)。
+虽然密封类也可以有子类，但是所有子类都必须在与密封类自身相同的文件中声明。(在`Kotlin 1.1`之前，该规则更加严格:子类必须嵌套在密封类声明的内部)。
 
 ```kotlin
 sealed class Expr
@@ -282,7 +277,7 @@ fun eval(expr: Expr): Double = when (expr) {
 ```
 
 使用密封类的关键好处在于使用`when`表达式 的时候，如果能够
-验证语句覆盖了所有情况，就不需要为该语句再添加一个`else`子句了。
+验证语句覆盖了所有情况，就不需要为该语句再添加一个`else`语句了。
 
 ```kotlin
 fun eval(expr: Expr): Double = when(expr) {
@@ -337,8 +332,7 @@ val s = try { x as String } catch(e: ClassCastException) { null }
 在Kotlin中，你将告别static这种语法，因为它引入了全新的关键字object，可以完美的代替使用static的所有场景。
 当然除了代替static的场景之外，它还能实现更多的功能，比如单例对象及简化匿名表达式等。 
 
-声明对象就如同声明一个类，你只需要用保留字`object`替代`class`，其他都相同。只需要考虑到对象不能有构造函数，因为我们不调用任何构造函数来访问
-它们。事实上，对象就是具有单一实现的数据类型。object声明的内容可以看成没有构造方法的类，它会在系统或者类加载时进行初始化。
+声明对象就如同声明一个类，你只需要用保留字`object`替代`class`，其他都相同。只需要考虑到对象不能有构造函数，因为我们不调用任何构造函数来访问它们。事实上，对象就是具有单一实现的数据类型。object声明的内容可以看成没有构造方法的类，它会在系统或者类加载时进行初始化。
 
 ```kotlin
 object Resource {
@@ -426,10 +420,9 @@ class Prize(val name: String, val count: Int, val type: Int) {
 }
 ```
 
-可以发现，该版本在语义上更清晰了。而且，companion object用花括号包裹了所有静态属性和方法，使得它可以与Prize类的普通
-方法和属性清晰的区分开来。最后，我们可以使用点号来对一个类的静态的成员进行调用。  
+可以发现，该版本在语义上更清晰了。而且，companion object用花括号包裹了所有静态属性和方法，使得它可以与Prize类的普通方法和属性清晰的区分开来。最后，我们可以使用点号来对一个类的静态的成员进行调用。  
 
-伴生对象的另一个作用是可以实现工厂方法模式。前面也说过如何从构造方法实现工厂方法模式，然而这种方法存在以下缺点:  
+伴生对象的另一个作用是可以实现工厂方法模式。当然也可以从构造方法实现工厂方法模式，然而这种方法存在以下缺点:  
 
 - 利用多个构造方法语义不够明确，只能靠参数区分
 - 每次获取对象时都需要重新创建对象
@@ -465,8 +458,8 @@ class Prize private constructor(val name: String, val count: Int, val type: Int)
 ```java
 class App : Application() {
     companion object {
-         lateinit var instance: App
-             private set
+         private lateinit var instance: App
+
      }
  
      override fun onCreate() {
@@ -476,9 +469,8 @@ class App : Application() {
 }
 ```
 
-在这例子中，创建一个由`Application`扩展的（派送）的类，并且在`companion object`中存储它的唯一实例。     
-`lateinit`表示这个属性开始是没有值得，但是，在使用前将被赋值（否则，就会抛出异常）。     
-`private set`用于说明外部类不能对其进行赋值。
+在这例子中，创建一个继承`Application`的类，并且在`companion object`中存储它的唯一实例。     
+`lateinit`表示这个属性开始是没有值的，但是，在使用前将被赋值（否则，就会抛出异常）。     
 
 ### 单例
 
@@ -696,8 +688,7 @@ fun test(){
 
 ##### map映射
 
-一个常见的用例是在一个映射`map`里存储属性的值。这经常出现在像解析`JSON`或者做其他“动态”事情的应用中。在这种情况下，你可以使用映射实例自身作
-为委托来实现委托属性。
+一个常见的用例是在一个映射`map`里存储属性的值。这经常出现在像解析`JSON`或者做其他“动态”事情的应用中。在这种情况下，你可以使用映射实例自身作为委托来实现委托属性。
 
 ```kotlin
 class User(val map: Map<String, Any?>) {
diff --git "a/KotlinCourse/6.Kotlin_\345\244\232\347\273\247\346\211\277\351\227\256\351\242\230.md" "b/KotlinCourse/6.Kotlin_\345\244\232\347\273\247\346\211\277\351\227\256\351\242\230.md"
index 3dbf5fe7..331c030d 100644
--- "a/KotlinCourse/6.Kotlin_\345\244\232\347\273\247\346\211\277\351\227\256\351\242\230.md"
+++ "b/KotlinCourse/6.Kotlin_\345\244\232\347\273\247\346\211\277\351\227\256\351\242\230.md"
@@ -3,7 +3,7 @@
 
 
 
-继承和实现是面向对象程序设计中不变的主题。Java是不支持类的多继承的，Kotlin亦是如此。我们他们要这样设计呢？ 现实中，其实多继承的需求经常会出现，然而类的多继承方式会导致进程关系上语义的混淆。
+继承和实现是面向对象程序设计中不变的主题。Java是不支持类的多继承的，Kotlin亦是如此。他们为什么要这样设计呢？ 现实中，其实多继承的需求经常会出现，然而类的多继承方式会导致进程关系上语义的混淆。
 
 
 
@@ -177,10 +177,10 @@ fun main(args: Array<String>) {
 }
 ```
 
-有人可能会有疑问： 首先，委托方式怎么跟接口实现多继承如此相似，而且好像也并没有简单多少。其次，这种方式好像跟组合也很想，那么它到底有什么优势? 主要有以下两点:   
+有人可能会有疑问： 首先，委托方式怎么跟接口实现多继承如此相似，而且好像也并没有简单多少。其次，这种方式好像跟组合也很像，那么它到底有什么优势? 主要有以下两点:   
 
 - 前面说到接口是无状态的，所以即使它提供了默认方法实现也是很简单的，不能实现复杂的逻辑，也不推荐在接口中实现复杂的方法逻辑。我们可以利用上面委托的这种方式，虽然它也是接口委托，但它是用一个具体的类去实现方法逻辑，可以拥有更强大的能力。
-- 假设我们需要继承的类是A，委托对象是B、C，我们再具体调用的时候并不是像组合一样A.B.method，而是可以直接调用A.method，这更能表达A拥有该method的能力，更加直观，虽然背后也是通过委托对象来执行具体的方法逻辑的。
+- 假设我们需要继承的类是A，委托对象是B、C，我们在具体调用的时候并不是像组合一样A.B.method，而是可以直接调用A.method，这更能表达A拥有该method的能力，更加直观，虽然背后也是通过委托对象来执行具体的方法逻辑的。
 
 
 
diff --git "a/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md" "b/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md"
index 8bd40753..9f3486e3 100644
--- "a/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md"
+++ "b/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md"
@@ -48,8 +48,7 @@ class Foo @Inject constructor(dependency: MyDependency) {
 反射是这样的一组语言和库功能，它允许在运行时自省你的程序的结构。
 `Kotlin`让语言中的函数和属性做为一等公民、并对其自省（即在运行时获悉一个名称或者一个属性或函数的类型）与简单地使用函数式或响应式风格紧密相关。
 
-在`Java`平台上，使用反射功能所需的运行时组件作为单独的`JAR`文件(`kotlin-reflect.jar`)分发。这样做是为了减少不使用反射功能的应用程序所需的
-运行时库的大小。如果你需要使用反射，请确保该`.jar`文件添加到项目的`classpath`中。
+在`Java`平台上，使用反射功能所需的运行时组件作为单独的`JAR`文件(`kotlin-reflect.jar`)分发。这样做是为了减少不使用反射功能的应用程序所需的运行时库的大小。如果你需要使用反射，请确保该`.jar`文件添加到项目的`classpath`中。
 
 
 ### 类引用
@@ -83,8 +82,7 @@ println(numbers.filter(::isOdd)) // 输出 [1, 3]
 
 扩展是`kotlin`中非常重要的一个特性，扩展函数允许我们在不改变已有类的情况下，为类添加新的函数。
 扩展函数是指对类的方法进行扩展，写法和定义方法类似，但是要声明目标类，也就是对哪个类进行扩展，`kotlin`中称之为`Top Level`。
-扩展函数表现得就像是属于这个类的一样，而且我们可以使用`this`关键字和调用所有`public`方法。
-扩展函数可以在已有类中添加新的方法，不会对原类做修改，扩展函数定义形式:
+扩展函数表现得就像是属于这个类的一样，而且我们可以使用`this`关键字和调用所有`public`方法。扩展函数定义形式:
 ```kotlin
 fun receiverType.functionName(params){
     body
@@ -115,9 +113,7 @@ Toast msg : hello, Extension
 
 按照通常的做法，会写一个`ToastUtils`工具类，或者在`BaseActivity`中实现`toast`。但是使用扩展函数就会简单很多。 
 上面的例子就是在`Context`中添加新的方法，让我们以更简单的方式去显示`toast`，并且不用传入任何`context`参数，
-可以被任何`Context`或者它的子类调用。我们可以在任何地方(例如一个工具类文件中)声明这个函数，然后在`Activity`中将
-它作为普通方法来直接调用。其中`Context`就是目标类`Top Level`，我们把它放到方法名前，用点`.`表示从属关系。在方法体中用关键字
-`this`对本体进行调用。和普通方法一样，如果有返回值，在方法后面跟上返回类型，我这里没有返回值，所以直接省略了。
+可以被任何`Context`或者它的子类调用。我们可以在任何地方(例如一个工具类文件中)声明这个函数，然后在`Activity`中将它作为普通方法来直接调用。其中`Context`就是目标类`Top Level`，我们把它放到方法名前，用点`.`表示从属关系。在方法体中用关键字`this`对本体进行调用。和普通方法一样，如果有返回值，在方法后面跟上返回类型，我这里没有返回值，所以直接省略了。
 
 扩展函数的原理: 通过查看对应的Java代码可以发现:  
 
@@ -351,8 +347,6 @@ toast("hello, ${Extension.name}")
 // 输出
 Toast msg : hello, Extension
 ```
-上面例子中，`companion object`一起是修饰关键字，`part`是方法块的名称。其中方法块名称`part`可以省略，如果省略的话，默认缺省名为
-`Companion`
 
 静态的扩展和普通的扩展类似，但是在目标类要加上静态方法块的名称，所以如果我们要对一个静态部分扩展，就要先知道静态方法块的名称才行。
 
@@ -376,6 +370,8 @@ toast("hello, ${Extension.upCase()}")
 Toast msg : hello, Extension
 Toast msg : hello, EXTENSION
 ```
+上面例子中，`companion object`一起是修饰关键字，`part`是方法块的名称。其中方法块名称`part`可以省略，如果省略的话，默认缺省名为
+`Companion`
 
 
 
@@ -495,10 +491,10 @@ class Kot {
     var age = 0
     fun dealStu() {
         val result = student?.also { stu -> 
-			this.age += stu.age                                    
+            this.age += stu.age                                    
             println(this.age)
-			println(stu.age)
-			this.age                                    
+            println(stu.age)
+            this.age                                    
         }
     }
 }
@@ -681,8 +677,7 @@ boolean isConnected = NetworkUtils.isMobileConnected(context);
 ```
 
 虽然用起来比没有封装之前优雅了很多，但是每次都要传入context，造成的烦琐我们先不计较，重要是可能会让调用者忽视context
-和mobileNetwork间的强关系。作为代码的使用者，我们更希望在调用时省略NetworkUtils类名，并且让isMobileConnected可以
-看起来像context的一个属性或方法。我们期望的是下面这样的使用方式: 
+和mobileNetwork间的强关系。作为代码的使用者，我们更希望在调用时省略NetworkUtils类名，并且让isMobileConnected可以看起来像context的一个属性或方法。我们期望的是下面这样的使用方式: 
 
 ```java
 boolean isConnected = context.isMobileConnected();
@@ -720,8 +715,7 @@ Kotlin允许我们对所有的运算符(+ - * / % ++ --)，以及其他关键字
 指定函数，不同的运算符对应的重载函数是不同的，比如：+ 对应plus() 、 - 对应minus()
 可以在类中，对同一运算符进行多次重载，来满足不同的需求。
 
-运算符重载实际上是函数重载，本质上是对运算符函数的调用，从运算符到对应函数的映射过程由编译器完成。
-或者理解成是对已有的运算符赋予他们新的含义。
+运算符重载实际上是函数重载，本质上是对运算符函数的调用，从运算符到对应函数的映射过程由编译器完成，或者理解成是对已有的运算符赋予他们新的含义。
 
 举例： 
 
diff --git "a/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md" "b/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
index 727998d8..10f39abf 100644
--- "a/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
+++ "b/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
@@ -246,7 +246,7 @@ main: Now I can quit.
 
 ### 取消是协作的
 
-协程的取消是*协作*的。一段协程代码必须协作才能被取消。 所有 `kotlinx.coroutines` 中的挂起函数都是 *可被取消的* 。
+协程的取消是*协作*的。一段协程代码必须协作才能被取消。 所有 `kotlinx.coroutines`中的挂起函数都是 *可被取消的* 。
 它们检查协程的取消，并在取消时抛出 [CancellationException](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-cancellation-exception/index.html)。
 然而，如果协程正在执行计算任务，并且没有检查取消的话，那么它是不能被取消的，就如如下示例代码所示：
 
@@ -386,7 +386,7 @@ async {
 }
 ```
 
-继续该类比,`await()`可以是一个挂起函数(因此也可以在一个`async {}`块中调用)，该函数挂起一个协程，直到一些计算完成并返回其结果:   
+`await()`可以是一个挂起函数(因此也可以在一个`async {}`块中调用)，该函数挂起一个协程，直到一些计算完成并返回其结果:   
 ```kotlin
 async {
     ……
@@ -431,9 +431,7 @@ suspend fun doSomethingUsefulTwo(): Int {
 ```
 
 如果需要按 *顺序* 调用它们，我们接下来会做什么——首先调用 `doSomethingUsefulOne` *接下来* 调用 `doSomethingUsefulTwo`，并且计算它们结果的和吗？ 
-实际上，如果我们要根据第一个函数的结果来决定是否我们需要调用第二个函数或者决定如何调用它时，我们就会这样做。
-
-我们使用普通的顺序来进行调用，因为这些代码是运行在协程中的，只要像常规的代码一样 *顺序* 都是默认的。
+实际上，如果我们要根据第一个函数的结果来决定是否我们需要调用第二个函数或者决定如何调用它时，我们就会使用普通的顺序来进行调用，因为这些代码是运行在协程中的，只要像常规的代码一样 *顺序* 都是默认的。
 下面的示例展示了测量执行两个挂起函数所需要的总时间：
 
 ```kotlin
@@ -507,9 +505,9 @@ The answer is 42
 Completed in 1017 ms
 ```
 
-因此，在先前的例子中这里定义的两个协程没有执行，但是控制权在于程序员准确的在开始执行时调用 
+因此，在前面的例子中这里定义的两个协程没有执行，但是控制权在于程序员准确的在开始执行时调用 
 [start](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-job/start.html)。
-我们首先 调用 `one`，然后调用 `two`，接下来等待这个协程执行完毕。
+我们首先调用 `one`，然后调用 `two`，接下来等待这个协程执行完毕。
 
 注意，如果我们只是在 `println` 中调用 [await](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-deferred/await.html)，
 而没有在单独的协程中调用 [start](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-job/start.html)，这将会导致顺序行为，
@@ -524,7 +522,7 @@ Completed in 1017 ms
 类型为代表的上下文中，它们被定义在了 Kotlin 的标准库里。
 
 协程上下文是各种不同元素的集合。其中主元素是协程中的 [Job](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-job/index.html)， 
-我们在前面的文档中见过它以及它的调度器，而本文将对它进行介绍。
+我们在前面见过它以及它的调度器。
 
 ### 调度器与线程
 

From b29b22808dce90006ab7be5e389694ee33fd1d8b Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Fri, 23 Apr 2021 19:42:41 +0800
Subject: [PATCH 061/213] update Java Memory Model

---
 ...36\346\224\266\346\234\272\345\210\266.md" |  32 +---
 .../JVM\346\236\266\346\236\204.md"           |  76 ++++----
 ...05\345\255\230\346\250\241\345\236\213.md" | 167 +++++++++++-------
 README.md                                     |   4 +
 4 files changed, 154 insertions(+), 125 deletions(-)

diff --git "a/JavaKnowledge/JVM\345\236\203\345\234\276\345\233\236\346\224\266\346\234\272\345\210\266.md" "b/JavaKnowledge/JVM\345\236\203\345\234\276\345\233\236\346\224\266\346\234\272\345\210\266.md"
index 1b1dfb51..704c9c55 100644
--- "a/JavaKnowledge/JVM\345\236\203\345\234\276\345\233\236\346\224\266\346\234\272\345\210\266.md"
+++ "b/JavaKnowledge/JVM\345\236\203\345\234\276\345\233\236\346\224\266\346\234\272\345\210\266.md"
@@ -1,10 +1,6 @@
 # JVM垃圾回收机制
 
-
-
-## JVM内存模式
-
-JVM内存模型可以分为两个部分，如下图所示，**堆和方法区是所有线程共有的**，而虚拟机栈，本地方法栈和程序计数器则是线程私有的。
+[Java内存模型](https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/Java%E5%86%85%E5%AD%98%E6%A8%A1%E5%9E%8B.md)如下图所示，**堆和方法区是所有线程共有的**，而虚拟机栈，本地方法栈和程序计数器则是线程私有的。
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/jvm.png)
 
@@ -43,32 +39,6 @@ Java 堆是垃圾收集器管理的主要区域，因此也被称作GC 堆（Gar
 
 
 
-### 方法区（Method Area）
-
-方法区也称”永久代“，它用于存储虚拟机加载的类信息、常量、静态变量、是各个线程共享的内存区域。默认最小值为16MB，最大值为64MB（64位JVM由于指针膨胀，默认是85M），可以通过-XX:PermSize 和 -XX:MaxPermSize 参数限制方法区的大小。它是一片连续的堆空间，永久代的垃圾收集是和老年代(old generation)捆绑在一起的，因此无论谁满了，都会触发永久代和老年代的垃圾收集。不过，一个明显的问题是，当JVM加载的类信息容量超过了参数-XX：MaxPermSize设定的值时，应用将会报OOM的错误。参数是通过-XX:PermSize和-XX：MaxPermSize来设定的。
-
-
-
-### 虚拟机栈(JVM Stack)
-
-描述的是java方法执行的内存模型：每个方法被执行的时候都会创建一个”栈帧”,用于存储局部变量表(包括参数)、操作栈、方法出口等信息。每个方法被调用到执行完的过程，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程**。**声明周期与线程相同，是线程私有的。栈帧由三部分组成：局部变量区、操作数栈、帧数据区。局部变量区被组织为以一个字长为单位、从0开始计数的数组，和局部变量区一样，操作数栈也被组织成一个以字长为单位的数组。但和前者不同的是，它不是通过索引来访问的，而是通过入栈和出栈来访问的，可以看作为临时数据的存储区域。除了局部变量区和操作数栈外，java栈帧还需要一些数据来支持常量池解析、正常方法返回以及异常派发机制。这些数据都保存在java栈帧的帧数据区中。
-
-局部变量表: 存放了编译器可知的各种基本数据类型、对象引用(引用指针，并非对象本身)，其中64位长度的long和double类型的数据会占用2个局部变量的空间，其余数据类型只占1个。局部变量表所需的内存空间**在**编译期间完成分配，当进入一个方法时，这个方法需要在栈帧中分配多大的局部变量是完全确定的，在运行期间栈帧不会改变局部变量表的大小空间。
-
-
-
-### 本地方法栈(Native Stack)
-
-与虚拟机栈基本类似，区别在于虚拟机栈为虚拟机执行的java方法服务，而本地方法栈则是为Native方法服务(栈的空间大小远远小于堆)。
-
-### 程序计数器（PC Register）
-
-最小的一块内存区域，它的作用是当前线程所执行的字节码的行号指示器，在虚拟机的模型里，字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令**，**分支**、**循环、异常处理、线程恢复等基础功能都需要依赖计数器完成。
-
-### 直接内存
-
-直接内存并不是虚拟机内存的一部分，也不是Java虚拟机规范中定义的内存区域。jdk1.4中新加入的NIO，引入了通道与缓冲区的IO方式，它可以调用Native方法直接分配堆外内存，这个堆外内存就是本机内存，不会影响到堆内存的大小.
-
 
 
 ## 如何判断对象是垃圾
diff --git "a/JavaKnowledge/JVM\346\236\266\346\236\204.md" "b/JavaKnowledge/JVM\346\236\266\346\236\204.md"
index a73cb5b8..33da8edb 100644
--- "a/JavaKnowledge/JVM\346\236\266\346\236\204.md"
+++ "b/JavaKnowledge/JVM\346\236\266\346\236\204.md"
@@ -10,7 +10,7 @@ Java源代码会被JDK内置的Java编译器(javac)编译成称为字节码(即.
 
 我们大多数人都知道Java的上述故事，这里的问题是该过程中最重要的组成部分-JVM被当作一个黑匣子教给我们，它可以神奇地解释字节码并执行许多运行时活动，例如JIT（程序执行期间进行实时）编译和GC（垃圾收集）。
 
-![](https://raw.githubusercontent.com/CharonChui/Pictures/master/JVM_Archite    cture.png)
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/JVM_Architecture.png)
 
 ## Class Loader子系统
 
@@ -23,47 +23,47 @@ JVM驻留在内存(RAM)上。在执行过程中，会使用Class Loader子系统
     - 当字节码静态引用一个类时
     - 当字节码创建一个类对象时(例如: Person person = new Person("John"))
 
-    有3种类型的类加载器（与继承属性连接），它们遵循4个主要原则： 
+    有3种类型的类加载器： 
 
-    - 可见性原则
+    - Bootstrap Class Loader
 
-        该原则指出子类加载器可以看到父类加载器加载的类，但是父类加载器找不到子类加载器加载的类。
+        加载来自rt.jar的标准JDK类，例如引导路径中存在的核心Java API类-$ JAVA_HOME/jre/lib目录（例如java.lang。*包类）。它以C / C ++之类的本地语言实现，并是Java中所有类加载器的父级。
 
-    - 唯一性原则
+    - Extension Class Loader
 
-        该原则指出，父类加载的类不应再由子类加载器加载，并确保不会发生重复的类加载。
+        将类加载请求委托给其父类Bootstrap，如果不成功，则从扩展路径中的扩展目录（例如，安全扩展功能）中加载-JAVA_HOME/jre/ext或java.ext.dirs系统指定的任何其他目录的类。该类加载器由Java中的sun.misc.Launcher$ExtClassLoader类实现。
 
-    - 委托层次结构原则
+    - System/Application Class Loader
 
-        为了满足上述2个原则，JVM遵循一个委托层次结构来为每个请求装入的类选择类加载器。首先从最低的子级别开始，Application Class Loader将接收到的类加载请求委托给Extension Class Loader，然后Extension Class Loader将该请求委托给Bootstrap Class Loader。如果在Bootstrap路径中找到了所请求的类，则将加载该类。否则，该请求将再次被转移回Extension Class Loader加载器中从该Loader的扩展路径或自定义指定的路径中查找类。如果它也失败，则请求将返回到Application Class Loader中从该Loader的System类路径中查找该类，并且如果Application Class Loader也未能加载所请求的类，则将获得运行时异常— java.lang.ClassNotFoundException。
+        从系统类路径加载应用程序特定的类，可以使用-cp或-classpath命令来在程序执行时动态设置。它在内部使用映射到java.class.path的环境变量。该类加载器由sun.misc.Launcher$AppClassLoader类用Java实现。
 
-    - 无卸载原则
+    除了上面讨论的3个主要的类加载器，程序员还可以直接在代码本身上创建用户定义的类加载器。这通过类加载器委托模型保证了应用程序的独立性。这种方法用于Tomcat之类的Web应用程序服务器中，以使Web应用程序和企业解决方案独立运行。
 
-        即使类加载器可以加载类，但是无法卸载已加载的类。替代卸载功能的是可以删除当前的类加载器，并创建一个新的类加载器。
+    每个类加载器都有自己的名称空间来保存已加载的类。当类加载器加载类时，它将基于存储在名称空间中的完全合格的类名称（FQCN：Fully Qualified Class Name）搜索该类，以检查该类是否已被加载。即使该类具有相同的FQCN但具有不同的名称空间，也将其视为不同的类。不同的名称空间意味着该类已由另一个类加载器加载。
 
-    ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/java_class_loaders.png)
+    它们遵循4个主要原则： 
 
-    #### 类加载器类型
+    - 可见性原则
 
-    - Bootstrap Class Loader
+        该原则指出子类加载器可以看到父类加载器加载的类，但是父类加载器找不到子类加载器加载的类。
 
-        加载来自rt.jar的标准JDK类，例如引导路径中存在的核心Java API类-$ JAVA_HOME/jre/lib目录（例如java.lang。*包类）。它以C / C ++之类的本地语言实现，并是Java中所有类加载器的父级。
+    - 唯一性原则
 
-    - Extension Class Loader
+        该原则指出，父类加载的类不应再由子类加载器加载，并确保不会发生重复的类加载。
 
-        将类加载请求委托给其父类Bootstrap，如果不成功，则从扩展路径中的扩展目录（例如，安全扩展功能）中加载-JAVA_HOME/jre/ext或java.ext.dirs系统指定的任何其他目录的类。该类加载器由Java中的sun.misc.Launcher$ExtClassLoader类实现。
+    - 委托层次结构原则
 
-    - System/Application Class Loader
+        为了满足上述2个原则，JVM遵循一个委托层次结构来为每个请求装入的类选择类加载器。首先从最低的子级别开始，Application Class Loader将接收到的类加载请求委托给Extension Class Loader，然后Extension Class Loader将该请求委托给Bootstrap Class Loader。如果在Bootstrap路径中找到了所请求的类，则将加载该类。否则，该请求将再次被转移回Extension Class Loader加载器中从该Loader的扩展路径或自定义指定的路径中查找类。如果它也失败，则请求将返回到Application Class Loader中从该Loader的System类路径中查找该类，并且如果Application Class Loader也未能加载所请求的类，则将获得运行时异常— java.lang.ClassNotFoundException。
 
-        从系统类路径加载应用程序特定的类，可以使用-cp或-classpath命令来在程序执行时动态设置。它在内部使用映射到java.class.path的环境变量。该类加载器由sun.misc.Launcher$AppClassLoader类用Java实现。
+    - 无法卸载原则
 
-    除了上面讨论的3个主要的类加载器，程序员还可以直接在代码本身上创建用户定义的类加载器。这通过类加载器委托模型保证了应用程序的独立性。这种方法用于Tomcat之类的Web应用程序服务器中，以使Web应用程序和企业解决方案独立运行。
+        即使类加载器可以加载类，但是无法卸载已加载的类。替代卸载功能的是可以删除当前的类加载器，并创建一个新的类加载器。
 
-    每个类加载器都有自己的名称空间来保存已加载的类。当类加载器加载类时，它将基于存储在名称空间中的完全合格的类名称（FQCN：Fully Qualified Class Name）搜索该类，以检查该类是否已被加载。即使该类具有相同的FQCN但具有不同的名称空间，也将其视为不同的类。不同的名称空间意味着该类已由另一个类加载器加载。
+    ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/java_class_loaders.png)
 
 - 链接
 
-    在遵循以下属性的同时，链接涉及验证和准备已加载的类或接口，其直接超类和超接口以及其元素类型。
+    在遵循以下属性的同时，链接涉及验证和准备已加载的类或接口，其直接父类和实现的接口以及其元素类型。
 
     - 在链接一个类或接口之前，必须将其完全加载。
     - 在初始化类或接口之前，必须对其进行完全验证和准备（在下一步中）。
@@ -148,9 +148,7 @@ Hotspot虚拟机的对象头包括两部分信息，第一部分用于存储对
 
 然后，对于每个已加载的.class文件，它都会按照java.lang包中的定义，恰好创建一个Class对象来表示堆内存中的文件。稍后，在我们的代码中，可以使用此Class对象读取类级别的信息（类名称，父名称，方法，变量信息，静态变量等）。
 
-
-
-TODO ... 具体可参考
+[具体可参考Java内存模型](https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/Java%E5%86%85%E5%AD%98%E6%A8%A1%E5%9E%8B.md)
 
 
 
@@ -197,9 +195,7 @@ TODO ... 具体可参考
 
 ### Garbage Collector (GC)
 
-只要引用了一个对象，JVM就会认为它是活动的。一旦不再引用对象，因此应用程序代码无法访问该对象，则垃圾收集器将其删除并回收未使用的内存。通常，垃圾回收是在后台进行的，但是我们可以通过调用System.gc（）方法来触发垃圾回收（同样，无法保证执行。因此，请调用Thread.sleep（1000）并等待GC完成）。
-
-
+只要引用了一个对象，JVM就会认为它是活动的。一旦不再引用对象，因此应用程序代码无法访问该对象，则垃圾收集器将其删除并回收未使用的内存。通常，垃圾回收是在后台进行的，但是我们可以通过调用System.gc()方法来触发垃圾回收（同样，无法保证执行。因此，请调用Thread.sleep（1000）并等待GC完成）。[具体内存回收部分请看JVM垃圾回收机制](https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/JVM%E5%9E%83%E5%9C%BE%E5%9B%9E%E6%94%B6%E6%9C%BA%E5%88%B6.md)
 
 
 
@@ -209,13 +205,27 @@ TODO ... 具体可参考
 
 主应用程序线程是作为调用公共静态void main（String []）的一部分而创建的主线程，而所有其他应用程序线程都是由该主线程创建的。应用程序线程执行诸如执行以main（）方法开头的指令，在Heap区域中创建对象（如果它在任何方法逻辑中找到新关键字）之类的任务等。
 
-The major system threads are as follows.
+主要的系统线程有： 
+
+- Compiler threads
+
+    在运行时，这些线程将字节码编译为本地代码。
+
+- GC threads
+
+    所有与GC相关的活动均由这些线程执行。
+
+- Periodic task thread
+
+    计划周期性操作执行的计时器事件（即中断）由该线程执行。
+
+- Signal dispatcher thread
+
+    该线程接收发送到JVM进程的信号，并通过调用适当的JVM方法在JVM内部对其进行处理。
+
+- VM thread
 
-- **Compiler threads**: At runtime, compilation of bytecode to native code is undertaken by these threads.
-- **GC threads**: All the GC related activities are carried out by these threads.
-- **Periodic task thread**: The timer events (i.e. interrupts) to schedule execution of periodic operations are performed by this thread.
-- **Signal dispatcher thread**: This thread receives signals sent to the JVM process and handle them inside the JVM by calling the appropriate JVM methods.
-- **VM thread**: As a pre-condition, some operations need the JVM to arrive at a safe  point where modifications to the Heap area does no longer happen.  Examples for such scenarios are “stop-the-world” garbage collections,  thread stack dumps, thread suspension and biased locking revocation.  These operations can be performed on a special thread called VM thread.
+    前提条件是，某些操作需要JVM到达安全点才能执行，在该点不再进行对Heap区域的修改。这种情况的示例是“世界停止”垃圾回收，线程堆栈转储，线程挂起和有偏向的锁吊销。这些操作可以在称为VM线程的特殊线程上执行。
 
 
 
diff --git "a/JavaKnowledge/Java\345\206\205\345\255\230\346\250\241\345\236\213.md" "b/JavaKnowledge/Java\345\206\205\345\255\230\346\250\241\345\236\213.md"
index a6791057..6aa45465 100644
--- "a/JavaKnowledge/Java\345\206\205\345\255\230\346\250\241\345\236\213.md"
+++ "b/JavaKnowledge/Java\345\206\205\345\255\230\346\250\241\345\236\213.md"
@@ -1,83 +1,105 @@
 Java内存模型
 ===
 
-# Java内存结构
-
-在说Java内存模型之前，我们先说一下Java的内存结构，也就是运行时的数据区域，Java虚拟机在执行Java程序的过程中，会把它管理的内存划分为五个不同的数据区域(Heap Memory、Stack Memory、Method Area、PC、Native Stack Memory)，这些区域都有各自的用途、创建时间、销毁时间:     
+Java虚拟机(Java Virtual Machine)在执行Java程序的过程中，会把它管理的内存划分为五个不同的数据区域(Heap Memory、Stack Memory、Method Area、PC、Native Stack Memory)，这些区域都有各自的用途、创建时间、销毁时间:     
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/jvm_memory_model.jpeg)
 
+## Program Counter Register
+
+程序计数器是一块较小的内存空间，严格来说是一个数据结构，用于保存当前正在执行的程序的内存地址，由于Java是支持多线程执行的，所以程序执行的轨迹不可能一直都是线性执行。当有多个线程交叉执行时，被中断的线程的程序当前执行到哪条内存地址必然要保存下来，以便用于被中断的线程恢复执行时再按照被中断时的指令地址继续执行下去。为了线程切换后能恢复到正确的执行位置，每个线程都需要有一个独立的程序计数器，各个线程之间计数器互不影响，独立存储，我们称这类内存区域为“线程私有”的内存,这在某种程度上有点类似于“ThreadLocal”，是线程安全的。可以看作是当前线程所执行的字节码的行号指示器。
+
+从上面的介绍中我们知道程序计数器主要有两个作用：
+
+- 字节码解释器通过改变程序计数器来依次读取指令，从而实现代码的流程控制，如：顺序执行、选择、循环、异常处理。
+- 在多线程的情况下，程序计数器用于记录当前线程执行的位置，从而当线程被切换回来的时候能够知道该线程上次运行到哪儿了。
+
+注意：程序计数器是唯一一个不会出现OutOfMemoryError的内存区域，它的生命周期随着线程的创建而创建，随着线程的结束而死亡。
+
+
 
 ## Heap Memory
+
+所有的对象实例和数组都存放到Heap内存中。Heap内存也称为共享内存。多线程可以共享这里面的数据。 
+
 - 堆内存在JVM启动的时候被加载(初始大小: -Xms)
+
 - 堆内存在程序运行时会增加或减少
-- 最小值: -Xmx
-- 从结构上来分，可以分为新生代和老年代。而新生代又可以分为Eden 空间、From Survivor 空间（s0）、To Survivor 空间（s1）。 所有新生成的对象首先都是放在新生代的。需要注意，Survivor的两个区是对称的，没先后关系，所以同一个区中可能同时存在从Eden复制过来的对象，和从前一个Survivor复制过来的对象，而复制到老年代的只有从第一个Survivor区过来的对象。而且，Survivor区总有一个是空的。在 JDK 1.8中移除整个永久代，取而代之的是一个叫元空间（Metaspace）的区域（永久代使用的是JVM的堆内存空间，而元空间使用的是物理内存，直接受到本机的物理内存限制）。
-所有的对象实例和数组都存放到Heap内存中。Heap内存也称为共享内存。多线程可以共享这里面的数据。 在并发编程中，多个线程之间采取什么机制进行通信（信息交换），什么机制进行数据的同步？
-
-在Java语言中，采用的是共享内存模型来实现多线程之间的信息交换和数据同步的。
-![](https://raw.githubusercontent.com/CharonChui/Pictures/master/jvm_heap_memory.png)
-## PC(Program Counter Register)
-程序计数器是一块较小的内存空间，可以看作是当前线程所执行的字节码的行号指示器。字节码解释器工作时通过改变这个计数器的值来选取下一条需要执行的字节码指令，分支、循环、跳转、异常处理、线程恢复等功能都需要依赖这个计数器来完。
-另外，为了线程切换后能恢复到正确的执行位置，每条线程都需要有一个独立的程序计数器，各线程之间计数器互不影响，独立存储，我们称这类内存区域为“线程私有”的内存。
-从上面的介绍中我们知道程序计数器主要有两个作用：
 
-字节码解释器通过改变程序计数器来依次读取指令，从而实现代码的流程控制，如：顺序执行、选择、循环、异常处理。
-在多线程的情况下，程序计数器用于记录当前线程执行的位置，从而当线程被切换回来的时候能够知道该线程上次运行到哪儿了。
+- 最小值: -Xmx
 
-注意：程序计数器是唯一一个不会出现OutOfMemoryError的内存区域，它的生命周期随着线程的创建而创建，随着线程的结束而死亡。
+- 从结构上来分，可以分为新生代和老年代。而新生代又可以分为Eden空间、From Survivor空间（s0）、To Survivor空间（s1）。 所有新生成的对象首先都是放在新生代的。需要注意，Survivor的两个区是对称的，没先后关系，所以同一个区中可能同时存在从Eden复制过来的对象，和从前一个Survivor复制过来的对象，而复制到老年代的只有从第一个Survivor区过来的对象。而且，Survivor区总有一个是空的。
 
-严格来说是一个数据结构，用于保存当前正在执行的程序的内存地址，由于Java是支持多线程执行的，所以程序执行的轨迹不可能一直都是线性执行。当有多个线程交叉执行时，被中断的线程的程序当前执行到哪条内存地址必然要保存下来，以便用于被中断的线程恢复执行时再按照被中断时的指令地址继续执行下去。为了线程切换后能恢复到正确的执行位置，每个线程都需要有一个独立的程序计数器，各个线程之间计数器互不影响，独立存储，我们称这类内存区域为“线程私有”的内存,这在某种程度上有点类似于“ThreadLocal”，是线程安全的。
+  ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/jvm_heap_memory.png)
 
-它的作用可以看做是当前线程所执行的字节码的行号指示器。
+在并发编程中，多个线程之间采取什么机制进行通信（信息交换），什么机制进行数据的同步？在Java语言中，采用的是共享内存模型来实现多线程之间的信息交换和数据同步的。
 
 ## Stack Memory
 
+栈总是与线程关联在一起的，每当创建一个线程，JVM就会为该线程创建对应的线程栈，线程stack中包含有关线程调用了哪些方法以达到当前执行点的信息。，也可以称之为调用栈，只要线程执行代码，调用栈就会发生改变。在这个栈中又会包含多个栈帧(Stack Frame)，栈是由一个个栈帧组成，这些栈帧是与每个方法关联起来的，每运行一个方法就创建一个栈帧，每个栈帧会含有一些局部变量表、操作栈和方法返回值等信息。
 
-![](https://raw.githubusercontent.com/CharonChui/Pictures/master/stack_heap.png)
+局部变量表主要存放了编译器可知的各种数据类型（boolean、byte、char、short、int、float、long、double）、对象引用（reference类型，它不同于对象本身，可能是一个指向对象起始地址的引用指针，也可能是指向一个代表对象的句柄或其他与此对象相关的位置）。
+
+每当一个方法执行完成时，该栈帧就会弹出栈帧的元素作为这个方法的返回值，并且清除这个栈帧，Java栈的栈顶的栈帧就是当前正在执行的活动栈，也就是当前正在执行的方法，PC寄存器也会指向该地址。只有这个活动的栈帧的本地变量可以被操作栈使用，当在这个栈帧中调用另外一个方法时，与之对应的一个新的栈帧被创建，这个新创建的栈帧被放到Java栈的栈顶，变为当前的活动栈。同样现在只有这个栈的本地变量才能被使用，当这个栈帧中所有指令都完成时，这个栈帧被移除Java栈，刚才的那个栈帧变为活动栈帧，前面栈帧的返回值变为这个栈帧的操作栈的一个操作数。
 
-Java栈总是与线程关联在一起的，每当创建一个线程，JVM就会为该线程创建对应的Java栈，在这个Java栈中又会包含多个栈帧(Stack Frame)，栈是由一个个栈帧组成，而每个栈帧中都拥有：局部变量表、操作数栈、动态链接、方法出口信息。局部变量表主要存放了编译器可知的各种数据类型（boolean、byte、char、short、int、float、long、double）、对象引用（reference类型，它不同于对象本身，可能是一个指向对象起始地址的引用指针，也可能是指向一个代表对象的句柄或其他与此对象相关的位置）。
 
-这些栈帧是与每个方法关联起来的，每运行一个方法就创建一个栈帧，每个栈帧会含有一些局部变量、操作栈和方法返回值等信息。每当一个方法执行完成时，该栈帧就会弹出栈帧的元素作为这个方法的返回值，并且清除这个栈帧，Java栈的栈顶的栈帧就是当前正在执行的活动栈，也就是当前正在执行的方法，PC寄存器也会指向该地址。只有这个活动的栈帧的本地变量可以被操作栈使用，当在这个栈帧中调用另外一个方法时，与之对应的一个新的栈帧被创建，这个新创建的栈帧被放到Java栈的栈顶，变为当前的活动栈。同样现在只有这个栈的本地变量才能被使用，当这个栈帧中所有指令都完成时，这个栈帧被移除Java栈，刚才的那个栈帧变为活动栈帧，前面栈帧的返回值变为这个栈帧的操作栈的一个操作数。
 
-JVM内部使用的Java内存模型在线程堆栈和堆之间分配内存。    
-Java虚拟机中的每个线程都有它自己的线程stack。线程stack中包含有关线程调用了哪些方法以达到当前执行点的信息。，也可以称之为调用栈，只要线程执行代码，调用栈就会发生改变。    
 线程stack中同样会包含该线程调用栈中所有方法执行所需要的本地变量，一个线程只能获取到它自己对应的线程stack。一个线程创建的本地变量对于其他任何线程都是不可见的。即使两个线程执行完全相同的代码，这两个线程仍然会在各自自己对应的线程stack中创建自己的本地变量。
 所有基础类型的局部变量(boolean,byte,short,char,int,long,float,double)都被保存在自己的线程stack中。一个线程可以将一个基础变量的副本传递给另一个线程，但是它不能共享原始局部变量本身。    
 堆内存包含在Java应用程序中创建的所有对象，而不管创建该对象的线程是什么。这包括基本类型的对象版本（例如Byte，Integer，Long等）。创建对象并将其分配给局部变量，或者将其创建为另一个对象的成员变量都没有关系，该对象仍存储在堆中。
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/java-memory-model-1.png)
 
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/stack_heap.png)
 
-局部变量可以是原始类型，在这种情况下，它完全保留在线程堆栈中。
-
-局部变量也可以是对对象的引用。在这种情况下，引用（局部变量）存储在线程堆栈中，但是对象本身（如果存储在堆中）。
+- 局部变量可以是原始类型，在这种情况下，它完全保留在线程堆栈中。
+- 局部变量也可以是对对象的引用。在这种情况下，引用（局部变量）存储在线程堆栈中，但是对象本身（如果存储在堆中）。
+- 一个对象可能包含方法，而这些方法可能包含局部变量。即使该方法所属的对象存储在堆内存中，这些局部变量也存储在线程堆内存中。
+- 对象的成员变量与对象本身一起存储在堆中。不管成员变量是原始类型时，以及它是对对象的引用时，都是如此。    
+- 静态类变量也与类定义一起存储在堆中。    
+- 引用对象的所有线程都可以访问堆上的对象。当线程可以访问对象时，它也可以访问该对象的成员变量。如果两个线程同时在同一个对象上调用一个方法，则它们都将有权访问该对象的成员变量，但是每个线程将拥有自己的局部变量副本。
 
-一个对象可能包含方法，而这些方法可能包含局部变量。即使该方法所属的对象存储在堆内存中，这些局部变量也存储在线程堆内存中。
-对象的成员变量与对象本身一起存储在堆中。不管成员变量是原始类型时，以及它是对对象的引用时，都是如此。    
-静态类变量也与类定义一起存储在堆中。    
-引用对象的所有线程都可以访问堆上的对象。当线程可以访问对象时，它也可以访问该对象的成员变量。如果两个线程同时在同一个对象上调用一个方法，则它们都将有权访问该对象的成员变量，但是每个线程将拥有自己的局部变量副本。
 
-Java 虚拟机栈会出现两种异常：StackOverFlowError 和 OutOfMemoryError。
 
-StackOverFlowError： 若Java虚拟机栈的内存大小不允许动态扩展，那么当线程请求栈的深度超过当前Java虚拟机栈的最大深度的时候，就抛出StackOverFlowError异常。
-OutOfMemoryError： 若 Java 虚拟机栈的内存大小允许动态扩展，且当线程请求栈时内存用完了，无法再动态扩展了，此时抛出OutOfMemoryError异常。
+Java 虚拟机栈会出现两种异常：StackOverFlowError 和 OutOfMemoryError： 
 
+- StackOverFlowError： 若Java虚拟机栈的内存大小不允许动态扩展，那么当线程请求栈的深度超过当前Java虚拟机栈的最大深度的时候，就抛出StackOverFlowError异常。
+- OutOfMemoryError： 若 Java 虚拟机栈的内存大小允许动态扩展，且当线程请求栈时内存用完了，无法再动态扩展了，此时抛出OutOfMemoryError异常。
 
 ## Method Area
 
-方法区存放了要加载的类的信息（名称、修饰符等）、类中的静态变量、类中定义为final类型的常量、类中的属性(Field)信息(属性信息包括属性名、属性类型、属性修饰符(public, private, protected,static,final volatile,transient的某个子集))、类中的方法信息(方法的相关信息包括：方法名， 方法的返回类型(或 void)， 方法参数的数量和类型(有序的)，方法的修饰符(public, private, protected, static, final, synchronized, native, abstract的一个子集))，以及即时编译器编译后的代码(每个方法：字节码，操作数堆栈大小，局部变量大小，局部变量表，异常表；异常表中的每个异常处理程序：起点，终点，处理程序代码的PC偏移，捕获到的异常类的常量池索引)，当在程序中通过Class对象的getName.isInterface等方法来获取信息时，这些数据都来源于方法区。方法区是被Java线程锁共享的，不像Java堆中其他部分一样会频繁被GC回收，它存储的信息相对比较稳定，在一定条件下会被GC，当方法区要使用的内存超过其允许的大小时，会抛出OutOfMemory的错误信息。方法区也是堆中的一部分，就是我们通常所说的Java堆中的永久区 Permanet Generation，大小可以通过参数来设置,可以通过-XX:PermSize指定初始值，-XX:MaxPermSize指定最大值。
+方法区也称”永久代“，它用于存储虚拟机加载的类的信息（名称、修饰符等）、类中的静态变量、类中定义为final类型的常量、类中的属性(Field)信息(属性信息包括属性名、属性类型、属性修饰符(public, private, protected,static,final volatile,transient的某个子集))、类中的方法信息(方法的相关信息包括：方法名， 方法的返回类型(或 void)， 方法参数的数量和类型(有序的)，方法的修饰符(public, private, protected, static, final, synchronized, native, abstract的一个子集))，以及即时编译器编译后的代码(每个方法：字节码，操作数堆栈大小，局部变量大小，局部变量表，异常表；异常表中的每个异常处理程序：起点，终点，处理程序代码的PC偏移，捕获到的异常类的常量池索引)，当在程序中通过Class对象的getName.isInterface等方法来获取信息时，这些数据都来源于方法区。
+
+方法区默认最小值为16MB，最大值为64MB（64位JVM由于指针膨胀，默认是85M），可以通过-XX:PermSize 和 -XX:MaxPermSize 参数限制方法区的大小。它是一片连续的堆空间，永久代的垃圾收集是和老年代(old generation)捆绑在一起的，因此无论谁满了，都会触发永久代和老年代的垃圾收集
+
+方法区是被Java线程锁共享的，不像Java堆中其他部分一样会频繁被GC回收，它存储的信息相对比较稳定，在一定条件下会被GC，当方法区要使用的内存超过其允许的大小时，会抛出OutOfMemory的错误信息。方法区也是堆中的一部分，就是我们通常所说的Java堆中的永久区 Permanet Generation，大小可以通过参数来设置,可以通过-XX:PermSize指定初始值，-XX:MaxPermSize指定最大值。
 
 方法区与堆有很多共性：线程共享、内存不连续、可扩展、可垃圾回收，同样当无法再扩展时会抛出OutOfMemoryError异常。
 
-正因为如此相像，Java虚拟机规范把方法区描述为堆的一个逻辑部分，但目前实际上是与Java堆分开的（Non-Heap）。
+正因为如此相像，Java虚拟机规范把方法区描述为堆的一个逻辑部分，但目前实际上是与Java堆分开的（Non-Heap）。Non-Heap主要包括的内容如下: 
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/jvm_no_heap.webp)
+
 方法区的内存回收目标主要是针对常量池的回收和对类型的卸载，一般来说这个区域的回收“成绩”比较难以令人满意，尤其是类型的卸载，条件相当苛刻，但是回收确实是有必要的。
 
+### Constant Pool
+
+常量池也称为运行时常量池(Runtime Constant Pool),用于存放编译期生成的各种字面量和符号引用。
+
+常量池本身是方法区中的一个数据结构。既然运行时常量池时方法区的一部分，自然受到方法区内存的限制，当常量池无法再申请到内存时会抛出 OutOfMemoryError 异常。
+
+常量池中存储了如字符串、final变量值、类名和方法名常量。常量池在编译期间就被确定，并保存在已编译的.class文件中。一般分为两类：字面量和应用量。字面量就是字符串、final变量等。类名和方法名属于引用量。引用量最常见的是在调用方法的时候，根据方法名找到方法的引用，并以此定为到函数体进行函数代码的执行。引用量包含：类和接口的权限定名、字段的名称和描述符，方法的名称和描述符。
+
+
+
+JVM会加载、链接、初始化class文件。一个class文件会把其所有所有符号引用都保留在一个位置，即常量池中。 
+
+每个class文件都会有一个对应constant pool。但是class文件中的常量池显示让不够的，因为需要再JVM上执行。这种情况下，需要runtime constant pool来服务JVM的运行。
+
+Java虚拟机加载的每个类或接口都有其常量池的内部版本，称为运行时常量池(runtime constant pool)。运行时常量池是特定于实现的数据结构，它与类文件中的常量池是一一对应映射的。因此，在最初加载类型之后，该类型的所有符号引用都驻留在该类型的运行时常量池中。包括字符串常量，类和接口名称，字段名称以及类中引用的其他常量。
 
-很多人愿意把方法区称为“永久代”（Permanent Generation），本质上两者并不等价，仅仅是因为HotSpot虚拟机的设计团队选择把GC 分代收集扩展至方法区，或者说使用永久代来实现方法区而已。对于其他虚拟机（如BEA JRockit、IBM J9 等）来说是不存在永久代的概念的。在Java8中永生代彻底消失了。
+#### String Constant Pool
+
+在Constant Pool中还有一个单独存放字符串的String Constant Pool。
 
-#### Constant Pool
-常量池也称为运行时常量池(Runtime Constant Pool),用于存放编译期生成的各种字面量和符号引用。常量池本身是方法区中的一个数据结构。常量池中存储了如字符串、final变量值、类名和方法名常量。常量池在编译期间就被确定，并保存在已编译的.class文件中。一般分为两类：字面量和应用量。字面量就是字符串、final变量等。类名和方法名属于引用量。引用量最常见的是在调用方法的时候，根据方法名找到方法的引用，并以此定为到函数体进行函数代码的执行。引用量包含：类和接口的权限定名、字段的名称和描述符，方法的名称和描述符。
-既然运行时常量池时方法区的一部分，自然受到方法区内存的限制，当常量池无法再申请到内存时会抛出 OutOfMemoryError 异常。
-JDK1.7及之后版本的 JVM 已经将运行时常量池从方法区中移了出来，在 Java 堆（Heap）中开辟了一块区域存放运行时常量池。
 ```java
 String str1 = "abcd";
 String str2 = new String("abcd");
@@ -111,44 +133,65 @@ Double i4 = 1.2;
 System.out.println(i3 == i4);// 输出false
 ```
 
+
+
+### Method Area & Constant Pool改动
+
+很多人愿意把方法区称为“永久代”（Permanent Generation），本质上两者并不等价，仅仅是因为HotSpot虚拟机的设计团队选择把GC 分代收集扩展至方法区，或者说使用永久代来实现方法区而已。对于其他虚拟机（如BEA JRockit、IBM J9 等）来说是不存在永久代的概念的。
+
+
+
+在JDK1.7中，将字符串常量池和静态变量从方法区域中移到堆中，其余的运行时常量池仍在方法区域中，即hotspot中的永久生成。 所有的被intern的String被存储在PermGen区.PermGen区使用-XX:MaxPermSize=N来设置最大大小，但是由于应用程序string.intern通常是不可预测和不可控的，因此不好设置这个大小。设置不好的话，常常会引起java.lang.OutOfMemoryError: PermGen space。
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/java7_method_constant_pool.jpg)
+
+在 JDK 1.8中移除整个永久代，取而代之的是一个叫元空间（Metaspace）的区域（永久代使用的是JVM的堆内存空间，而元空间使用的是物理内存，直接受到本机的物理内存限制）。string constant pool仍然还是在Heap内存中。runtime constant pool也仍然在方法区。但是方法区的实现已经改成使用Metaspace。 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/java8_memory_method.jpg)
+
+为什么要移除永久代，改为元空间嗯？ 
+
+> Metaspace与PermGen之间最大的区别在于：Metaspace并不在虚拟机中，而是使用本机内存。如果没有使用-XX:MaxMetaspaceSize来设置类的元数据的大小，其最大可利用空间是整个系统内存的可用空间。JVM也可以增加本地内存空间来满足类元数据信息的存储。
+> 但是如果没有设置最大值，则可能存在bug导致Metaspace的空间在不停的扩展，会导致机器的内存不足；进而可能出现swap内存被耗尽；最终导致进程直接被系统直接kill掉。
+>
+> 如果类元数据的空间占用达到MaxMetaspaceSize设置的值，将会触发对象和类加载器的垃圾回收。java.lang.OutOfMemoryError: Metaspace space
+
+从用户角度来看，主要的区别是，默认情况下，Metaspace自动增加其大小（达到基础操作系统所提供的大小），而PermGen始终具有固定的最大大小。您可以使用JVM参数为Metaspace设置固定的最大值，但不能使PermGen自动增加。
+
+在很大程度上，这只是名称的更改。早在引入PermGen时，就没有Java EE或动态类的加载（取消加载），因此，一旦加载了一个类，该类便一直停留在内存中，直到JVM关闭为止，从而实现了永久生成。如今，可以在JVM的生命周期内加载和卸载类，因此对于保留元数据的区域，Metaspace更有意义。
+
+
+
+
+
 ## Native Method Stack
+
 本地方法栈和Java栈所发挥的作用非常相似，区别不过是Java栈为JVM执行Java方法服务，而本地方法栈为JVM执行Native方法服务。如Java使用c或c++编写的接口服务时，代码在此区运行，本地方法栈也会抛出StackOverflowError和OutOfMemoryError异常。
 
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/RDA.png)
 先看一张图，这张图能很清晰的说明JVM内存结构的布局和相应的控制参数：
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/jvm_memory_archi_param.jpeg)
 
+## 主内存和工作内存：
 
-主内存和工作内存：
-
-　　Java内存模型的主要目标是定义程序中各个变量的访问规则，即在JVM中将变量存储到内存和从内存中取出变量这样的底层细节。此处的变量与Java编程里面的变量有所不同步，它包含了实例字段、静态字段和构成数组对象的元素，但不包含局部变量和方法参数，因为后者是线程私有的，不会共享，当然不存在数据竞争问题（如果局部变量是一个reference引用类型，它引用的对象在Java堆中可被各个线程共享，但是reference引用本身在Java栈的局部变量表中，是线程私有的）。为了获得较高的执行效能，Java内存模型并没有限制执行引起使用处理器的特定寄存器或者缓存来和主内存进行交互，也没有限制即时编译器进行调整代码执行顺序这类优化措施。
+Java内存模型的主要目标是定义程序中各个变量的访问规则，即在JVM中将变量存储到内存和从内存中取出变量这样的底层细节。此处的变量与Java编程里面的变量有所不同步，它包含了实例字段、静态字段和构成数组对象的元素，但不包含局部变量和方法参数，因为后者是线程私有的，不会共享，当然不存在数据竞争问题（如果局部变量是一个reference引用类型，它引用的对象在Java堆中可被各个线程共享，但是reference引用本身在Java栈的局部变量表中，是线程私有的）。为了获得较高的执行效能，Java内存模型并没有限制执行引起使用处理器的特定寄存器或者缓存来和主内存进行交互，也没有限制即时编译器进行调整代码执行顺序这类优化措施。
 
-　　JMM规定了所有的变量都存储在主内存（Main Memory）中。每个线程还有自己的工作内存（Working Memory）,线程的工作内存中保存了该线程使用到的变量的主内存的副本拷贝，线程对变量的所有操作（读取、赋值等）都必须在工作内存中进行，而不能直接读写主内存中的变量（volatile变量仍然有工作内存的拷贝，但是由于它特殊的操作顺序性规定，所以看起来如同直接在主内存中读写访问一般）。不同的线程之间也无法直接访问对方工作内存中的变量，线程之间值的传递都需要通过主内存来完成。
+JMM(Java Memory Model)规定了所有的变量都存储在主内存（Main Memory）中。每个线程还有自己的工作内存（Working Memory）,线程的工作内存中保存了该线程使用到的变量的主内存的副本拷贝，线程对变量的所有操作（读取、赋值等）都必须在工作内存中进行，而不能直接读写主内存中的变量（volatile变量仍然有工作内存的拷贝，但是由于它特殊的操作顺序性规定，所以看起来如同直接在主内存中读写访问一般）。不同的线程之间也无法直接访问对方工作内存中的变量，线程之间值的传递都需要通过主内存来完成。
 
-
-# Java内存模型
 由上述对JVM内存结构的描述中，我们知道了堆和方法区是线程共享的。而局部变量，方法定义参数和异常处理器参数就不会在线程之间共享，它们不会有内存可见性问题，也不受内存模型的影响。
 
+Java线程之间的通信由Java内存模型（本文简称为JMM）控制，JMM决定一个线程对共享变量的写入何时对另一个线程可见。从抽象的角度来看，JMM定义了线程和主内存之间的抽象关系：线程之间的共享变量存储在主内存（main memory）中，每个线程都有一个私有的本地内存（local memory），本地内存中存储了该线程以读/写共享变量的副本。本地内存是JMM的一个抽象概念，并不真实存在。它涵盖了缓存，写缓冲区，寄存器以及其他的硬件和编译器优化。
 
+假设线程A与线程B之间如要通信的话，必须要经历下面2个步骤: 
 
-Java线程之间的通信由Java内存模型（本文简称为JMM）控制，JMM决定一个线程对共享变量的写入何时对另一个线程可见。从抽象的角度来看，JMM定义了线程和主内存之间的抽象关系：线程之间的共享变量存储在主内存（main memory）中，每个线程都有一个私有的本地内存（local memory），本地内存中存储了该线程以读/写共享变量的副本。本地内存是JMM的一个抽象概念，并不真实存在。它涵盖了缓存，写缓冲区，寄存器以及其他的硬件和编译器优化。Java内存模型的抽象示意图如下：
-
-线程A与线程B之间如要通信的话，必须要经历下面2个步骤：
-
-首先，线程A把本地内存A中更新过的共享变量刷新到主内存中去。
-然后，线程B到主内存中去读取线程A之前已更新过的共享变量。
+1. 线程A把本地内存A中更新过的共享变量刷新到主内存中去。
+2. 线程B到主内存中去读取线程A之前已更新过的共享变量。
 
 ## 重排
 
-重排序
-在执行程序时为了提高性能，编译器和处理器常常会对指令做重排序。
-
 
+在执行程序时为了提高性能，编译器和处理器常常会对指令做重排序。
 
 这里说的重排序可以发生在好几个地方：编译器、运行时、JIT等，比如编译器会觉得把一个变量的写操作放在最后会更有效率，编译后，这个指令就在最后了（前提是只要不改变程序的语义，编译器、执行器就可以这样自由的随意优化），一旦编译器对某个变量的写操作进行优化（放到最后），那么在执行之前，另一个线程将不会看到这个执行结果。
 
-
-
 当然了，写入动作可能被移到后面，那也有可能被挪到了前面，这样的“优化”有什么影响呢？这种情况下，其它线程可能会在程序实现“发生”之前，看到这个写入动作（这里怎么理解，指令已经执行了，但是在代码层面还没执行到）。通过内存屏障的功能，我们可以禁止一些不必要、或者会带来负面影响的重排序优化，在内存模型的范围内，实现更高的性能，同时保证程序的正确性。
 
 下面我们来看一个重排序的例子：
@@ -171,19 +214,21 @@ Class Reordering {
 
 当然不行！ 因为在writer方法中，可能发生了重排序，y的写入动作可能发在x写入之前，这种情况下，线程B就有可能看到x的值还是0。
 
-
-
 在Java内存模型中，描述了在多线程代码中，哪些行为是正确的、合法的，以及多线程之间如何进行通信，代码中变量的读写行为如何反应到内存、CPU缓存的底层细节。
 
 
 
-在Java中包含了几个关键字：volatile、final和synchronized，帮助程序员把代码中的并发需求描述给编译器。JMM中定义了它们的行为，确保正确同步的Java代码在所有的处理器架构上都能正确执行。
+---
+
 参考
 ---
 - [Java (JVM) Memory Types](https://javapapers.com/core-java/java-jvm-memory-types/)
+- [Java 8: From PermGen to Metaspace](https://dzone.com/articles/java-8-permgen-metaspace)
+- [Interview question Series Part 5: JDK runtime  constant pool, string constant pool, static constant pool, are you  stupid and confused?](https://javamana.com/2020/11/20201113132526144q.html)
+- [Where Has the Java PermGen Gone?](https://www.infoq.com/articles/Java-PERMGEN-Removed/)
 
 
-		
+​		
 ---
 - 邮箱 ：charon.chui@gmail.com  
 - Good Luck! 
diff --git a/README.md b/README.md
index 78f801b2..b8e22d65 100644
--- a/README.md
+++ b/README.md
@@ -236,6 +236,8 @@ Android学习笔记
     - [volatile和Synchronized区别][109]
     - [Http与Https的区别][195]
     - [Top-K问题][196]
+    - [Java内存模型][285]
+    - [JVM架构][286]
 - [基础部分][54] 
     - [安全退出应用程序][110]
     - [病毒][111]
@@ -603,6 +605,8 @@ Android学习笔记
 [283]: https://github.com/CharonChui/AndroidNote/blob/master/OperatingSystem/AndroidKernal/9.PackageManagerService%E7%AE%80%E4%BB%8B.md "9.PackageManagerService简介"
 
 [ 284 ]: https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/LeakCanary%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90.md. "LeakCanary源码分析"
+[285]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/Java%E5%86%85%E5%AD%98%E6%A8%A1%E5%9E%8B.md "Java内存模型"
+[286]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/JVM%E6%9E%B6%E6%9E%84.md "JVM架构"
 
 
 Developed By

From 674c62dbf984223caf02a4a5c0da57f1819fdad6 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Sun, 25 Apr 2021 14:25:02 +0800
Subject: [PATCH 062/213] update Android Runtime

---
 "AdavancedPart/ART\344\270\216Dalvik.md"      |  48 ------
 .../AndroidRuntime_ART\344\270\216Dalvik.md"  | 161 ++++++++++++++++++
 2 files changed, 161 insertions(+), 48 deletions(-)
 delete mode 100644 "AdavancedPart/ART\344\270\216Dalvik.md"
 create mode 100644 "AdavancedPart/AndroidRuntime_ART\344\270\216Dalvik.md"

diff --git "a/AdavancedPart/ART\344\270\216Dalvik.md" "b/AdavancedPart/ART\344\270\216Dalvik.md"
deleted file mode 100644
index 84fa0fea..00000000
--- "a/AdavancedPart/ART\344\270\216Dalvik.md"
+++ /dev/null
@@ -1,48 +0,0 @@
-ART与Dalvik
-===
-
-
-
-Dalvik
----
-
-`Dalvik`是`Google`公司自己设计用于`Android`平台的`Java`虚拟机。它可以支持已转换为`.dex`（即`Dalvik Executable`）格式的`Java`应用程序的运行，
-`.dex`格式是专为`Dalvik`设计的一种压缩格式，适合内存和处理器速度有限的系统。`Dalvik`经过优化，允许在有限的内存中同时运行多个虚拟机的实例，
-并且每一个`Dalvik`应用作为一个独立的`Linux`进程执行。独立的进程可以防止在虚拟机崩溃的时候所有程序都被关闭。
-很长时间以来，`Dalvik`虚拟机一直被用户指责为拖慢安卓系统运行速度不如`IOS`的根源。
-`2014`年`6`月`25`日，`Android L`正式亮相于召开的谷歌`I/O`大会，`Android L`改动幅度较大，谷歌将直接删除`Dalvik`，代替它的是传闻已久的`ART`。
-
-
-ART
---- 
-
-`Android 4.4`提供了一种与`Dalvik`截然不同的运行环境`ART`支持,`ART`源于`google`收购的`Flexycore`的公司。
-`ART`模式与`Dalvik`模式最大的不同在于，启用`ART`模式后，系统在安装应用的时候会进行一次预编译，将字节码转换为机器语言存储在本地，
-这样在运行程序时就不会每次都进行一次编译了，执行效率也大大提升。
-
-`ART`使用`AOT(Ahead Of Time)`(静态编译)而`Dalvik`使用`JIT(Just In Time)`(动态编译)
-`JIT`方式会在程序执行时将`Dex bytecode`(`java`字节码)转换为处理器可以理解的本地代码，这种方式会将编译时间计入程序的执行时间，程序执行会显得慢一些。`AOT`方式会在程序执行之前(一般是安装时)就编译好本地代码，因此程序执行时少了编译的过程会显得快一些，但占用更多存储空间，安装时也会更慢。但没针对ART优化的程序反而会运行得更慢，随着`Android L`的普及这个问题迟早会解决。`ART`拥有改进的`GC`(垃圾回收)机制:`GC`时更少的暂停时间、`GC`时并行处理、某些时候`Collector`所需时间更短、减少内存不足时触发GC的次数、减少后台内存占用。   
-在移除解释代码这一过程后，应用程序执行将更有效率，启动更快。总体的理念就是空间换时间。
-
-
-`AOT`的编译器分两种模式：            
-- 在开发机上编译预装应用；
-- 在设备上编译新安装的应用,在应用安装时将`dex`字节码翻译成本地机器码。
-
-ART优点:     
-- 系统性能的显著提升。
-- 应用启动更快、运行更快、体验更流畅、触感反馈更及时。
-- 更长的电池续航能力。
-- 支持更低的硬件。
-
-ART缺点:       
-- 更大的存储空间占用，可能会增加10%-20%。
-- 更长的应用安装时间。
-
-
-
-		
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
diff --git "a/AdavancedPart/AndroidRuntime_ART\344\270\216Dalvik.md" "b/AdavancedPart/AndroidRuntime_ART\344\270\216Dalvik.md"
new file mode 100644
index 00000000..179c9bb5
--- /dev/null
+++ "b/AdavancedPart/AndroidRuntime_ART\344\270\216Dalvik.md"
@@ -0,0 +1,161 @@
+AndroidRuntime_ART与Dalvik
+===
+在说Android Runtime之前，我们需要了解什么是运行时环境，还需要了解一些基本知识，即JVM和Dalvik VM的功能。 
+
+## Runtime
+
+用最简单的术语来说，它是操作系统使用的系统，它负责将您用Java之类的高级语言编写的代码转换为CPU/处理器能理解机器代码。
+
+运行时包含在程序运行时执行的软件指令，即使它们实际上并不是该软件代码的一部分也是如此。
+CPU或更笼统的术语我们的计算机仅理解机器语言（二进制代码），因此要使其在CPU上运行，必须将代码转换为机器代码，这由翻译器完成。
+因此，以下是按顺序生成翻译器的过程: 
+- Assemblers
+    它可以直接将汇编代码转换为机器代码，因此速度非常快。
+- Compilers
+    它将代码转换为汇编代码，然后使用汇编程序将代码转换为二进制。使用此编译速度很慢，但是执行速度很快。但是编译器的最大问题是所生成的机器代码取决于平台。换句话说，在一台计算机上运行的代码可能不会在另一台计算机上运行。
+- Interpreters
+    它在执行代码时翻译代码。由于翻译是在运行时进行的，因此执行速度很慢。
+### JVM
+为了维持代码的平台独立性，JAVA开发了JVM，即Java虚拟机。它针对每个平台开发了JVM，这意味着JVM依赖于该平台。Java编译器将.java文件转换为.class文件，这称为字节码。该字节码被提供给JVM，该JVM将其转换为机器码。
+
+### Android Runtime
+
+当我们构建应用程序并生成APK时，该APK的一部分是.dex文件。这些文件包含我们应用程序的源代码，包括我们在为软件解释器设计的低级代码（字节码）中使用的所有库。
+
+当用户运行我们的应用程序时，写入的.dex文件中的字节码将由Android Runtime转换为机器码—一组指令，机器可以直接理解并由CPU处理。
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/dex_local_code.png)
+
+Android Runtime同样也回管理内存及垃圾回收。
+
+
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/jvm_dvm.png)
+
+
+
+可以使用各种策略将字节码编译为机器代码，所有这些策略都有其取舍。为了了解Android Runtime的工作原理，需要首先了解Dalvik。
+
+
+
+## Android Runtime的发展
+
+### Dalvik（<= Android K）
+
+`Dalvik`是`Google`公司自己设计用于`Android`平台的`Java`虚拟机。它可以支持已转换为`.dex`（即`Dalvik Executable`）格式的`Java`应用程序的运行，
+`.dex`格式是专为`Dalvik`设计的一种压缩格式，适合内存和处理器速度有限的系统。`Dalvik`经过优化，允许在有限的内存中同时运行多个虚拟机的实例，并且每一个`Dalvik`应用作为一个独立的`Linux`进程执行。独立的进程可以防止在虚拟机崩溃的时候所有程序都被关闭。
+很长时间以来，`Dalvik`虚拟机一直被用户指责为拖慢安卓系统运行速度不如`IOS`的根源。
+`2014`年`6`月`25`日，`Android L`正式亮相于召开的谷歌`I/O`大会，`Android L`改动幅度较大，谷歌将直接删除`Dalvik`，代替它的是传闻已久的`ART`。
+
+
+
+早期，Android智能手机并不像现在那么强大。一次大多数手机的RAM很少，有些甚至只有200MB。
+难怪第一个被称为Dalvik的Android Runtime的实现正是为了优化此参数：RAM的使用。
+
+因此，它没有在运行它之前将整个应用程序编译为机器代码，而是使用了称为Just In Time编译（简称JIT）的策略。
+
+在这种策略下，编译器可以充当解释器。它在应用程序执行期间（在运行时）编译一小段代码。
+
+而且由于Dalvik仅编译所需的代码并在运行时执行它，因此可以节省大量RAM。
+
+使用Dalvik JIT编译器，每次运行该应用程序时，它会将Dalvik字节码的一部分动态转换为机器代码。随着执行的进行，更多的字节码将被编译和缓存。由于JIT仅编译部分代码，因此它具有较小的内存占用空间，并且在设备上使用的物理空间更少。
+
+但是此策略有一个严重的缺点-因为所有这些都在运行时发生，因此显然会对运行时性能产生负面影响。
+
+最终，引入了一些优化以使Dalvik更具性能。一些经常使用的已编译代码段已被缓存，不再重新编译。但这是非常有限的，因为在最初的日子里内存非常稀缺。
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/dalvik_jit.png)
+
+几年来运行良好，但与此同时，手机的性能越来越高，RAM也越来越多。而且由于应用程序也越来越大，因此JIT性能影响变得越来越成问题。
+
+这就是为什么在Android L中引入了新的Android Runtime：ART。
+
+
+
+### ART(Android L)
+
+`Android 4.4`提供了一种与`Dalvik`截然不同的运行环境`ART`支持,`ART`源于`google`收购的`Flexycore`的公司。
+`ART`模式与`Dalvik`模式最大的不同在于，启用`ART`模式后，系统在安装应用的时候会进行一次预编译，将字节码转换为机器语言存储在本地，这样在运行程序时就不会每次都进行一次编译了，执行效率也大大提升。
+
+`ART`使用`AOT(Ahead Of Time)`(静态编译)而`Dalvik`使用`JIT(Just In Time)`(动态编译)
+`JIT`方式会在程序执行时将`Dex bytecode`(`java`字节码)转换为处理器可以理解的本地代码，这种方式会将编译时间计入程序的执行时间，程序执行会显得慢一些。`AOT`方式会在程序执行之前(一般是安装时)就编译好本地代码，因此程序执行时少了编译的过程会显得快一些，但占用更多存储空间，安装时也会更慢。但没针对ART优化的程序反而会运行得更慢，随着`Android L`的普及这个问题迟早会解决。`ART`拥有改进的`GC`(垃圾回收)机制:`GC`时更少的暂停时间、`GC`时并行处理、某些时候`Collector`所需时间更短、减少内存不足时触发GC的次数、减少后台内存占用。   
+在移除解释代码这一过程后，应用程序执行将更有效率，启动更快。总体的理念就是空间换时间。
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/dvm_art.png)
+
+`AOT`的编译器分两种模式：            
+
+- 在开发机上编译预装应用；
+- 在设备上编译新安装的应用,在应用安装时将`dex`字节码翻译成本地机器码。
+
+
+
+这种方法极大地提高了运行时性能，因为运行本机机器代码甚至比及时编译快20倍。
+
+ART优点:     
+
+- 系统性能的显著提升。
+- 应用启动更快、运行更快、体验更流畅、触感反馈更及时。
+- 更长的电池续航能力。
+- 支持更低的硬件。
+
+ART缺点:       
+
+- 更大的存储空间占用，可能会增加10%-20%。
+- 更长的应用安装时间，因为下载APK后，整个应用程序都需要转换为机器代码，而且由于所有应用程序都需要重新优化，因此执行系统更新还需要更长的时间。
+- Android L中的ART使用的内存比Dalvik多得多。
+
+
+
+对于应用程序中经常运行的部分来说，对其进行预编译显然是有回报的，但现实是，用户很少打开应用程序的大多数部分，而对整个应用程序进行预编译几乎也没有回报。
+
+这就是为什么在Android N中，Just In Time编译与称为配置文件引导的编译(profile-guided complication)一起被引入到Android Runtime的原因。
+
+### Profile-guided compilation(Android N)
+
+概要文件引导的编译是一种策略，可以在运行Android应用程序时不断提高其性能。默认情况下，应用程序使用即时编译策略进行编译，但是当ART检测到某些方法“很热”时，这意味着它们经常运行，ART可以预编译并缓存这些方法以获得最佳性能。
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/art_profile_guide.png)
+
+该策略可为应用程序的关键部分提供最佳性能，同时减少RAM使用量。由于事实证明，对于大多数应用程序来说，通常仅使用10％到20％的代码。
+
+更改ART之后，不再影响应用程序安装和系统更新的速度。应用的关键部分的预编译仅在设备空闲和充电时进行，以最大程度地减少对设备电池的影响。
+
+
+
+这种方法的唯一缺点是，为了获取配置文件数据并预编译常用的方法和类，用户必须实际使用应用程序。这意味着该应用程序的一些首次使用可能会有点慢，因为在这种情况下，将仅使用“及时”编译。
+
+这就是为什么要改善在Android P中的初始用户体验的原因，Google在云中引入了个人资料。
+
+### Profiles in the cloud(Android P)
+
+云中的配置文件背后的主要思想是，大多数人以非常相似的方式使用该应用程序。因此，为了在安装后立即提高性能，我们可以从已经使用过此应用程序的人那里收集配置文件数据。此汇总的配置文件数据用于为应用程序创建一个称为通用核心配置文件的文件。
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/profiles_in_cloud.png)
+
+因此，当新用户安装该应用程序时，该文件将与该应用程序一起下载。 ART使用它来预编译大多数用户经常运行的类和方法。这样，新用户在下载应用程序后即可获得更好的性能。
+
+这并不意味着不再使用旧策略。用户运行应用程序后，ART将收集用户特定的配置文件数据并重新编译设备闲置时该特定用户经常使用的代码。
+
+而最好的部分是，我们开发应用程序的开发人员无需执行任何操作即可启用此功能。这一切都发生在Android Runtime中。
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_runtime_change.png)
+
+
+
+- 最初Android使用Dalvik，它使用即时编译(JIT)来优化RAM(那时内存是非常紧缺的)的使用。
+- 为了提高Android L中的性能，引入了使用Ahead of time编译的ART。这样可以实现更好的运行时性能，但会导致更长的安装时间和更多的RAM使用率。
+- 因此，在Android N中，JIT被引入到ART中，并且配置文件引导的编译允许为经常运行的部分代码提供更好的性能。
+- 为了让用户在Android P中安装应用后立即获得最佳性能，Google在云端引入了配置文件，它通过添加随APK下载的通用核心配置文件来补充以前的优化，并允许ART预编译部分代码最常由以前的应用程序用户运行。
+
+
+
+
+
+[Android Runtime-How Dalvik and ART works?](https://www.youtube.com/watch?v=0J1bm585UCc&t=27s)
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file

From c60c19696cf5add03da24d731622e6ccb3800b59 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Sun, 25 Apr 2021 15:28:21 +0800
Subject: [PATCH 063/213] update README

---
 .../AndroidRuntime_ART\344\270\216Dalvik.md"       | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git "a/AdavancedPart/AndroidRuntime_ART\344\270\216Dalvik.md" "b/AdavancedPart/AndroidRuntime_ART\344\270\216Dalvik.md"
index 179c9bb5..7efca459 100644
--- "a/AdavancedPart/AndroidRuntime_ART\344\270\216Dalvik.md"
+++ "b/AdavancedPart/AndroidRuntime_ART\344\270\216Dalvik.md"
@@ -49,7 +49,7 @@ Android Runtime同样也回管理内存及垃圾回收。
 
 
 
-早期，Android智能手机并不像现在那么强大。一次大多数手机的RAM很少，有些甚至只有200MB。
+早期，Android智能手机并不像现在那么强大。大多数手机的RAM很少，有些甚至只有200MB。
 难怪第一个被称为Dalvik的Android Runtime的实现正是为了优化此参数：RAM的使用。
 
 因此，它没有在运行它之前将整个应用程序编译为机器代码，而是使用了称为Just In Time编译（简称JIT）的策略。
@@ -90,7 +90,7 @@ Android Runtime同样也回管理内存及垃圾回收。
 
 
 
-这种方法极大地提高了运行时性能，因为运行本机机器代码甚至比及时编译快20倍。
+这种方法极大地提高了运行时性能，因为运行本机机器代码甚至比即时编译快20倍。
 
 ART优点:     
 
@@ -101,7 +101,7 @@ ART优点:
 
 ART缺点:       
 
-- 更大的存储空间占用，可能会增加10%-20%。
+- 更大的存储空间占用，可能会增加10%-20%。字节码预先编译成机器码并存储到本地，机器码需要的存储空间更大。
 - 更长的应用安装时间，因为下载APK后，整个应用程序都需要转换为机器代码，而且由于所有应用程序都需要重新优化，因此执行系统更新还需要更长的时间。
 - Android L中的ART使用的内存比Dalvik多得多。
 
@@ -109,11 +109,11 @@ ART缺点:
 
 对于应用程序中经常运行的部分来说，对其进行预编译显然是有回报的，但现实是，用户很少打开应用程序的大多数部分，而对整个应用程序进行预编译几乎也没有回报。
 
-这就是为什么在Android N中，Just In Time编译与称为配置文件引导的编译(profile-guided complication)一起被引入到Android Runtime的原因。
+这就是为什么在Android N中，Just In Time编译与称为配置文件引导编译(profile-guided complication)一起被引入到Android Runtime的原因。
 
 ### Profile-guided compilation(Android N)
 
-概要文件引导的编译是一种策略，可以在运行Android应用程序时不断提高其性能。默认情况下，应用程序使用即时编译策略进行编译，但是当ART检测到某些方法“很热”时，这意味着它们经常运行，ART可以预编译并缓存这些方法以获得最佳性能。
+配置文件引导编译是一种策略，可以在运行Android应用程序时不断提高其性能。默认情况下，应用程序使用即时编译策略进行编译，但是当ART检测到某些热点功能时，这意味着它们经常运行，ART可以预编译并缓存这些方法以获得最佳性能。
 
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/art_profile_guide.png)
 
@@ -123,7 +123,7 @@ ART缺点:
 
 
 
-这种方法的唯一缺点是，为了获取配置文件数据并预编译常用的方法和类，用户必须实际使用应用程序。这意味着该应用程序的一些首次使用可能会有点慢，因为在这种情况下，将仅使用“及时”编译。
+这种方法的唯一缺点是，为了获取配置文件数据并预编译常用的方法和类，用户必须实际使用应用程序。这意味着该应用程序的一些首次使用可能会有点慢，因为在这种情况下，将仅使用即时编译。
 
 这就是为什么要改善在Android P中的初始用户体验的原因，Google在云中引入了个人资料。
 
@@ -158,4 +158,4 @@ ART缺点:
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 

From 93b3dd2483e6775233f5ce35f1c5590f823e4040 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Sun, 25 Apr 2021 21:38:34 +0800
Subject: [PATCH 064/213] update README

---
 ...\351\207\217&\347\261\273&\346\216\245\345\217\243.md" | 8 ++++++--
 README.md                                                 | 4 ++--
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md" "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
index fe0de1b5..c2e41fb7 100644
--- "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
+++ "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
@@ -700,7 +700,7 @@ data class Artist(
 - `hashCode()`
 - `copy()`
 - `toString()`
-- 一系列可以映射对象到变量中的函数(后面再说)。
+- `componentN()`
 
 如果我们使用不可修改的对象，就像我们之前讲过的，假如我们需要修改这个对象状态，必须要创建一个新的一个或者多个属性被修改的实例。
 这个任务是非常重复且不简洁的。
@@ -724,7 +724,7 @@ val charon2 = charon.copy(age = 19)
 - 数据类必须拥有一个构造方法，该方法至少包含一个参数，一个没有数据的数据类是没有任何用处的。
 - 与普通的类不同，数据类构造方法的参数强制使用var或者val进行声明
 - data class之前不能用abstract、open、sealed或者inner进行修饰
-- 在Kotlin 1.1版本前数据类只允许实现接口，之后的版本既可以实现接口也可以继承类
+- 在Kotlin 1.1版本前数据类只允许实现接口，之后的版本既可以实现接口也可以继承类，更多可看[Feedback Request: Limitations on Data Classes](https://blog.jetbrains.com/kotlin/2015/09/feedback-request-limitations-on-data-classes/)
 
 
 
@@ -753,6 +753,10 @@ name = PersonData, age = 20
 var name = f1.component1()
 var age = f1.component2()
 ```
+数据类的缺点，数据类虽然使用的时候很简单，但是因为它会默认帮我们自动生成很多代码，里面的有些代码其实在某些情况下我们并不需要，例如copy、component等，
+如果在项目中使用了大量的数据类，那就会引起包大小增加的问题。具体可见[Data classes in Kotlin: how do they impact application size](https://medium.com/bumble-tech/data-classes-in-kotlin-the-real-impact-of-using-it-6f1fdc909837)
+
+虽然对于release包，使用了R8，ProGuard，DexGuard等优化器。这些可以删除未使用的方法，这意味着它们可以优化数据类。像componentN()、copy()如果没有使用的话，会默认给删除。但是对于toString()、equals()、hashCode()方法则不会删除。对于有些不需要toString()、equals()、hashCode()方法的类如果使用数据类就会导致多生成这些代码，所以在使用数据类的时候不要去为了简单而乱用，也要去想想是否需要这些方法？是否需要设计成数据类。
 
 ## 继承
 
diff --git a/README.md b/README.md
index b8e22d65..39604e78 100644
--- a/README.md
+++ b/README.md
@@ -192,7 +192,7 @@ Android学习笔记
     - [Android启动模式详解][75]
     - [Android卸载反馈][76]
     - [ApplicationId vs PackageName][77]
-    - [ART与Dalvik][78]
+    - [AndroidRuntime_ART与Dalvik][78]
     - [BroadcastReceiver安全问题][79]
     - [Crash及ANR分析][80]
     - [Library项目中资源id使用case时报错][81]
@@ -389,7 +389,7 @@ Android学习笔记
 [75]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/Android%E5%90%AF%E5%8A%A8%E6%A8%A1%E5%BC%8F%E8%AF%A6%E8%A7%A3.md   "Android启动模式详解"
 [76]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/Android%E5%8D%B8%E8%BD%BD%E5%8F%8D%E9%A6%88.md   "Android卸载反馈"
 [77]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/ApplicationId%20vs%20PackageName.md   "ApplicationId vs PackageName"
-[78]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/ART%E4%B8%8EDalvik.md   "ART与Dalvik"
+[78]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/AndroidRuntime_ART%E4%B8%8EDalvik.md   "AndroidRuntime_ART与Dalvik"
 [79]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/BroadcastReceiver%E5%AE%89%E5%85%A8%E9%97%AE%E9%A2%98.md   "BroadcastReceiver安全问题"
 [80]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/Crash%E5%8F%8AANR%E5%88%86%E6%9E%90.md  "Crash及ANR分析"
 

From 401e87a80e866e89cad7515aa38f1ac5c7d86151 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 26 Apr 2021 10:40:17 +0800
Subject: [PATCH 065/213] update MaterialDesign

---
 .../MaterialDesign\344\275\277\347\224\250.md"   | 16 ++++++++++------
 "Architect/2.UML\347\256\200\344\273\213.md"     |  9 +++++++++
 2 files changed, 19 insertions(+), 6 deletions(-)
 create mode 100644 "Architect/2.UML\347\256\200\344\273\213.md"

diff --git "a/AdavancedPart/MaterialDesign\344\275\277\347\224\250.md" "b/AdavancedPart/MaterialDesign\344\275\277\347\224\250.md"
index 549c18e9..fa323a88 100644
--- "a/AdavancedPart/MaterialDesign\344\275\277\347\224\250.md"
+++ "b/AdavancedPart/MaterialDesign\344\275\277\347\224\250.md"
@@ -1,13 +1,14 @@
 MaterialDesign使用
 ===
 
-- `Material Design`是`Google`在`2014`年的`I/O`大会上推出的全新设计语言。                        
+- [Material Design](https://material.io/components?platform=android)是`Google`在`2014`年的`I/O`大会上推出的全新设计语言。                        
 - `Material Design`是基于`Android 5.0``(API level 21)`的，兼容5.0以下的设备时需要使用版本号`v21.0.0`以上的                           
 `support v7`包中的`appcpmpat`，不过遗憾的是`support`包只支持`Material Design`的部分特性。                       
-使用`eclipse`或`Android Studio`进行开发时，直接在`Android SDK Manager`中将`Extras->Android Support Library`
-升级至最新版即可。
+为了更好的去使用，需要继承support.design包: 
+```
+implementation 'com.android.support:design:<version>'
+```
 
-下面我就简单讲解一下如何通过`support v7`包来使用`Material Design`进行开发。
 
 Material Design Theme
 ---
@@ -690,10 +691,11 @@ final NavigationView navigationView = (NavigationView) findViewById(R.id.navigat
 从名字可以看出，这个ViewGroup是用来协调它的子View的，CoordinatorLayout 作为一个 **“super-powered FrameLayout”**，主要有以下两个作用：
 
 1. 作为顶层布局；
-2. 作为协调子 View 之间交互的容器。
+2. 作为协调子View之间交互的容器。
 
 CoordinatorLayout也是在`com.android.support.design`包中的组件。 
 
+通过为 CoordinatorLayout 的子View指定 Behaviors，你可以在单一父View下提供许多不同的交互，同时也可以让子View间各自进行交互。
 #### CoordinatorLayout与FloadingActionButton
 
 ```xml
@@ -856,7 +858,9 @@ compile 'com.android.support:recyclerview-v7:21.+'
 
 
 
+[更多实例请看MaterialSample](https://github.com/CharonChui/MaterialSample.git)
+
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/Architect/2.UML\347\256\200\344\273\213.md" "b/Architect/2.UML\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..c0259a46
--- /dev/null
+++ "b/Architect/2.UML\347\256\200\344\273\213.md"
@@ -0,0 +1,9 @@
+2.UML简介
+
+推荐使用[Visual Paradigm](https://www.visual-paradigm.com/cn/)，如果是非商业用途可以下载社区版，免费使用
+
+## 类图
+
+## 时序图
+
+

From 12e93433fda6f5968a4880f635283d1c58deddfb Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 26 Apr 2021 21:34:39 +0800
Subject: [PATCH 066/213] update Kotlin notes

---
 ...MaterialDesign\344\275\277\347\224\250.md" | 19 ++++++++++++++-----
 ...&\347\261\273&\346\216\245\345\217\243.md" |  2 ++
 ...7&\345\205\263\351\224\256\345\255\227.md" |  2 +-
 3 files changed, 17 insertions(+), 6 deletions(-)

diff --git "a/AdavancedPart/MaterialDesign\344\275\277\347\224\250.md" "b/AdavancedPart/MaterialDesign\344\275\277\347\224\250.md"
index fa323a88..e8a477b4 100644
--- "a/AdavancedPart/MaterialDesign\344\275\277\347\224\250.md"
+++ "b/AdavancedPart/MaterialDesign\344\275\277\347\224\250.md"
@@ -2,13 +2,22 @@ MaterialDesign使用
 ===
 
 - [Material Design](https://material.io/components?platform=android)是`Google`在`2014`年的`I/O`大会上推出的全新设计语言。                        
-- `Material Design`是基于`Android 5.0``(API level 21)`的，兼容5.0以下的设备时需要使用版本号`v21.0.0`以上的                           
-`support v7`包中的`appcpmpat`，不过遗憾的是`support`包只支持`Material Design`的部分特性。                       
-为了更好的去使用，需要继承support.design包: 
+为了使用Materia功能，首先需要集成相应的依赖: 
 ```
-implementation 'com.android.support:design:<version>'
+implementation 'com.google.android.material:material:<version>'
+```
+并保证Activity都使用AppCompatActivity，这样可以确保所有组件都能正常使用。
+把主题改成集成自Material组件的主题: 
+```
+    Theme.MaterialComponents
+    Theme.MaterialComponents.NoActionBar
+    Theme.MaterialComponents.Light
+    Theme.MaterialComponents.Light.NoActionBar
+    Theme.MaterialComponents.Light.DarkActionBar
+    Theme.MaterialComponents.DayNight
+    Theme.MaterialComponents.DayNight.NoActionBar
+    Theme.MaterialComponents.DayNight.DarkActionBar
 ```
-
 
 Material Design Theme
 ---
diff --git "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md" "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
index c2e41fb7..d4406391 100644
--- "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
+++ "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
@@ -31,6 +31,8 @@
 and first-class delegation`等实现
 - `Kotlin`可与`Java`语言无缝通信。这意味着我们可以在`Kotlin`代码中使用任何已有的`Java`库；同样的`Kotlin`代码还可以为`Java`代码所用
 - `Kotlin`在代码中很少需要在代码中指定类型，因为编译器可以在绝大多数情况下推断出变量或是函数返回值的类型。这样就能获得两个好处:简洁与安全
+- Kotlin 是一种静态类型的语言。这意味着，类型将在编译时解析且从不改变
+
 
 ## `Kotlin`优势
 
diff --git "a/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md" "b/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md"
index 4210b7a1..4457adc7 100644
--- "a/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md"
+++ "b/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md"
@@ -3,7 +3,7 @@
 
 ## `if`表达式
 
-在`Kotlin`中，`if`是一个表达式，即它会返回一个值。因此就不需要三元运算符`条件 ? 然后 : 否则`，因为普通的`if`就能胜任这个角色。
+在`Kotlin`中，`if`是一个表达式，即它会返回一个值，每个条件分支都隐式地返回其最后一行的表达式的结果，因此无需使用return关键字。因此就不需要三元运算符`条件 ? 然后 : 否则`，因为普通的`if`就能胜任这个角色。
 `if`的分支可以是代码块，最后的表达式作为该块的值:   
 
 ```kotlin

From c1deae781ab77a6497efe78a9c9fd2e447620ad0 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 17 May 2021 11:19:58 +0800
Subject: [PATCH 067/213] add jetpack part

---
 ...MaterialDesign\344\275\277\347\224\250.md" | 875 ---------------
 ...\351\233\206\346\210\220(\344\272\214).md" | 164 ---
 .../3.Lifecycle(\344\270\211).md"             | 175 ---
 .../4.LiveData(\345\233\233).md"              | 315 ------
 .../5.ViewModel(\344\272\224).md"             | 138 ---
 "Jetpack/Jetpack\347\256\200\344\273\213.md"  | 161 +++
 .../1.\347\256\200\344\273\213.md"            |   4 +-
 .../10.DataStore\347\256\200\344\273\213.md"  | 205 ++++
 .../11.Hilt\347\256\200\344\273\213.md"       |  16 +
 .../12.Navigation\347\256\200\344\273\213.md" | 487 +++++++++
 Jetpack/architecture/13.Jetpack MVVM.md       |  47 +
 ...73\345\217\212\346\234\252\346\235\245.md" |  22 +
 .../2.ViewBinding\347\256\200\344\273\213.md" | 400 +++++++
 Jetpack/architecture/3.Lifecycle.md           | 958 +++++++++++++++++
 Jetpack/architecture/4.ViewModel.md           | 349 ++++++
 Jetpack/architecture/5.LiveData.md            | 430 ++++++++
 .../6.DataBinding\347\256\200\344\273\213.md" |  23 +
 .../architecture/7.Room.md                    |   2 +-
 .../architecture/8.PagingLibrary.md           |   2 +-
 .../9.App Startup\347\256\200\344\273\213.md" | 607 +++++++++++
 ...etpack Compose\347\256\200\344\273\213.md" |  22 +
 ...aterialToolbar\347\256\200\344\273\213.md" | 281 +++++
 ...NavigationView\347\256\200\344\273\213.md" | 192 ++++
 ...stedScrollView\347\256\200\344\273\213.md" | 993 ++++++++++++++++++
 ...rdinatorLayout\347\256\200\344\273\213.md" | 154 +++
 ...5.AppBarLayout\347\256\200\344\273\213.md" |  94 ++
 ...gToolbarLayout\347\256\200\344\273\213.md" | 234 +++++
 .../7.Snackbar\347\256\200\344\273\213.md"    |  36 +
 .../8.TabLayout\347\256\200\344\273\213.md"   |  39 +
 ...2\344\270\276&\345\247\224\346\211\230.md" | 204 +++-
 README.md                                     |   2 -
 31 files changed, 5938 insertions(+), 1693 deletions(-)
 delete mode 100644 "AdavancedPart/MaterialDesign\344\275\277\347\224\250.md"
 delete mode 100644 "ArchitectureComponents/2.\351\233\206\346\210\220(\344\272\214).md"
 delete mode 100644 "ArchitectureComponents/3.Lifecycle(\344\270\211).md"
 delete mode 100644 "ArchitectureComponents/4.LiveData(\345\233\233).md"
 delete mode 100644 "ArchitectureComponents/5.ViewModel(\344\272\224).md"
 create mode 100644 "Jetpack/Jetpack\347\256\200\344\273\213.md"
 rename "ArchitectureComponents/1.\347\256\200\344\273\213(\344\270\200).md" => "Jetpack/architecture/1.\347\256\200\344\273\213.md" (96%)
 create mode 100644 "Jetpack/architecture/10.DataStore\347\256\200\344\273\213.md"
 create mode 100644 "Jetpack/architecture/11.Hilt\347\256\200\344\273\213.md"
 create mode 100644 "Jetpack/architecture/12.Navigation\347\256\200\344\273\213.md"
 create mode 100644 Jetpack/architecture/13.Jetpack MVVM.md
 create mode 100644 "Jetpack/architecture/14.findViewById\347\232\204\350\277\207\345\216\273\345\217\212\346\234\252\346\235\245.md"
 create mode 100644 "Jetpack/architecture/2.ViewBinding\347\256\200\344\273\213.md"
 create mode 100644 Jetpack/architecture/3.Lifecycle.md
 create mode 100644 Jetpack/architecture/4.ViewModel.md
 create mode 100644 Jetpack/architecture/5.LiveData.md
 create mode 100644 "Jetpack/architecture/6.DataBinding\347\256\200\344\273\213.md"
 rename "ArchitectureComponents/6.Room(\345\205\255).md" => Jetpack/architecture/7.Room.md (99%)
 rename "ArchitectureComponents/7.PagingLibrary(\344\270\203).md" => Jetpack/architecture/8.PagingLibrary.md (75%)
 create mode 100644 "Jetpack/architecture/9.App Startup\347\256\200\344\273\213.md"
 create mode 100644 "Jetpack/ui/Jetpack Compose\347\256\200\344\273\213.md"
 create mode 100644 "Jetpack/ui/material/1.MaterialToolbar\347\256\200\344\273\213.md"
 create mode 100644 "Jetpack/ui/material/2.NavigationView\347\256\200\344\273\213.md"
 create mode 100644 "Jetpack/ui/material/3.NestedScrollView\347\256\200\344\273\213.md"
 create mode 100644 "Jetpack/ui/material/4.CoordinatorLayout\347\256\200\344\273\213.md"
 create mode 100644 "Jetpack/ui/material/5.AppBarLayout\347\256\200\344\273\213.md"
 create mode 100644 "Jetpack/ui/material/6.CollapsingToolbarLayout\347\256\200\344\273\213.md"
 create mode 100644 "Jetpack/ui/material/7.Snackbar\347\256\200\344\273\213.md"
 create mode 100644 "Jetpack/ui/material/8.TabLayout\347\256\200\344\273\213.md"

diff --git "a/AdavancedPart/MaterialDesign\344\275\277\347\224\250.md" "b/AdavancedPart/MaterialDesign\344\275\277\347\224\250.md"
deleted file mode 100644
index e8a477b4..00000000
--- "a/AdavancedPart/MaterialDesign\344\275\277\347\224\250.md"
+++ /dev/null
@@ -1,875 +0,0 @@
-MaterialDesign使用
-===
-
-- [Material Design](https://material.io/components?platform=android)是`Google`在`2014`年的`I/O`大会上推出的全新设计语言。                        
-为了使用Materia功能，首先需要集成相应的依赖: 
-```
-implementation 'com.google.android.material:material:<version>'
-```
-并保证Activity都使用AppCompatActivity，这样可以确保所有组件都能正常使用。
-把主题改成集成自Material组件的主题: 
-```
-    Theme.MaterialComponents
-    Theme.MaterialComponents.NoActionBar
-    Theme.MaterialComponents.Light
-    Theme.MaterialComponents.Light.NoActionBar
-    Theme.MaterialComponents.Light.DarkActionBar
-    Theme.MaterialComponents.DayNight
-    Theme.MaterialComponents.DayNight.NoActionBar
-    Theme.MaterialComponents.DayNight.DarkActionBar
-```
-
-Material Design Theme
----
-
-`Material`主题:                         
-
-- @android:style/Theme.Material (dark version)             --               Theme.AppCompat                           
-- @android:style/Theme.Material.Light (light version)      --               Theme.AppCompat.Light                 
-- @android:style/Theme.Material.Light.DarkActionBar        --               Theme.AppCompat.Light.DarkActionBar                 
-
-对应的效果分别如下:    
-
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/Material_theme.png?raw=true)    
-
-使用ToolBar
----
-
-- 禁止Action Bar                  
-    ToolBar相当于是ActionBar的替代版，因此需要制定一个不带ActionBar的主题，
-    可以通过自定义`theme`继承`Theme.AppCompat.Light.NoActionBar`或者在`theme`中通过以下配置来进行禁用`ActionBar`。
-    
-    ```xml
-    <item name="windowActionBar">false</item>
-    <item name="android:windowNoTitle">true</item>
-    ```
-    
-    下面我通过第二种方式来看一下具体的实现:   
-    
-    在`style.xml`中自定义`AppTheme`:    
-    
-    ```xml
-    <!-- Base application theme. -->
-    <style name="AppTheme" parent="AppTheme.Base"/>
-    
-    <style name="AppTheme.Base" parent="Theme.AppCompat.Light.DarkActionBar">
-    	<!-- Tell Android System that we will use ToolBar instead of ActionBar -->
-    	<item name="windowNoTitle">true</item>
-    	<item name="windowActionBar">false</item>
-    	<!-- colorPrimary is used for the default action bar background -->
-    	<item name="colorPrimary">@color/colorPrimary</item>
-    
-    	<!-- colorPrimaryDark is used for the status bar -->
-    	<item name="colorPrimaryDark">@color/colorPrimaryDark</item>
-    
-    	<!-- colorAccent is used as the default value for colorControlActivated
-    		 which is used to tint widgets -->
-    	<item name="colorAccent">@color/colorAccent</item>
-    </style>
-    ```
-    
-    配置的这几种颜色分别如下图所示:    
-    ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/material_color.png?raw=true)	       
-里面没有`colorAccent`的颜色，唯独colorAccent这个属性比较难理解，它不是用来指定Checkbox`等某一个按钮的颜色，而是更多表达了一个强调的意思，比如一些控件的选中状态也会使用colorAccent的颜色。
-    
-    在`values-v21`中的`style.xml`中同样自定义`AppTheme`主题: 
-    ```xml
-    <style name="AppTheme" parent="AppTheme.Base">
-        <!-- Customize your theme using Material Design here. -->
-    	<item name="android:windowContentTransitions" >true</item>
-    	<item name="android:windowAllowEnterTransitionOverlap" >true</item>
-    	<item name="android:windowAllowReturnTransitionOverlap">true</item>
-    	<item name="android:windowSharedElementEnterTransition">@android:transition/move</item>
-    	<item name="android:windowSharedElementExitTransition">@android:transition/move</item>
-    </style>
-    ```
-    
-- 在`Manifest`文件中设置`AppTheme`主题:   
-
-    ```xml
-    <application
-    	android:allowBackup="true"
-    	android:icon="@mipmap/ic_launcher"
-    	android:label="@string/app_name"
-    	android:theme="@style/AppTheme" >
-    	<activity
-    		...
-    	</activity>
-    	<activity android:name="com.charon.materialsample.FriendsActivity"></activity>
-    </application>
-    ```
-    这里说一下为什么要在`values-v21`中也自定义个主题，这是为了能让在`21`以上的版本能更好的使用`Material Design`，
-在21以上的版本中会有更多的动画、特效等。
-
-- 让Activity继承AppCompatActivity
-
-    ```java
-    public class MainActivity extends AppCompatActivity {
-    	...
-    }
-    ```
-
-- 在布局文件中进行声明
-
-    声明`toolbar.xml`，我们把他单独放到一个文件中，方便多布局使用:    
-    ```xml
-    <android.support.v7.widget.Toolbar xmlns:android="http://schemas.android.com/apk/res/android"
-        xmlns:local="http://schemas.android.com/apk/res-auto"
-        android:id="@+id/toolbar"
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content"
-        android:background="?attr/colorPrimary"
-        android:minHeight="?attr/actionBarSize"
-        local:popupTheme="@style/ThemeOverlay.AppCompat.Light"
-        local:theme="@style/ThemeOverlay.AppCompat.Dark.ActionBar" />
-    ```
-    在`Activity`的布局中使用`ToolBar`:    
-    
-    ```xml
-    <LinearLayout
-    	android:layout_width="match_parent"
-    	android:layout_height="match_parent"
-    	android:orientation="vertical">
-    
-    	<include
-    		android:id="@+id/toolbar"
-    		layout="@layout/toolbar" />
-    
-    	<com.charon.materialsample.view.PagerSlidingTabStrip
-    		android:id="@+id/psts_main"
-    		android:layout_width="match_parent"
-    		android:layout_height="48dip"
-    		android:background="@color/colorPrimary" />
-    
-    	<android.support.v4.view.ViewPager
-    		android:id="@+id/vp_main"
-    		android:layout_width="match_parent"
-    		android:layout_height="match_parent"></android.support.v4.view.ViewPager>
-    
-    </LinearLayout>
-    ```
-
-- 在Activity中设置ToolBar
-    ```java
-    public class MainActivity extends AppCompatActivity{
-        private Context mContext;
-        private Toolbar mToolbar;
-    
-        @Override
-        protected void onCreate(Bundle savedInstanceState) {
-            super.onCreate(savedInstanceState);
-            setContentView(R.layout.activity_main);
-            mContext = this;
-    		mToolbar = (Toolbar) findViewById(R.id.toolbar);
-    		mToolbar.setTitle(R.string.app_name);
-    		// 将ToolBar设置为ActionBar，这样一设置后他就能像ActionBar一样直接显示menu目录中的菜单资源
-    		// 如果不用该方法，那ToolBar就只是一个普通的View，对menu要用inflateMenu去加载布局。
-    		setSupportActionBar(mToolbar);
-    		getSupportActionBar().setDisplayShowHomeEnabled(true);
-        }
-    }
-    ```
-
-到这里运行项目就可以了，就可以看到一个简单的`ToolBar`实现。
-
-接下来我们看一下`ToolBar`中具体有哪些内容:    
-
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/ToolBar_content.jpg?raw=true)	              
-
-我们可以通过对应的方法来修改他们的属性:                 
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/toolbarCode.png?raw=true)
-
-ToolBar最左侧的这个按钮就叫做HomeAsUp按钮，它默认的图标是一个返回的箭头，含义是返回上一个活动，可以通过setDisplayHomeAsUpEnabled来让导航按钮显示出来。 可以在onOptionsItemSelected()方法中对HomeAsUp安阿牛的点击事件进行处理，HomeAsUp按钮的id永远都是android.R.id.home。
-
-​	           
-
-对于`ToolBar`中的`Menu`部分我们可以通过一下方法来设置:     
-```java
-toolbar.inflateMenu(R.menu.menu_main);
-toolbar.setOnMenuItemClickListener();
-```
-或者也可以直接在`Activity`的`onCreateOptionsMenu`及`onOptionsItemSelected`来处理: 
-```java
-@Override
-public boolean onCreateOptionsMenu(Menu menu) {
-	// Inflate the menu; this adds items to the action bar if it is present.
-	getMenuInflater().inflate(R.menu.menu_main, menu);
-	return true;
-}
-
-@Override
-public boolean onOptionsItemSelected(MenuItem item) {
-	// Handle action bar item clicks here. The action bar will
-	// automatically handle clicks on the Home/Up button, so long
-	// as you specify a parent activity in AndroidManifest.xml.
-	int id = item.getItemId();
-
-	//noinspection SimplifiableIfStatement
-	if (id == R.id.action_settings) {
-		return true;
-	}
-	if (id == R.id.action_search) {
-		Toast.makeText(getApplicationContext(), "Search action is selected!", Toast.LENGTH_SHORT).show();
-		return true;
-	}
-	return super.onOptionsItemSelected(item);
-}
-```
-`menu`的实现如下:   
-```xml
-<menu xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:app="http://schemas.android.com/apk/res-auto"
-    xmlns:tools="http://schemas.android.com/tools" tools:context=".MainActivity">
-
-        <item
-            android:id="@+id/action_search"
-            android:title="@string/action_search"
-            android:orderInCategory="100"
-            android:icon="@drawable/ic_action_search"
-            app:showAsAction="ifRoom" />
-
-        <item
-            android:id="@+id/action_settings"
-            android:title="@string/action_settings"
-            android:orderInCategory="100"
-            app:showAsAction="never" />
-
-</menu>
-```
-
-如果想要对`NavigationIcon`添加点击实现:  
-```java
-toolbar.setNavigationOnClickListener(new View.OnClickListener() {
-	@Override
-	public void onClick(View v) {
-		onBackPressed();
-	}
-});
-```
-
-运行后发现我们强大的`Activity`切换动画怎么在`5.0`一下系统上实现呢？`support v7`包也帮我们考虑到了。使用`ActivityOptionsCompat`
-及`ActivityCompat.startActivity`，但是悲剧了，他对4.0一下基本都无效，而且就算在4.0上很多动画也不行，具体还是用其他
-大神在`github`写的开源项目吧。
-
-
-- 动态取色Palette 
-
-    `Palette`这个类中可以提取一下集中颜色：　　
-    
-    - Vibrant （有活力）
-    - Vibrant dark（有活力 暗色）
-    - Vibrant light（有活力 亮色）
-    - Muted （柔和）
-    - Muted dark（柔和 暗色）
-    - Muted light（柔和 亮色）
-    
-    ```java
-    //目标bitmap，代码片段
-    Bitmap bm = BitmapFactory.decodeResource(getResources(),
-    		R.drawable.kale);
-    Palette palette = Palette.generate(bm);
-    if (palette.getLightVibrantSwatch() != null) {
-    	//得到不同的样本，设置给imageview进行显示
-    	iv.setBackgroundColor(palette.getLightVibrantSwatch().getRgb());
-    	iv1.setBackgroundColor(palette.getDarkVibrantSwatch().getRgb());
-    	iv2.setBackgroundColor(palette.getLightMutedSwatch().getRgb());
-    	iv3.setBackgroundColor(palette.getDarkMutedSwatch().getRgb());
-    }
-    ```
-
-使用DrawerLayout
----
-
-- 布局中的使用
-
-```xml
-<android.support.v4.widget.DrawerLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:app="http://schemas.android.com/apk/res-auto"
-    xmlns:tools="http://schemas.android.com/tools"
-    android:id="@+id/drawer_layout"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent">
-
-    <!--主页面-->
-    <LinearLayout
-        android:layout_width="match_parent"
-        android:layout_height="match_parent"
-        android:orientation="vertical">
-
-        <include
-            android:id="@+id/toolbar"
-            layout="@layout/toolbar" />
-
-        <com.charon.materialsample.view.PagerSlidingTabStrip
-            android:id="@+id/psts_main"
-            android:layout_width="match_parent"
-            android:layout_height="48dip"
-            android:background="@color/colorPrimary" />
-
-        <android.support.v4.view.ViewPager
-            android:id="@+id/vp_main"
-            android:layout_width="match_parent"
-            android:layout_height="match_parent"></android.support.v4.view.ViewPager>
-
-    </LinearLayout>
-
-    <!--侧边栏部分-->
-    <fragment
-        android:id="@+id/fragment_navigation_drawer"
-        android:name="com.charon.materialsample.fragment.FragmentDrawer"
-        android:layout_width="@dimen/nav_drawer_width"
-        android:layout_height="match_parent"
-        android:layout_gravity="start"
-        app:layout="@layout/fragment_navigation_drawer"
-        tools:layout="@layout/fragment_navigation_drawer" />
-
-</android.support.v4.widget.DrawerLayout>
-```
-
-使用DrawerLayout后可以实现类似SlidingMenu的效果。但是怎么将DrawerLayout与ToolBar结合起来呢？ 还有再结合Navigation Tabs
-以及ViewPager。下面我就直接上代码了。
-
-先看布局：　activity_main.xml                
-```xml
-<android.support.v4.widget.DrawerLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:app="http://schemas.android.com/apk/res-auto"
-    xmlns:tools="http://schemas.android.com/tools"
-    android:id="@+id/drawer_layout"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent">
-
-    <!--主页面-->
-    <LinearLayout
-        android:layout_width="match_parent"
-        android:layout_height="match_parent"
-        android:orientation="vertical">
-
-        <include
-            android:id="@+id/toolbar"
-            layout="@layout/toolbar" />
-
-        <com.charon.materialsample.view.PagerSlidingTabStrip
-            android:id="@+id/psts_main"
-            android:layout_width="match_parent"
-            android:layout_height="48dip"
-            android:background="@color/colorPrimary" />
-
-        <android.support.v4.view.ViewPager
-            android:id="@+id/vp_main"
-            android:layout_width="match_parent"
-            android:layout_height="match_parent"/>
-
-    </LinearLayout>
-
-    <!--侧边栏部分-->
-    <fragment
-        android:id="@+id/fragment_navigation_drawer"
-        android:name="com.charon.materialsample.fragment.DrawerFragment"
-        android:layout_width="wrap_content"
-        android:layout_marginRight="56dp"
-        android:layout_height="match_parent"
-        android:layout_gravity="start"
-        app:layout="@layout/fragment_navigation_drawer"
-        tools:layout="@layout/fragment_navigation_drawer" />
-
-</android.support.v4.widget.DrawerLayout>
-```
-
-MainActivity的代码: 
-```java
-public class MainActivity extends AppCompatActivity {
-
-    private Context mContext;
-
-    private Toolbar mToolbar;
-    private PagerSlidingTabStrip mScrollingTabs;
-    private ViewPager mViewPager;
-    private MainPagerAdapter mPagerAdapter;
-    private ActionBarDrawerToggle mDrawerToggle;
-    private DrawerLayout mDrawerLayout;
-
-    private List<String> mTitles;
-    private List<Fragment> mFragments;
-
-    @Override
-    protected void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-        setContentView(R.layout.activity_main);
-        mContext = this;
-
-        findView();
-        setToolBar();
-        initView();
-        initDrawerFragment();
-    }
-
-    private void findView() {
-        mToolbar = (Toolbar) findViewById(R.id.toolbar);
-        mScrollingTabs = (PagerSlidingTabStrip) findViewById(R.id.psts_main);
-        mViewPager = (ViewPager) findViewById(R.id.vp_main);
-        mDrawerLayout = (DrawerLayout) findViewById(R.id.drawer_layout);
-    }
-
-
-    private void setToolBar() {
-        mToolbar.setTitle(R.string.app_name);
-        setSupportActionBar(mToolbar);
-        getSupportActionBar().setDisplayShowHomeEnabled(true);
-    }
-
-    private void initView() {
-        mFragments = new ArrayList<>();
-        for (int xxx = 0; xxx < 5; xxx++) {
-            mFragments.add(new FriendsFragment());
-        }
-
-        mTitles = new ArrayList<>();
-        for (int xxx = 0; xxx < 5; xxx++) {
-            mTitles.add("Tab : " + xxx);
-        }
-
-        mPagerAdapter = new MainPagerAdapter(getSupportFragmentManager(), mFragments, mTitles);
-        mViewPager.setAdapter(mPagerAdapter);
-        mScrollingTabs.setDividerColor(Color.TRANSPARENT);
-        mScrollingTabs.setIndicatorHeight(10);
-        mScrollingTabs.setUnderlineHeight(0);
-        mScrollingTabs.setTextSize(50);
-        mScrollingTabs.setTextColor(Color.BLACK);
-        mScrollingTabs.setSelectedTextColor(Color.WHITE);
-        mScrollingTabs.setViewPager(mViewPager);
-
-    }
-
-    private void initDrawerFragment() {
-        mDrawerToggle = new ActionBarDrawerToggle(this, mDrawerLayout, mToolbar, R.string.drawer_open, R.string.drawer_close) {
-            @Override
-            public void onDrawerOpened(View drawerView) {
-                super.onDrawerOpened(drawerView);
-                MainActivity.this.invalidateOptionsMenu();
-            }
-
-            @Override
-            public void onDrawerClosed(View drawerView) {
-                super.onDrawerClosed(drawerView);
-                MainActivity.this.invalidateOptionsMenu();
-            }
-
-            @Override
-            public void onDrawerSlide(View drawerView, float slideOffset) {
-                super.onDrawerSlide(drawerView, slideOffset);
-                mToolbar.setAlpha(1 - slideOffset / 2);
-            }
-        };
-
-        mDrawerLayout.setDrawerListener(mDrawerToggle);
-        mDrawerToggle.syncState();
-    }
-
-    @Override
-    public boolean onCreateOptionsMenu(Menu menu) {
-        // Inflate the menu; this adds items to the action bar if it is present.
-        getMenuInflater().inflate(R.menu.menu_main, menu);
-        return true;
-    }
-
-    @Override
-    public boolean onOptionsItemSelected(MenuItem item) {
-        // Handle action bar item clicks here. The action bar will
-        // automatically handle clicks on the Home/Up button, so long
-        // as you specify a parent activity in AndroidManifest.xml.
-        int id = item.getItemId();
-
-        //noinspection SimplifiableIfStatement
-        if (id == R.id.action_settings) {
-            return true;
-        }
-        if (id == R.id.action_search) {
-            Toast.makeText(getApplicationContext(), "Search action is selected!", Toast.LENGTH_SHORT).show();
-            return true;
-        }
-        return super.onOptionsItemSelected(item);
-    }
-
-}
-```
-最后再看一下`DrawerFragment`的代码: 
-```java
-public class DrawerFragment extends Fragment {
-    private Context mContext;
-    private RecyclerView mRecyclerView;
-    private NavigationDrawerAdapter mAdapter;
-    private static String[] titles = null;
-
-    public DrawerFragment() {
-
-    }
-
-    public static List<NavDrawerItem> getData() {
-        List<NavDrawerItem> data = new ArrayList<>();
-
-        // preparing navigation drawer items
-        for (int i = 0; i < titles.length; i++) {
-            NavDrawerItem navItem = new NavDrawerItem();
-            navItem.setTitle(titles[i]);
-            data.add(navItem);
-        }
-        return data;
-    }
-
-    @Override
-    public void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-        mContext = getActivity();
-        // drawer labels
-        titles = getActivity().getResources().getStringArray(R.array.nav_drawer_labels);
-    }
-
-    @Override
-    public View onCreateView(LayoutInflater inflater, ViewGroup container,
-                             Bundle savedInstanceState) {
-        // Inflating view layout
-        View layout = inflater.inflate(R.layout.fragment_navigation_drawer, container, false);
-        mRecyclerView = (RecyclerView) layout.findViewById(R.id.drawerList);
-        mRecyclerView.setHasFixedSize(true);
-        mAdapter = new NavigationDrawerAdapter(getActivity(), getData());
-        mRecyclerView.setAdapter(mAdapter);
-        mRecyclerView.setLayoutManager(new LinearLayoutManager(getActivity()));
-        mAdapter.setOnRecyclerViewListener(new NavigationDrawerAdapter.OnRecyclerViewListener() {
-            @Override
-            public void onItemClick(int position) {
-                Toast.makeText(mContext, getData().get(position).getTitle(), Toast.LENGTH_SHORT).show();
-                startActivity(new Intent(getActivity(), FriendsActivity.class));
-            }
-
-            @Override
-            public boolean onItemLongClick(int position) {
-                return false;
-            }
-        });
-        return layout;
-    }
-
-}
-```
-上面的`PagerSlidingTabStrip`是开源项目，我改了下，添加了一个选中时的文字颜色改变。
-
-[Demo地址](https://github.com/CharonChui/MaterialLibrary)
-
-### NavigationView
-
-NavigationView包含两个部分：menu和headerLayout。menu是用来在NavigationView中显示具体的菜单项的，headerLayout则是用来在NavigationView中显示头部布局的。
-
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/navigator_view.png?raw=true)        
-
-```xml
-<?xml version="1.0" encoding="utf-8"?>
-<android.support.v4.widget.DrawerLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:app="http://schemas.android.com/apk/res-auto"
-    android:id="@+id/drawer_layout"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent">
-
-    <RelativeLayout
-        android:layout_width="match_parent"
-        android:layout_height="match_parent">
-
-        <android.support.v7.widget.Toolbar
-            android:id="@+id/toolbar"
-            android:layout_width="match_parent"
-            android:layout_height="?attr/actionBarSize"
-            android:background="@color/colorPrimary" />
-
-    </RelativeLayout>
-
-    <android.support.design.widget.NavigationView
-        android:id="@+id/navigation_view"
-        android:layout_width="wrap_content"
-        android:layout_height="match_parent"
-        android:layout_gravity="start"
-        app:headerLayout="@layout/drawer_header"
-        app:menu="@menu/drawer_view" />
-</android.support.v4.widget.DrawerLayout>
-```
-
-
-
-drawer_header.xml 如下
-
-```xml
-<?xml version="1.0" encoding="utf-8"?>
-<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    android:layout_width="match_parent"
-    android:layout_height="wrap_content">
-
-    <ImageView
-        android:scaleType="fitXY"
-        android:src="@drawable/image"
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content" />
-
-    <TextView
-        android:textStyle="bold"
-        android:textColor="@android:color/white"
-        android:textSize="20sp"
-        android:text="Header View"
-        android:layout_marginTop="50dp"
-        android:layout_marginLeft="25dp"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content" />
-
-</RelativeLayout>
-```
-
-
-
-drawer_view.xml 如下： 
-
-```xml
-<?xml version="1.0" encoding="utf-8"?>
-<menu xmlns:android="http://schemas.android.com/apk/res/android">
-    <group android:checkableBehavior="single">
-
-        <item
-            android:id="@+id/menu_home"
-            android:icon="@drawable/ic_home"
-            android:title="Home" />
-
-        <item
-            android:id="@+id/menu_settings"
-            android:icon="@drawable/ic_settings"
-            android:title="Settings" />
-
-        <item android:title="Other">
-            <menu>
-                <item
-                    android:id="@+id/menu_share"
-                    android:icon="@drawable/ic_share"
-                    android:title="Share" />
-                <item
-                    android:id="@+id/menu_about"
-                    android:icon="@drawable/ic_info_outline"
-                    android:title="About" />
-            </menu>
-        </item>
-    </group>
-</menu>
-```
-
-
-
-我们给 Header 和 Menu 添加点击事件： 
-
-```java
-final NavigationView navigationView = (NavigationView) findViewById(R.id.navigation_view);
-        navigationView.getHeaderView(0).setOnClickListener(new View.OnClickListener() {
-            @Override
-            public void onClick(View v) {
-                drawerLayout.closeDrawer(navigationView);
-                Toast.makeText(MainActivity.this, "Header View is clicked!", Toast.LENGTH_SHORT).show();
-            }
-        });
-        navigationView.setNavigationItemSelectedListener(new NavigationView.OnNavigationItemSelectedListener() {
-            @Override
-            public boolean onNavigationItemSelected(@NonNull MenuItem item) {
-                switch (item.getItemId()) {
-                    case R.id.menu_home:
-                        Toast.makeText(MainActivity.this, "Home is clicked!", Toast.LENGTH_SHORT).show();
-                        break;
-                    case R.id.menu_settings:
-                        Toast.makeText(MainActivity.this, "Settings is clicked!", Toast.LENGTH_SHORT).show();
-                        break;
-                    case R.id.menu_share:
-                        Toast.makeText(MainActivity.this, "Share is clicked!", Toast.LENGTH_SHORT).show();
-                        break;
-                    case R.id.menu_about:
-                        Toast.makeText(MainActivity.this, "About is clicked!", Toast.LENGTH_SHORT).show();
-                        break;
-                }
-                drawerLayout.closeDrawer(navigationView);
-                return false;
-            }
-        });
-```
-
-
-
-### CoordinatorLayout
-
-**一、CoordinatorLayout 的作用**
-
-从名字可以看出，这个ViewGroup是用来协调它的子View的，CoordinatorLayout 作为一个 **“super-powered FrameLayout”**，主要有以下两个作用：
-
-1. 作为顶层布局；
-2. 作为协调子View之间交互的容器。
-
-CoordinatorLayout也是在`com.android.support.design`包中的组件。 
-
-通过为 CoordinatorLayout 的子View指定 Behaviors，你可以在单一父View下提供许多不同的交互，同时也可以让子View间各自进行交互。
-#### CoordinatorLayout与FloadingActionButton
-
-```xml
-<?xml version="1.0" encoding="utf-8"?>
-<RelativeLayout     
-    xmlns:android="http://schemas.android.com/apk/res/android"
-    android:id="@+id/contentView"
-    android:orientation="vertical"     
-    android:layout_width="match_parent"
-    android:layout_height="match_parent">
-    <android.support.design.widget.FloatingActionButton
-        android:id="@+id/fab"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:layout_alignParentBottom="true"
-        android:layout_alignParentRight="true"
-        android:onClick="onClick"
-        android:layout_marginRight="10dp"
-        android:layout_marginBottom="10dp"/>
-</RelativeLayout>
-```
-
-
-
-```java
-public void onClick(View v) {
-    switch (v.getId()) {
-        case R.id.fab:
-            Snackbar.make(findViewById(R.id.contentView), "Snackbar", Snackbar.LENGTH_SHORT).show();
-            break;
-    }
-}
-```
-
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/smacker_floatingbutton.webp?raw=true)        
-
-可以看到FloatingActionButton会被SmackBar遮挡，为了解决遮挡的问题，就需要使用到CoordinatorLayout。CoordinatorLayout可以说是一个加强版的FrameLayout，这个布局也是由Design Support库提供的。它在普通情况下的作用和FrameLayout基本一致，不过既然是Design Support库中提供的布局，那么就必然有一些Material Design的魔力了。
-事实上，CoordinatorLayout可以监听其所有子控件的各种事件，然后自动帮助我们做出最为合理的响应。举个简单的例子，刚才弹出的Snackbar提示将悬浮按钮遮挡住了，而如果我们能让CoordinatorLayout监听到Snackbar的弹出事件，那么它会自动将内部的FloatingActionButton向上偏移，从而确保不会被Snackbar遮挡到。
-
-```xml
-<?xml version="1.0" encoding="utf-8"?>
-<android.support.design.widget.CoordinatorLayout 
-    xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:app="http://schemas.android.com/apk/res-auto"
-    android:id="@+id/contentView"
-    android:orientation="vertical" 
-    android:layout_width="match_parent"
-    android:layout_height="match_parent">
-    <LinearLayout
-        android:id="@+id/anchorView"
-        android:layout_width="match_parent"
-        android:layout_height="match_parent"
-        android:orientation="vertical"/>
-    <android.support.design.widget.FloatingActionButton
-        android:id="@+id/fab"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        app:layout_anchor="@id/anchorView"
-        app:layout_anchorGravity="bottom|right"
-        android:onClick="onClick"
-        android:layout_marginRight="10dp"
-        android:layout_marginBottom="10dp"/>
-</android.support.design.widget.CoordinatorLayout>
-```
-
-
-
-悬浮按钮自动向上偏移了Snackbar的同等高度，从而确保不会被遮挡住，当Snackbar消失的时候，悬浮按钮会自动向下偏移回到原来位置。
-另外悬浮按钮的向上和向下偏移也是伴随着动画效果的，且和Snackbar完全同步，整体效果看上去特别赏心悦目。
-
-
-
-或者我们也可以不把不过FloatingActionButton放到布局中，只是make()方法时传入的view是在布局中即可，我们回过头来再思考一下，刚才说的是CoordinatorLayout可以监听其所有子控件的各种事件，但是Snackbar好像并不是CoordinatorLayout的子控件吧，为什么它却可以被监听到呢？
-
-其实道理很简单，还记得我们在Snackbar的make()方法中传入的第一个参数吗？这个参数就是用来指定Snackbar是基于哪个View来触发的，刚才我们传入的是FloatingActionButton本身，而FloatingActionButton是CoordinatorLayout中的子控件，因此这个事件就理所应当能被监听到了。你可以自己再做个试验，如果给Snackbar的make()方法传入一个DrawerLayout，那么Snackbar就会再次遮挡住悬浮按钮，因为DrawerLayout不是CoordinatorLayout的子控件，CoordinatorLayout也就无法监听到Snackbar的弹出和隐藏事件了。
-
-
-
-#### CollapsingToolbarLayout
-
-可折叠式标题栏，CollapsingToolbarLayout是一个作用于Toolbar基础之上的布局，它也是由Design Support库提供的。CollapsingToolbarLayout可以让Toolbar的效果变得更加丰富，不仅仅是展示一个标题栏，而是能够实现非常华丽的效果。
-
-
-
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/CollapsingToolbarLayout.gif?raw=true)        
-
-
-
-可以看到，我们在CollapsingToolbarLayout中定义了一个ImageView和一个Toolbar，也就意味着，这个高级版的标题栏将是由普通的标题栏加上图片组合而成的。这里定义的大多数属性我们都是见过的，就不再解释了，只有一个app:layout_collapseMode比较陌生。它用于指定当前控件在CollapsingToolbarLayout折叠过程中的折叠模式，其中Toolbar指定成pin，表示在折叠的过程中位置始终保持不变，ImageView指定成parallax，表示会在折叠的过程中产生一定的错位偏移，这种模式的视觉效果会非常好。
-
-### NestedScrollView
-
-NestedScrollView 即 支持嵌套滑动的ScrollView。
-
-因此，我们可以简单的把NestedScrollView类比为ScrollView，其作用就是作为控件父布局，从而具备（嵌套）滑动功能。
-
-NestedScrollView与ScrollView的区别就在于NestedScrollView支持 *嵌套滑动*，无论是作为父控件还是子控件，嵌套滑动都支持，且默认开启。
-
-因此，在一些需要支持嵌套滑动的情景中，比如一个ScrollView内部包裹一个RecyclerView，那么就会产生滑动冲突，这个问题就需要你自己去解决。而如果使用NestedScrollView包裹RecyclerView，嵌套滑动天然支持，你无需做什么就可以实现前面想要实现的功能了。
-
-我们通常为RecyclerView增加一个Header和Footer的方法是通过定义不同的viewType来区分的，而如果使用NestedScrollView，我们完全可以把RecyclerView当成一个单独的控件，然后在其上面增加一个控件作为Header，在其下面增加一个控件作为Footer。
-
-虽然NestedScrollView内嵌RecyclerView和其他控件可以实现Header和Footer，但还是不推荐上面这种做法（建议还是直接使用RecyclerView自己添加Header和Footer），因为虽然NestedScrollView支持嵌套滑动，但是在实际应用中，嵌套滑动可能会带来其他的一些奇奇怪怪的副作用，Google 也推荐我们能不使用嵌套滑动就尽量不要使用。
-
-
-
-作者：Whyn
-链接：https://www.jianshu.com/p/f55abc60a879
-来源：简书
-著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
-
-
-
-
-
-
-
-
-Ripple效果
----
-
-个人非常喜欢的效果。相当于给点击事件加上了动态的赶脚。。。
-
-
-假设现在有一个`Button`的`selector`，我们想给这个`Button`加上`Ripple`效果，肿么办？ 
-新建一个`xml`文件，用`ripple`包裹`selector`，然后在`Button`的`backgroud`直接引用这个`xml`就好了。
-```xml
-<?xml version="1.0" encoding="utf-8"?>
-<ripple xmlns:android="http://schemas.android.com/apk/res/android"
-android:color="@color/whatever">
-<selector xmlns:android="http://schemas.android.com/apk/res/android"
-<item android:state_pressed="false" android:state_focused="true"
-android:drawable="@drawable/some_focused_blah"/>
-<item android:state_pressed="true" android:drawable="@drawable/some_pressed_blah"/>
-<item android:drawable="@android:color/whatever"/>
-</selector>
-</ripple>
-
-```
-但是很遗憾，`ripple`是5.0才有的，而且`support`包中没有实现该功能的扩展。
-`5.0`的这些效果还是无法在低版本上实现，包括一些`TextView`等样式，现在可以用大神的开源项目        
-[MaterialDesignLibrary](https://github.com/navasmdc/MaterialDesignLibrary)
-
-
-RecyclerView
----
-
-`ListView`的升级版，还有什么理由不去用呢？ 同样他也在`support v7`包中。
-```
-compile 'com.android.support:recyclerview-v7:21.+'  
-```
-通过`mRecyclerView.setLayoutManager(new LinearLayoutManager(this)); `设置为`LinearLayoutManager`来实现水平或者竖直
-方向的`ListView`。
-
-
-阴影
----
-
-通过对`View`设置`backgroud`后再添加`android:elevation="2dp"`来实现背景大小。
-
-
-
-[更多实例请看MaterialSample](https://github.com/CharonChui/MaterialSample.git)
-
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
diff --git "a/ArchitectureComponents/2.\351\233\206\346\210\220(\344\272\214).md" "b/ArchitectureComponents/2.\351\233\206\346\210\220(\344\272\214).md"
deleted file mode 100644
index 396665c9..00000000
--- "a/ArchitectureComponents/2.\351\233\206\346\210\220(\344\272\214).md"
+++ /dev/null
@@ -1,164 +0,0 @@
-2.集成(二)
-===
-
-
-首先在`Project`目录中的`build.gradle`中添加`google()`仓库(大部分项目可能都已经有了):   
-
-```
-allprojects {
-    repositories {
-        jcenter()
-        google()
-    }
-}
-```
-
-然后在`app`的`build.gradle`中添加对应的依赖,如:   
-
-```
-implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version"
-```
-如果想要使用`kotlin`开发的话，可以在后面加上`-ktx`后缀就可以了，如下:   
-```
-implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"
-```
-
-`Lifecycle`依赖:   
----
-
-`Lifecycle`依赖包括`LiveData`和`ViewModel`
-
-```
-dependencies {
-    def lifecycle_version = "1.1.1"
-
-    // ViewModel and LiveData
-    implementation "android.arch.lifecycle:extensions:$lifecycle_version"
-    // alternatively - just ViewModel
-    implementation "android.arch.lifecycle:viewmodel:$lifecycle_version" // use -ktx for Kotlin
-    // alternatively - just LiveData
-    implementation "android.arch.lifecycle:livedata:$lifecycle_version"
-    // alternatively - Lifecycles only (no ViewModel or LiveData).
-    //     Support library depends on this lightweight import
-    implementation "android.arch.lifecycle:runtime:$lifecycle_version"
-
-    annotationProcessor "android.arch.lifecycle:compiler:$lifecycle_version"
-    // alternately - if using Java8, use the following instead of compiler
-    implementation "android.arch.lifecycle:common-java8:$lifecycle_version"
-
-    // optional - ReactiveStreams support for LiveData
-    implementation "android.arch.lifecycle:reactivestreams:$lifecycle_version"
-
-    // optional - Test helpers for LiveData
-    testImplementation "android.arch.core:core-testing:$lifecycle_version"
-}
-```
-
-
-`Room`依赖:   
----
-
-`Room`的依赖包括`testing Room migrations`和`Room RxJava`
-
-```
-dependencies {
-    def room_version = "1.1.1"
-
-    implementation "android.arch.persistence.room:runtime:$room_version"
-    annotationProcessor "android.arch.persistence.room:compiler:$room_version"
-
-    // optional - RxJava support for Room
-    implementation "android.arch.persistence.room:rxjava2:$room_version"
-
-    // optional - Guava support for Room, including Optional and ListenableFuture
-    implementation "android.arch.persistence.room:guava:$room_version"
-
-    // Test helpers
-    testImplementation "android.arch.persistence.room:testing:$room_version"
-}
-
-```
-
-`Paging`依赖
----
-
-```
-dependencies {
-    def paging_version = "1.0.0"
-
-    implementation "android.arch.paging:runtime:$paging_version"
-
-    // alternatively - without Android dependencies for testing
-    testImplementation "android.arch.paging:common:$paging_version"
-
-    // optional - RxJava support, currently in release candidate
-    implementation "android.arch.paging:rxjava2:1.0.0-rc1"
-}
-```
-
-`Navigation`依赖
----
-
-> Navigation classes are already in the androidx.navigation package, but currently depend on Support Library 27.1.1, and associated Arch component versions. Version of Navigation with AndroidX dependencies will be released in the future.
-
-```
-dependencies {
-    def nav_version = "1.0.0-alpha02"
-
-    implementation "android.arch.navigation:navigation-fragment:$nav_version" // use -ktx for Kotlin
-    implementation "android.arch.navigation:navigation-ui:$nav_version" // use -ktx for Kotlin
-
-    // optional - Test helpers
-    androidTestImplementation "android.arch.navigation:navigation-testing:$nav_version" // use -ktx for Kotlin
-}
-```
-
-
-`Safe args`依赖
----
-
-想要使用`Safe args`，需要在`Project`顶层的`build.gradle`中配置以下路径:   
-```
-buildscript {
-    repositories {
-        google()
-    }
-    dependencies {
-        classpath "android.arch.navigation:navigation-safe-args-gradle-plugin:1.0.0-alpha02"
-    }
-}
-```
-并且在`app`或`module`中`build.gradle`中:   
-```
-apply plugin: "androidx.navigation.safeargs"
-```
-
-`WorkManager`依赖
----
-
-> WorkManager classes are already in the androidx.work package, but currently depend on Support Library 27.1, and associated Arch component versions. Version of WorkManager with AndroidX dependencies will be released in the future.
-
-
-```
-dependencies {
-    def work_version = "1.0.0-alpha03"
-
-    implementation "android.arch.work:work-runtime:$work_version" // use -ktx for Kotlin
-
-    // optional - Firebase JobDispatcher support
-    implementation "android.arch.work:work-firebase:$work_version"
-
-    // optional - Test helpers
-    androidTestImplementation "android.arch.work:work-testing:$work_version"
-}
-```
-
-
-[上一篇: 1.简介(一)](https://github.com/CharonChui/AndroidNote/blob/master/ArchitectureComponents/1.%E7%AE%80%E4%BB%8B(%E4%B8%80).md)
-[下一篇: 3.Lifecycle(三)](https://github.com/CharonChui/AndroidNote/blob/master/ArchitectureComponents/3.Lifecycle(%E4%B8%89).md)
-
-
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! `
\ No newline at end of file
diff --git "a/ArchitectureComponents/3.Lifecycle(\344\270\211).md" "b/ArchitectureComponents/3.Lifecycle(\344\270\211).md"
deleted file mode 100644
index b034723b..00000000
--- "a/ArchitectureComponents/3.Lifecycle(\344\270\211).md"
+++ /dev/null
@@ -1,175 +0,0 @@
-3.Lifecycle(三)
-===
-
-
-`Android`开发中，经常需要管理生命周期。举个栗子，我们需要获取用户的地址位置，当这个`Activity`在显示的时候，我们开启定位功能，然后实时获取到定位信息，当页面被销毁的时候，需要关闭定位功能。
-```java
-class MyLocationListener {
-    public MyLocationListener(Context context, Callback callback) {
-        // ...
-    }
-
-    void start() {
-        // connect to system location service
-    }
-
-    void stop() {
-        // disconnect from system location service
-    }
-}
-
-
-class MyActivity extends AppCompatActivity {
-    private MyLocationListener myLocationListener;
-
-    @Override
-    public void onCreate(...) {
-        myLocationListener = new MyLocationListener(this, (location) -> {
-            // update UI
-        });
-    }
-
-    @Override
-    public void onStart() {
-        super.onStart();
-        myLocationListener.start();
-        // manage other components that need to respond
-        // to the activity lifecycle
-    }
-
-    @Override
-    public void onStop() {
-        super.onStop();
-        myLocationListener.stop();
-        // manage other components that need to respond
-        // to the activity lifecycle
-    }
-}
-```
-
-上面的代码看起来还挺简单，但是当定位功能需要满足一些条件下才开启，那么会变得复杂多了。可能在执行`Activity`的`stop`方法时，定位的`start`方法才刚刚开始执行，比如如下代码，这样生命周期管理就变得很麻烦了。
-```java
-class MyActivity extends AppCompatActivity {
-    private MyLocationListener myLocationListener;
-
-    public void onCreate(...) {
-        myLocationListener = new MyLocationListener(this, location -> {
-            // update UI
-        });
-    }
-
-    @Override
-    public void onStart() {
-        super.onStart();
-        Util.checkUserStatus(result -> {
-            // what if this callback is invoked AFTER activity is stopped?
-            if (result) {
-                myLocationListener.start();
-            }
-        });
-    }
-
-    @Override
-    public void onStop() {
-        super.onStop();
-        myLocationListener.stop();
-    }
-}
-```
-
-`android.arch.lifecycle`包提供的类和接口可帮助您用简单和独立的方式解决这些问题。
-
-`Lifecycle`类是一个持有组件(`activity`或`fragment`)生命周期信息的类，其他对象可以观察该状态。`Lifecycle`使用两个重要的枚举部分来管理对应组件的生命周期的状态:   
-
-- `Event`:生命周期事件由系统来分发，这些事件对应于`Activity`和`Fragment`的生命周期函数。
-
-- `State`:`Lifecycle`对象所追踪的组件的当前状态   
-
-<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/lifecycle-states.png" width="100%" height="100%">
-
-
-```kotlin
-class MainActivity : AppCompatActivity() {
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        setContentView(R.layout.activity_main)
-        // lifecycle是LifecycleOwner接口的getLifecycle()方法得到的，从com.android.support:appcompat-v7:26.1.0开始activity和fragment都实现了该接口
-        lifecycle.addObserver(MyObserver()) 
-    }
-}
-```
-
-```kotlin
-class MyObserver : LifecycleObserver{
-    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
-    fun connectListener() {
-        Log.e("@@@", "connect")
-    }
-
-    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
-    fun disconnectListener() {
-        Log.e("@@@", "disconnect")
-    }
-}
-```
-上面的`lifecycle.addObserver(MyObserver()) `的完整写法应该是`aLifecycleOwner.getLifecycle().addObserver(new MyObserver())`而`aLifecycleOwner`一般是实现了`LifecycleOwner`的类，比如`Activity/Fragment`
-
-
-
-`LifecycleOwner`
---- 
-
-那什么是`LifecycleOwner`呢？实现`LifecycleOwner`接口就表示这是个有生命周期的类，他有一个`getLifecycle ()`方法是必须实现的。   
-
-对于前面提到的监听位置的例子。可以把`MyLocationListener`实现`LifecycleObserver`,然后在`Lifecycle（Activity／Fragment）`的`onCreate`方法中初始化。这样`MyLocationListener`就能自行处理生命周期带来的问题。
-
-
-
-从`Support Library 26.1.0`开始`Activity／Fragment`已经实现了`LifecycleOwner`接口。
-如果想在自定义的类中实现`LifecyclerOwner`，就需要用到[LifecycleRegistry](https://developer.android.com/reference/android/arch/lifecycle/LifecycleRegistry)类,并且需要自行发送`Event`:  
-
-```java
-public class MyActivity extends Activity implements LifecycleOwner {
-    private LifecycleRegistry mLifecycleRegistry;
-
-    @Override
-    protected void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-
-        mLifecycleRegistry = new LifecycleRegistry(this);
-        mLifecycleRegistry.markState(Lifecycle.State.CREATED);
-    }
-
-    @Override
-    public void onStart() {
-        super.onStart();
-        mLifecycleRegistry.markState(Lifecycle.State.STARTED);
-    }
-
-    @NonNull
-    @Override
-    public Lifecycle getLifecycle() {
-        return mLifecycleRegistry;
-    }
-}
-```
-
-
-`Lifecycles`的最佳建议:   
-
-- 保持`UI Controllers（Activity／Fragment）`中代码足够简洁。一定不能包含如何获取数据的代码，要通过`ViewModel`获取`LiveData`形式的数据。
-- 用数据驱动`UI`，`UI`的职责就是根据数据改变显示的内容，并且把用户操作`UI`的行为传递给`ViewModel`。
-- 把业务逻辑相关的代码放到`ViewModel`中，把`ViewModel`看成是链接`UI`和`App`其他部分的纽带。但`ViewModel`不能直接获取数据，要通过调用其他类来获取数据。
-- 使用`DataBinding`来简化`View`（布局文件）和`UI Controllers（Activity／Fragment）`之间的代码
-- 如果布局本身太过复杂，可以考虑创建一个`Presenter`类来处理UI相关的改变。虽然这么做会多写很多代码，但是对于保持`UI`的简介和可测试性是有帮助的。
-- 不要在`ViewModel`中持有任何`View／Activity`的`context`。否则会造成内存泄露。
-
-
-[上一篇: 2.集成(二)](https://github.com/CharonChui/AndroidNote/blob/master/ArchitectureComponents/2.%E9%9B%86%E6%88%90(%E4%BA%8C).md)
-[下一篇: 4.LiveData(四)](https://github.com/CharonChui/AndroidNote/blob/master/ArchitectureComponents/4.LiveData(%E5%9B%9B).md)
-
-
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! `
\ No newline at end of file
diff --git "a/ArchitectureComponents/4.LiveData(\345\233\233).md" "b/ArchitectureComponents/4.LiveData(\345\233\233).md"
deleted file mode 100644
index 143fdc3f..00000000
--- "a/ArchitectureComponents/4.LiveData(\345\233\233).md"
+++ /dev/null
@@ -1,315 +0,0 @@
-4.LiveData(四)
-===
-
-> LiveData is an observable data holder class. Unlike a regular observable, LiveData is lifecycle-aware, meaning it respects the lifecycle of other app components, such as activities, fragments, or services. This awareness ensures LiveData only updates app component observers that are in an active lifecycle state.
-
-
-`LiveData`是一种持有可被观察数据的类。和其他可被观察的类不同的是，`LiveData`是有生命周期感知能力的，这意味着它可以在`activities`,`fragments`,或者`services`生命周期是活跃状态时更新这些组件。那么什么是活跃状态呢？上篇文章中提到的`STARTED`和`RESUMED`就是活跃状态，只有在这两个状态下`LiveData`是会通知数据变化的。
-
-要想使用`LiveData`（或者这种有可被观察数据能力的类）就必须配合实现了`LifecycleOwner`的对象使用。在这种情况下，当对应的生命周期对象`DESTROYED`时，才能移除观察者。这对`Activity`或者`Fragment`来说显得尤为重要，因为他们可以在生命周期结束的时候立刻解除对数据的订阅，从而避免内存泄漏等问题。
-
-
-
-
-使用`LiveData`的优点:   
-
-- `UI`和实时数据保持一致 因为`LiveData`采用的是观察者模式，这样一来就可以在数据发生改变时获得通知，更新`UI`。
-- 避免内存泄漏,观察者被绑定到组件的生命周期上，当被绑定的组件销毁（`destory`）时，观察者会立刻自动清理自身的数据。
-- 不会再产生由于`Activity`处于`stop`状态而引起的崩溃 例如:当`Activity`处于后台状态时，是不会收到`LiveData`的任何事件的。
-- 不需要再解决生命周期带来的问题`LiveData`可以感知被绑定的组件的生命周期，只有在活跃状态才会通知数据变化。
-- 实时数据刷新,当组件处于活跃状态或者从不活跃状态到活跃状态时总是能收到最新的数据
-- 解决`Configuration Change`问题,在屏幕发生旋转或者被回收再次启动，立刻就能收到最新的数据。
-- 数据共享,如果对应的`LiveData`是单例的话，就能在`app`的组件间分享数据。
-
-
-
-使用`LiveData`:      
-
-- 创建一个持有某种数据类型的`LiveData`(通常是在`ViewModel`中)
-- 创建一个定义了`onChange()`方法的观察者。这个方法是控制`LiveData`中数据发生变化时，采取什么措施 (比如更新界面)。通常是在`UI Controller`(`Activity/Fragment`)中创建这个观察者。
-- 通过`observe()`方法连接观察者和`LiveData`。`observe()`方法需要携带一个`LifecycleOwner`类。这样就可以让观察者订阅`LiveData`中的数据，实现实时更新。
-
-
-创建`LiveData`对象
---- 
-
-`LiveData`是一个数据的包装。具体的包装对象可以是任何数据，包括集合（比如`List`）。`LiveData`通常在`ViewModel`中创建，然后通过`getter`方法获取。具体可以看一下代码:   
-```java
-public class NameViewModel extends ViewModel {
-
-// Create a LiveData with a String
-private MutableLiveData<String> mCurrentName;
-
-    public MutableLiveData<String> getCurrentName() {
-        if (mCurrentName == null) {
-            mCurrentName = new MutableLiveData<String>();
-        }
-        return mCurrentName;
-    }
-
-// Rest of the ViewModel...
-}
-```
-
-观察`LiveData`中的数据
----
-
-
-通常情况下都是在组件的`onCreate()`方法中开始观察数据，原因有以下两点:   
-
-- 系统会多次调用`onResume()`方法
-- 确保`Activity/Fragment`在处于活跃状态时立刻可以展示数据。
-
-```java
-public class NameActivity extends AppCompatActivity {
-
-    private NameViewModel mModel;
-
-    @Override
-    protected void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-
-        // Other code to setup the activity...
-
-        // Get the ViewModel.
-        mModel = ViewModelProviders.of(this).get(NameViewModel.class);
-
-
-        // Create the observer which updates the UI.
-        final Observer<String> nameObserver = new Observer<String>() {
-            @Override
-            public void onChanged(@Nullable final String newName) {
-                // Update the UI, in this case, a TextView.
-                mNameTextView.setText(newName);
-            }
-        };
-
-        // Observe the LiveData, passing in this activity as the LifecycleOwner and the observer.
-        mModel.getCurrentName().observe(this, nameObserver);
-    }
-}
-```
-
-更新`LiveData`对象
----
-
-
-如果想要在`UI Controller`中改变`LiveData`中的值呢？（比如点击某个`Button`把性别从男设置成女）。`LiveData`并没有提供这样的功能，但是`Architecture Component`提供了`MutableLiveData`这样一个类，可以通过`setValue(T)`和`postValue(T)`方法来修改存储在`LiveData`中的数据。`MutableLiveData`是`LiveData`的一个子类，从名称上也能看出这个类的作用。举个直观点的例子:  
-
-```java
-mButton.setOnClickListener(new OnClickListener() {
-    @Override
-    public void onClick(View v) {
-        String anotherName = "John Doe";
-        mModel.getCurrentName().setValue(anotherName);
-    }
-})
-```
-调用`setValue()`方法就可以把`LiveData`中的值改为`John Doe`。同样通过这种方法修改`LiveData`中的值同样会触发所有对这个数据感兴趣的类。那么`setValue()`和`postValue()`有什么不同呢？区别就是`setValue()`只能在主线程中调用，而`postValue()`可以在子线程中调用。
-
-
-`Room`和`LiveData`配合使用
---- 
-
-`Room`可以返回`LiveData`的数据类型。这样对数据库中的任何改动都会被传递出去。这样修改完数据库就能获取最新的数据，减少了主动获取数据的代码。
-
-继承`LiveData`扩展功能
----
-
-`LiveData`的活跃状态包括:`STARTED`或者`RESUMED`两种状态。那么如何在活跃状态下把数据传递出去呢？下面是示例代码:  
-
-```java
-public class StockLiveData extends LiveData<BigDecimal> {
-    private StockManager mStockManager;
-
-    private SimplePriceListener mListener = new SimplePriceListener() {
-        @Override
-        public void onPriceChanged(BigDecimal price) {
-            setValue(price);
-        }
-    };
-
-    public StockLiveData(String symbol) {
-        mStockManager = new StockManager(symbol);
-    }
-
-    @Override
-    protected void onActive() {
-        mStockManager.requestPriceUpdates(mListener);
-    }
-
-    @Override
-    protected void onInactive() {
-        mStockManager.removeUpdates(mListener);
-    }
-}
-```
-
-上面有三个重要的方法:   
-
-- The onActive() method is called when the LiveData object has an active observer. This means you need to start observing the stock price updates from this method.
-- The onInactive() method is called when the LiveData object doesn't have any active observers. Since no observers are listening, there is no reason to stay connected to the StockManager service.
-- The setValue(T) method updates the value of the LiveData instance and notifies any active observers about the change.
-
-可以像下面这样使用`StockLiveData`:   
-```java
-public class MyFragment extends Fragment {
-    @Override
-    public void onActivityCreated(Bundle savedInstanceState) {
-        super.onActivityCreated(savedInstanceState);
-        LiveData<BigDecimal> myPriceListener = ...;
-        myPriceListener.observe(this, price -> {
-            // Update the UI.
-        });
-    }
-}
-```
-上面`observe()`方法中的第一个参数传递的是`fragment`的实例，该`fragment`实现了`LifecycleOwner`接口。这样做是为了将`observer`和`Lifecycle`对象绑定到一起，这意味着:      
-- 如果当前的`Lifecycle`对象不是出于活跃期，就算`value`值有改变也不会回调到`observer`中
-- 在`Lifecycle`对象销毁后哦，`observer`对象也会自动移除
-
-实际上`LiveData`对象是适应生命周期也就意味着你需要在多个`activities`,`fragments`和`services`中进行共享，所以通常我们会将`LiveData`的示例设计成单例的:   
-```java
-public class StockLiveData extends LiveData<BigDecimal> {
-    private static StockLiveData sInstance;
-    private StockManager mStockManager;
-
-    private SimplePriceListener mListener = new SimplePriceListener() {
-        @Override
-        public void onPriceChanged(BigDecimal price) {
-            setValue(price);
-        }
-    };
-
-    @MainThread
-    public static StockLiveData get(String symbol) {
-        if (sInstance == null) {
-            sInstance = new StockLiveData(symbol);
-        }
-        return sInstance;
-    }
-
-    private StockLiveData(String symbol) {
-        mStockManager = new StockManager(symbol);
-    }
-
-    @Override
-    protected void onActive() {
-        mStockManager.requestPriceUpdates(mListener);
-    }
-
-    @Override
-    protected void onInactive() {
-        mStockManager.removeUpdates(mListener);
-    }
-}
-```
-这样就可以在`fragment`中像如下这样使用:   
-```java
-public class MyFragment extends Fragment {
-    @Override
-    public void onActivityCreated(Bundle savedInstanceState) {
-        StockLiveData.get(getActivity()).observe(this, price -> {
-            // Update the UI.
-        });
-    }
-}
-```
-
-转换LiveData
----
-
-你可能有时会在`LiveData`分发给`observers`之前想要修改一下存储在`LiveData`中的值，或者你想根据当前的值进行修改返回另一个值。`Lifecycle`提供了`Transformations`类来通过里面的`helper`方法解决这种问题。 
-
-- `Transformations.map()`
-
-可以将`LiveData`中的数据进行改变。
-
-
-```java
-LiveData<User> userLiveData = ...;
-LiveData<String> userName = Transformations.map(userLiveData, user -> {
-    user.name + " " + user.lastName
-});
-```
-将`LiveData`中的`User`数据转换成`String`  
-
-
-- `Transformations.switchMap()`
-
-```java
-private LiveData<User> getUser(String id) {
-  ...;
-}
-
-LiveData<String> userId = ...;
-LiveData<User> user = Transformations.switchMap(userId, id -> getUser(id) );
-```
-
-
-和上面的`map()`方法很像。区别在于传递给`switchMap()`的函数必须返回`LiveData`对象。
-和`LiveData`一样,`Transformation`也可以在观察者的整个生命周期中存在。只有在观察者处于观察`LiveData`状态时,`Transformation`才会运算。`Transformation`是延迟运算的（`calculated lazily`），而生命周期感知的能力确保不会因为延迟发生任何问题。
-
-如果在`ViewModel`对象的内部需要一个`Lifecycle`对象，那么使用`Transformation`是一个不错的方法。举个例子:假如有个`UI`组件接受输入的地址，返回对应的邮政编码。那么可以 实现一个`ViewModel`和这个组件绑定:   
-```java
-class MyViewModel extends ViewModel {
-    private final PostalCodeRepository repository;
-    public MyViewModel(PostalCodeRepository repository) {
-       this.repository = repository;
-    }
-
-    private LiveData<String> getPostalCode(String address) {
-       // DON'T DO THIS
-       return repository.getPostCode(address);
-    }
-}
-
-```
-
-看代码中的注释，有个`// DON'T DO THIS`(不要这么干),这是为什么？有一种情况是如果`UI`组件被回收后又被重新创建，那么又会触发一次`repository.getPostCode(address)`询，而不是重用上次已经获取到的查询。那么应该怎样避免这个问题呢？看一下下面的代码:  
-
-```java
-class MyViewModel extends ViewModel {
-    private final PostalCodeRepository repository;
-    private final MutableLiveData<String> addressInput = new MutableLiveData();
-    public final LiveData<String> postalCode =
-            Transformations.switchMap(addressInput, (address) -> {
-                return repository.getPostCode(address);
-             });
-
-  public MyViewModel(PostalCodeRepository repository) {
-      this.repository = repository
-  }
-
-  private void setInput(String address) {
-      addressInput.setValue(address);
-  }
-}
-```
-
-`postalCode`变量的修饰符是`public`和`final`，因为这个变量的是不会改变的。哎？不会改变？那我输入不同的地址还总返回相同邮编？先打住，`postalCode`这个变量存在的作用是把输入的`addressInput`转换成邮编，那么只有在输入变化时才会调用`repository.getPostCode()`方法。这就好比你用`final`来修饰一个数组，虽然这个变量不能再指向其他数组，但是数组里面的内容是可以被修改的。绕来绕去就一点:当输入是相同的情况下，用了`switchMap()`可以减少没有必要的请求。并且同样，只有在观察者处于活跃状态时才会运算并将结果通知观察者。
-
-
-
-
-合并多个`LiveData`中的数据
----
-
-`MediatorLiveData`是`LiveData`的子类，可以通过`MediatorLiveData`合并多个`LiveData`来源的数据。同样任意一个来源的`LiveData`数据发生变化，`MediatorLiveData`都会通知观察他的对象。说的有点抽象，举个例子。比如`UI`接收来自本地数据库和网络数据，并更新相应的`UI`。可以把下面两个`LiveData`加入到`MeidatorLiveData`中:   
-
-- 关联数据库的`LiveData`
-- 关联联网请求的`LiveData`
-相应的`UI`只需要关注`MediatorLiveData`就可以在任意数据来源更新时收到通知。
-
-
-
-[上一篇: 3.Lifecycle(三)](https://github.com/CharonChui/AndroidNote/blob/master/ArchitectureComponents/3.Lifecycle(%E4%B8%89).md)
-[下一篇: 5.ViewModel(五)](https://github.com/CharonChui/AndroidNote/blob/master/ArchitectureComponents/5.ViewModel(%E4%BA%94).md)
-
-
-
-
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! `
\ No newline at end of file
diff --git "a/ArchitectureComponents/5.ViewModel(\344\272\224).md" "b/ArchitectureComponents/5.ViewModel(\344\272\224).md"
deleted file mode 100644
index 98ea2f37..00000000
--- "a/ArchitectureComponents/5.ViewModel(\344\272\224).md"
+++ /dev/null
@@ -1,138 +0,0 @@
-5.ViewModel(五)
-===
-
-`ViewModel`是用来存储`UI`层的数据，以及管理对应的数据，当数据修改的时候，可以马上刷新`UI`。
-
-`Android`系统提供控件，比如`Activity`和`Fragment`，这些控件都是具有生命周期方法，这些生命周期方法被系统调用。
-
-当这些控件被销毁或者被重建的时候，如果数据保存在这些对象中，那么数据就会丢失。比如在一个界面，保存了一些用户信息，当界面重新创建的时候，就需要重新去获取数据。当然了也可以使用控件自动再带的方法，在`onSaveInstanceState`方法中保存数据，在`onCreate`中重新获得数据，但这仅仅在数据量比较小的情况下。如果数据量很大，这种方法就不能适用了。
-
-另外一个问题就是，经常需要在`Activity`中加载数据，这些数据可能是异步的，因为获取数据需要花费很长的时间。那么`Activity`就需要管理这些数据调用，否则很有可能会产生内存泄露问题。最后需要做很多额外的操作，来保证程序的正常运行。
-
-同时`Activity`不仅仅只是用来加载数据的，还要加载其他资源，做其他的操作，最后`Activity`类变大，就是我们常讲的上帝类。也有不少架构是把一些操作放到单独的类中，比如`MVP`就是这样，创建相同类似于生命周期的函数做代理，这样可以减少`Activity`的代码量，但是这样就会变得很复杂，同时也难以测试。
-
-`AAC`中提供`ViewModel`可以很方便的用来管理数据。我们可以利用它来管理`UI`组件与数据的绑定关系。`ViewModel`提供自动绑定的形式，当数据源有更新的时候，可以自动立即的更新`UI`。   
-
-
-实现`ViewModel`
----
-
-```java
-public class MyViewModel extends ViewModel {
-    private MutableLiveData<List<User>> users;
-    public LiveData<List<User>> getUsers() {
-        if (users == null) {
-            users = new MutableLiveData<List<User>>();
-            loadUsers();
-        }
-        return users;
-    }
-
-    private void loadUsers() {
-        // Do an asynchronous operation to fetch users.
-    }
-}
-```
-
-然后可以再`activity`像如下这样获取数据:   
-```java
-public class MyActivity extends AppCompatActivity {
-    public void onCreate(Bundle savedInstanceState) {
-        // Create a ViewModel the first time the system calls an activity's onCreate() method.
-        // Re-created activities receive the same MyViewModel instance created by the first activity.
-
-        MyViewModel model = ViewModelProviders.of(this).get(MyViewModel.class);
-        model.getUsers().observe(this, users -> {
-            // update UI
-        });
-    }
-}
-```
-
-在`activity`重建后，它会收到在第一个`activity`中创建的同一个`MyViewModel`实例，当所属的`activity`销毁后，`framework`会调用`ViewModel`对象的`onCleared()`
-方法来清除资源。
-
-
-`ViewModel`的生命周期
----
-
-`ViewModel`在获取`ViewModel`对象时会通过`ViewModelProvider`的传递来绑定对应的声明周期。   
-`ViewModel`只有在`Activity finish`或者`Fragment detach`之后才会销毁。
-
-
-<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/viewmodel-lifecycle.png" width="100%" height="100%">
-
-
-
-在`Fragments`间分享数据
----
-
-有时候一个`Activity`中的两个或多个`Fragment`需要分享数据或者相互通信，这样就会带来很多问题，比如数据获取，相互确定生命周期。
-
-使用`ViewModel`可以很好的解决这个问题。假设有这样两个`Fragment`，一个`Fragment`提供一个列表，另一个`Fragment`提供点击每个`item`现实的详细信息。
-
-
-```java
-public class SharedViewModel extends ViewModel {
-    private final MutableLiveData<Item> selected = new MutableLiveData<Item>();
-
-    public void select(Item item) {
-        selected.setValue(item);
-    }
-
-    public LiveData<Item> getSelected() {
-        return selected;
-    }
-}
-
-public class MasterFragment extends Fragment {
-    private SharedViewModel model;
-    public void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-        model = ViewModelProviders.of(getActivity()).get(SharedViewModel.class);
-        itemSelector.setOnClickListener(item -> {
-            model.select(item);
-        });
-    }
-}
-
-public class DetailFragment extends LifecycleFragment {
-    public void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-        SharedViewModel model = ViewModelProviders.of(getActivity()).get(SharedViewModel.class);
-        model.getSelected().observe(this, { item ->
-           // update UI
-        });
-    }
-}
-```
-
-两个`Fragment`都是通过`getActivity()`来获取`ViewModelProvider`。这意味着两个`Activity`都是获取的属于同一个`Activity`的同一个`ShareViewModel`实例。
-这样做优点如下:   
-
-- `Activity`不需要写任何额外的代码，也不需要关心`Fragment`之间的通信。
-- `Fragment`不需要处理除`SharedViewModel`以外其他的代码。这两个`Fragment`不需要知道对方是否存在。
-- `Fragment`的生命周期不会相互影响
-
-
-
-
-`ViewModel`和`SavedInstanceState`对比
----
-
-`ViewModel`使得在`configuration change`（旋转屏幕等）保存数据变的十分方便，但是这不能用于应用被系统杀死时持久化数据。举个简单的例子，有一个界面展示国家信息。
-不应该把整个国家信息放到`SavedInstanceState`里，而是把国家对应的`id`放到`SavedInstanceState`，等到界面恢复时，再通过`id`去获取详细的信息。这些详细的信息应该被存放在数据库中。
-
-
-
-<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/viewModel_saveinstancestate.png" width="100%" height="100%">
-
-
-[上一篇: 4.LiveData(四)](https://github.com/CharonChui/AndroidNote/blob/master/ArchitectureComponents/4.LiveData(%E5%9B%9B).md)
-[下一篇: 6.Room(六)](https://github.com/CharonChui/AndroidNote/blob/master/ArchitectureComponents/6.Room(%E5%85%AD).md)
-
-
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! `
\ No newline at end of file
diff --git "a/Jetpack/Jetpack\347\256\200\344\273\213.md" "b/Jetpack/Jetpack\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..e29d72c2
--- /dev/null
+++ "b/Jetpack/Jetpack\347\256\200\344\273\213.md"
@@ -0,0 +1,161 @@
+# Jetpack简介
+
+JetPack是Google推出的一些库的集合。是Android基础支持库SDK以外的部分。包含了组件、工具、架构方案等...开发者可以自主按需选择接入具体的哪个库。
+
+## 背景 
+
+### Support库
+
+早之前的Android更新迭代是，所有的功能更新都是跟随着每一个特定的Android版本所发布的。
+例如: 
+- Fragment是在Android 3.0更新的。
+- Material Design组件是在Android 5.0上更新的
+但是由于Android用户庞大，每一次Android更新都无法覆盖所有用户的，同时因为手机厂商众多，但支持有限，也无法为自己生产的所有设备保持迭代到最新的Android版本，所以用户所持有的设备上Android版本是层次不齐的。
+从技术的角度来说，因为用户的设备版本不一致，导致Android工程师在维护项目的时候，会遇到很多难以解决的问题。为了解决这些由于Android版本不一致而出现的兼容性问题，Google推出了Support库。
+
+Support库是针对Framework API的补充，Framework API跟随每一个Android版本所发布，和设备具有强关联性，Support API是开发者自主集成的，最终会包含在我们所发布的应用中，这样我们就可以在最新的Android版本上进行应用的开发，同时使用Support API解决各种潜在的兼容性问题，帮助开发者在不同Android版本的设备上实现行为一致的工作代码。
+
+### Support 库的弊端
+最早的Support库发布于2011年，版本号为：android.support.v4，也就是我们所熟知的v4库，2013年在v4的基础上，Android团队发布了v7库，版本号为：android.support.v7，之后还发布了用于特定场景的v8、v13、v14、v17。    
+如果是前几年刚开始学习Android的同学们，一定都对这些奇怪的数字很疑惑，4、7、8、13、14、17 到底都是什么意思？   
+拿第一代支持库v4举例，最初本意是指：该支持库最低可以支持到API 4(Android 1.4)的设备，v7表示最低支持 API 7(Android 2.1)的设备，但随着Android版本的持续更新，API 4以及API 7的设备早就淘汰了。在2017年7月Google将所有支持库的最低API支持版本提高到了API 14(Android 4.0)，但由于包名无法修改，所以还是沿用之前的v4、v7命名标准，所以就出现了Support库第一个无法解决的问题：版本增长混乱。
+
+与此同时Support库还面临一个非常严峻的问题：架构设计本身导致的严重依赖问题。最早的Support库是v4，v7是基于v4进行的补充，因为v4、v7太过庞大，功能集中，所以如果想要开发新的支持库，也只能在v4、v7的基础上进行二次开发，比方说我们后期常用的，RecyclerView、CardView等等。
+
+这样就会产生很严重的重复依赖的问题，在无论是使用官方库，还是第三方库的时候，我们都需要保持整个项目中Support库版本一致，我相信很多人都在这个问题上踩过坑，虽然还是有办法解决这个问题，但无形中增加了很多工作量。
+
+我们都知道“组合优于继承”这句话，但Support库在最初的架构设计上，却采用了重继承轻组合的方式，我猜这可能是因为开发Support库的人和开发Framework API的是同一批人有关，Framework API里有种各种继承逻辑，例如我们常用的 Activity、Fragment、View。
+
+虽然在后期Google尝试拆分Support库，例如推出了独立的支持库：support:design、support:customtabs等，但并不能从根源解决依赖的问题。
+
+### Android X
+从Goole IO 2017开始。Google开始推出Architecture Component,ORM库Room,用户生命周期管理的ViewModel/LiveData.
+Goole IO 2018将Support lib更名为androidx.将许多Google认为是正确的方案和实践集中起来。可以说AndroidX的出现就是为了解决长久以来Support库混乱的问题，你也可以把AndroidX理解为更强大的Support库。
+AndroidX将原有的Support库拆分为85个大大小小的支持库，抛弃了之前与API最低支持相关联的版本命名规范，重置为1.0.0，并且每一个库在之后都会按照严格的语义版本控制规则进行版本控制。
+同时通过组合依赖的方式，我们可以选择自己需要的组件库，而不是像Support一样全部依赖，一定程度上也减小了应用的体积。
+很重要的一点，就是它不会随着特定的Android版本而更新，它是由开发者自主控制，同时包含在我们所发布的应用程序中。
+
+
+以上种种，现在统称为JetPack.
+Jetpack的出现是为了彻底解决这两个致命的问题:   
+1. Support 库版本增长混乱
+2. Support 库重复依赖
+如果Jetpack仅仅是针对Support库的重构，那它并没有了不起的，因为这只是Google解决了它自身因为历史原因所产生的代码问题。
+更重要的是Jetpack为大家提供了一系列的最佳实践，包含：架构、数据处理、后台任务处理、动画、UI 各个方面，无需纠结于各种因为Android本身而出现的问题，而是让我们把更多的精力放在业务需求的实现上，这才是Jetpack真正了不起的地方。其最核心的出发点就是帮助开发者快速构建出稳定、高性能、测试友好同时向后兼容的APP。
+
+Jetpack相当于Google把自己的Android生态重新整理了一番。确立了Android未来的版图和大方向。
+
+## 组成部分
+
+前面讲到过，JetPack是一系列库和工具的集合，它更多是Google的一个提出的一个概念，或者说态度。
+并非所有的东西都是每年在IO大会上新推出的，它也包含了对现有基础库的整理和扩展。在大部分项目中其实我们都有用到JetPack的内容，也许你只是不知道而已。让我们以上帝视角来看看整个JetPack除了你熟悉的部分，还有哪些是你不熟悉但是听过的内容。看看他们都能做些什么事情。
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_jetpack.png)
+
+[Jetpack完整组件列表](https://developer.android.com/jetpack/androidx/explorer)
+
+### Foundation(基础组件)：
+基础组件提供了横向功能，例如向后兼容性、测试以及Kotlin语言的支持。它包含如下组件库: 
+- Android KTX：Android KTX 是一组 Kotlin 扩展程序，它优化了供Kotlin使用的Jetpack和Android平台的API。以更简洁、更愉悦、更惯用的方式使用Kotlin进行Android开发。
+- AppCompat：提供了一系列以AppCompat开头的API，以便兼容低版本的Android开发。Jetpack基础中的AppCompat库包含v7库中的所有组件([支持库软件包](https://developer.android.com/topic/libraries/support-library/packages#v7-appcompat))。 其中包括AppCompat，Cardview，GridLayout，MediaRouter，Palette，RecyclerView，Renderscript，Preferences，Leanback，Vector Drawable，Design，Custom选项卡等。此外，该库为材质设计用户界面提供了实现支持，这使得AppCompat对 开发人员。 以下是android应用程序的一些关键领域，这些领域很难构建，但是可以使用AppCompat库轻松进行设计： 一般都是为了兼容 Android L以下版本，来提供Material Design的效果: 
+    - Toolbar
+    - ContextCompat
+    - AppCompatDialog
+- annotation:注解，提升代码可读性，内置了Android中常用的注解
+- Multidex(多Dex处理)：为方法数超过 64K 的应用启用多 dex 文件。Security(安全)：按照安全最佳做法读写加密文件和共享偏好设置。
+- Test(测试)：用于单元和运行时界面测试的 Android 测试框架。
+
+### Architecture(架构组件)
+架构组件可帮助开发者设计稳健、可测试且易维护的应用。它包含如下组件库: 
+- Data Binding(数据绑定):数据绑定库是一种支持库，借助该库，可以使用声明式将布局中的界面组件绑定到应用中的数据源。
+- Lifecycles:方便管理Activity和Fragment生命周期，帮助开发者书写更轻量、易于维护的代码。
+- ViewModel：以生命周期感知的方式存储和管理与UI相关的数据。
+- LiveData:是一个可观察的数据持有者类。与常规observable不同，LiveData是有生命周期感知的。
+- Navigation:处理应用内导航所需的一切。
+- Paging：帮助开发者一次加载和显示小块数据。按需加载部分数据可减少网络带宽和系统资源的使用。
+- Room：Room持久性库在SQLite上提供了一个抽象层，帮助开发者更友好、流畅的访问SQLite数据库。
+- WorkManager：即使应用程序退出或设备重新启动，也可以轻松地调度预期将要运行的可延迟异步任务。
+- hilt:基于Dagger的Android依赖注入框架绑定View和Model
+- startup:自动处理依赖初始化
+- datastore:Preferences的替代类，支持异步、更加安全
+
+
+
+### Behavior(行为组件)
+行为组件可帮助开发者的应用与标准Android服务（如通知、权限、分享和Google助理）相集成。它包含如下组件库: 
+- CameraX：帮助开发者简化相机应用的开发工作。它提供一致且易于使用的 API 界面，适用于大多数 Android 设备，并可向后兼容至 Android 5.0（API 级别 21）。
+- DownloadManager下载管理器:可处理长时间运行的HTTP下载，并在出现故障或在连接更改和系统重新启动后重试下载。
+- Media & playback(媒体&播放)：用于媒体播放和路由（包括 Google Cast）的向后兼容 API。
+- Notifications(通知)：提供向后兼容的通知 API，支持 Wear 和 Auto。
+- Permissions(权限)：用于检查和请求应用权限的兼容性 API。
+- Preferences(偏好设置)：提供了用户能够改变应用的功能和行为能力。
+- Sharing(共享)：提供适合应用操作栏的共享操作。
+- Slices(切片)：创建可在应用外部显示应用数据的灵活界面元素。
+
+### UI(界面组件)
+大多数的UI组件其实都包含在基础组件中的appcompat中，这里是一些独立组件库存在的UI组件，界面组件可提供各类view和辅助程序，让应用不仅简单易用，还能带来愉悦体验。它包含如下组件库: 
+- drawerlayout:抽屉布局
+- recyclerview:可复用的滑动列表
+- constraintlayout:约束布局
+- compose*: Jetpack compose声明式UI
+- coordinatorlayout:顶层布局继承自Framelayout，可以实现子View之间的联动交互效果
+- swiperefreshlayout:下拉刷新布局
+- viewpager2:分页布局
+- Material Design Components * : MD组件
+- Animation & Transitions(动画&过度)：提供各类内置动画，也可以自定义动画效果。
+- Emoji(表情符号)：使用户在未更新系统版本的情况下也可以使用表情符号。
+    -  EmojiTextView
+    -  EmojiEditTExt
+    -  EmojiButton
+- Fragment：组件化界面的基本单位。
+- Layout(布局)：xml书写的界面布局或者使用Compose完成的界面。
+    用户界面结构（如应用程序的活动）由Layout定义。 它定义了View和ViewGroup对象。 可以通过两种方式创建View和ViewGroup：通过以XML声明UI元素或通过编写代码（即以编程方式）。 Jetpack的这一部分涵盖了一些最常见的布局，例如LinearLayout，RelativeLayout和全新的ConstraintLayout。 而且，官方的Jetpack布局文档提供了一些指导，以使用RecyclerView创建项目列表以及使用CardView创建卡布局。 用户可以看到一个视图。 EditView，TextView和Button是View的示例。 另一方面，ViewGroup是一个容器对象，它定义了View的布局结构，因此它是不可见的。 ViewGroup的示例是LinearLayout，RelativeLayout和ConstraintLayout。 
+- Palette(调色板)：从调色板中提取出有用的信息。
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/jetpack_compose.png?raw=true)
+
+[Android Jetpack Compose](https://developer.android.com/jetpack/compose)是2019 Google/IO大会上推出的一种声明式的UI开发框架，经过一年左右的演进，现在到了alpha阶段。Jetpack Compose是用于构建原生界面的新款Android工具包。它可简化并加快Android上的界面开发。使用更少的代码、强大的工具和直观的KotlinAPI，快速让应用生动而精彩，从此不再需要写xml，使用声明式的Compose函数来构建页面UI。
+
+Compose由androidx中的6个Maven组ID构成。每个组都包含一套特定用途的功能，并各有专属的版本说明。下表介绍了各个组及指向其版本说明的链接: 
+- compose.animation:在Jetpack Compose应用中构建动画，丰富用户的体验。
+- compose.compiler:借助Kotlin编译器插件，转换@Composable functions（可组合函数）并启用优化功能。
+- compose.foundation:使用现成可用的构建块编写Jetpack Compose应用，还可扩展Foundation以构建您自己的设计系统元素。
+- compose.material:使用现成可用的Material Design组件构建Jetpack Compose UI。这是更高层级的Compose入口点，旨在提供与www.material.io上描述的组件一致的组件。
+- compose.runtime:Compose的编程模型和状态管理的基本构建块，以及Compose编译器插件针对的核心运行时。
+- compose.ui:与设备互动所需的Compose UI的基本组件，包括布局、绘图和输入。
+```kotlin
+class MainActivity : AppCompatActivity() {
+    overridefun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContent {
+             Text("Hello, Android技术杂货铺")
+        }
+    }
+}
+```
+废弃部分: 
+- asynclayoutinflater:异步生成UI
+- localbroadcastmanager:本地广播
+- viewpager:使用vviewpager2
+- cardview:使用MaterialCardView替代
+
+
+## Jetpack的意义
+Jetpack里目前包含的内容，未来也会是Google大力维护和扩展的内容。对应开发者来说也是值得去学习使用的且相对无后顾之忧的。JetPack里没有的，除开一些优秀的第三方库，未来应该也会慢慢被新的API替代，逐渐边缘化，直至打上Deprecate注解。
+
+以当下的环境来说，要开发出一个完全摆脱JetPack的APP是很难做到的。但是反过来讲JetPack也远远没有到成熟的地步，目前也还存在亟待解决的问题，未来可以做的事情还有很多。
+
+关于使用的话，并不是所有库都建议使用，因为目前还有很多库在alpha版本。但是作为学习还是很有必要的，能给你日常的开发中多提供一些思路，这些是无可厚非的。
+
+
+
+
+
+## Jetpack库列表及集成
+
+[Jetpack各库版本及gradle集成使用](https://developer.android.com/jetpack/androidx/releases/activity)
+
+
+
+## 参考
+- [Jetpack Compose初体验 ](https://easyliu-ly.github.io/2020/12/12/android_jetpack/compose/)
diff --git "a/ArchitectureComponents/1.\347\256\200\344\273\213(\344\270\200).md" "b/Jetpack/architecture/1.\347\256\200\344\273\213.md"
similarity index 96%
rename from "ArchitectureComponents/1.\347\256\200\344\273\213(\344\270\200).md"
rename to "Jetpack/architecture/1.\347\256\200\344\273\213.md"
index 7716d3b9..5345872d 100644
--- "a/ArchitectureComponents/1.\347\256\200\344\273\213(\344\270\200).md"
+++ "b/Jetpack/architecture/1.\347\256\200\344\273\213.md"
@@ -1,4 +1,4 @@
-1.简介(一)
+1.简介
 ===
 
 应用开发者面临的常见问题
@@ -97,6 +97,8 @@ override fun onDestroy() {
 除了有可能引发内存泄漏的风险, 数据持久化也是一个经常困扰我们的问题.通常在屏幕旋转后,`UI`的对象都会被销毁重建,这将导致原来的对象数据不得不重新创建和获取,浪费资源的同时也会影响用户的体验.
 通常的解决方法是,通过`SavedInstanceState`来存取数据,但`SavedInstanceState`存储的数据一般比较小,且数据对象还是必须重新构建.   
 
+为了将代码解耦以应对日益膨胀的代码量，工程师在应用程序中引入了“架构”的概念。使之在不影响应用程序各模块组件间通信的同时，还能够保持模块的相对独立。这样不仅有利于后期维护，也有利于代码测试。
+
 
 
 上述两个问题可以通过使用`AAC`架构解决.
diff --git "a/Jetpack/architecture/10.DataStore\347\256\200\344\273\213.md" "b/Jetpack/architecture/10.DataStore\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..2b6cdb21
--- /dev/null
+++ "b/Jetpack/architecture/10.DataStore\347\256\200\344\273\213.md"
@@ -0,0 +1,205 @@
+# 10.DataStore简介
+
+Jetpack DataStore 是一种数据存储解决方案，允许您使用[协议缓冲区](https://developers.google.com/protocol-buffers)存储键值对或类型化对象。DataStore 使用 Kotlin 协程和 Flow 以异步、一致的事务方式存储数据。
+
+如果您当前在使用 [`SharedPreferences`](https://developer.android.com/reference/kotlin/android/content/SharedPreferences) 存储数据，请考虑迁移到 DataStore。
+
+**注意**：如果您需要支持大型或复杂数据集、部分更新或参照完整性，请考虑使用 [Room](https://developer.android.com/training/data-storage/room)，而不是 DataStore。DataStore 非常适合简单的小型数据集，不支持部分更新或参照完整性。
+
+## Preferences DataStore 和 Proto DataStore
+
+DataStore 提供两种不同的实现：Preferences DataStore 和 Proto DataStore。
+
+- **Preferences DataStore** 像SharedPreferences一样，以键值对的形式进行基本类型的数据存储。DataStore 基于 Flow 实现异步存储，避免因为阻塞主线程带来的ANR问题
+- **Proto DataStore** 基于Protobuf实现任意自定义类型的数据存储，需要定义Protobuf的IDL，但是可以保证类型安全的访问
+
+
+
+如需在您的应用中使用 Jetpack DataStore，请根据您要使用的实现向 Gradle 文件添加以下内容：
+
+```groovy
+// Preferences DataStore (SharedPreferences like APIs)
+dependencies {
+  implementation "androidx.datastore:datastore-preferences:1.0.0-beta01"
+
+  // optional - RxJava2 support
+  implementation "androidx.datastore:datastore-preferences-rxjava2:1.0.0-beta01"
+
+  // optional - RxJava3 support
+  implementation "androidx.datastore:datastore-preferences-rxjava3:1.0.0-beta01"
+}
+// Alternatively - use the following artifact without an Android dependency.
+dependencies {
+  implementation "androidx.datastore:datastore-preferences-core:1.0.0-beta01"
+}
+```
+
+
+
+
+
+Jetpack DataStore 是一种数据存储解决方案，允许您使用[协议缓冲区](https://developers.google.com/protocol-buffers)存储键值对或类型化对象。DataStore 使用 Kotlin 协程和 Flow 以异步、一致的事务方式存储数据。
+
+如果您当前在使用 [`SharedPreferences`](https://developer.android.com/reference/kotlin/android/content/SharedPreferences) 存储数据，请考虑迁移到 DataStore。
+
+**注意**：如果您需要支持大型或复杂数据集、部分更新或参照完整性，请考虑使用 [Room](https://developer.android.com/training/data-storage/room)，而不是 DataStore。DataStore 非常适合简单的小型数据集，不支持部分更新或参照完整性。
+
+## Preferences DataStore 和 Proto DataStore
+
+DataStore 提供两种不同的实现：Preferences DataStore 和 Proto DataStore。
+
+- **Preferences DataStore** 使用键存储和访问数据。此实现不需要预定义的架构，也不确保类型安全。
+- **Proto DataStore** 将数据作为自定义数据类型的实例进行存储。此实现要求您使用[协议缓冲区](https://developers.google.com/protocol-buffers)来定义架构，但可以确保类型安全。
+
+## 设置
+
+如需在您的应用中使用 Jetpack DataStore，请根据您要使用的实现向 Gradle 文件添加以下内容：
+
+[类型化](https://developer.android.com/topic/libraries/architecture/datastore#类型化-datastore)[偏好设置](https://developer.android.com/topic/libraries/architecture/datastore#偏好设置-datastore)
+
+```
+// Typed DataStore (Typed API surface, such as Proto)dependencies { implementation "androidx.datastore:datastore:1.0.0-beta01" // optional - RxJava2 support implementation "androidx.datastore:datastore-rxjava2:1.0.0-beta01" // optional - RxJava3 support implementation "androidx.datastore:datastore-rxjava3:1.0.0-beta01"}// Alternatively - use the following artifact without an Android dependency.dependencies { implementation "androidx.datastore:datastore-core:1.0.0-beta01"}
+```
+
+**注意**：如果您将 `datastore-preferences-core` 工件与 Proguard 搭配使用，就必须手动将 Proguard 规则添加到 `proguard-rules.pro` 文件中，以免您的字段遭到删除。您可以点击[此处](https://cs.android.com/androidx/platform/frameworks/support/+/androidx-main:datastore/datastore-preferences/proguard-rules.pro)查找必要的规则。
+
+## 使用 Preferences DataStore 存储键值对
+
+Preferences DataStore 实现使用 [`DataStore`](https://developer.android.com/reference/kotlin/androidx/datastore/core/DataStore) 和 [`Preferences`](https://developer.android.com/reference/kotlin/androidx/datastore/preferences/core/Preferences) 类将简单的键值对保留在磁盘上。
+
+### 创建 Preferences DataStore
+
+使用由 [`preferencesDataStore`](https://developer.android.com/reference/kotlin/androidx/datastore/preferences/package-summary#dataStore) 创建的属性委托来创建 `Datastore<Preferences>` 实例。在您的 Kotlin 文件顶层调用该实例一次，便可在应用的所有其余部分通过此属性访问该实例。这样可以更轻松地将 `DataStore` 保留为单例。此外，如果您使用的是 RxJava，请使用 [`RxPreferenceDataStoreBuilder`](https://developer.android.com/reference/kotlin/androidx/datastore/rxjava2/RxDataStoreBuilder)。必需的 `name` 参数是 Preferences DataStore 的名称。
+
+[Kotlin](https://developer.android.com/topic/libraries/architecture/datastore#kotlin)[Java](https://developer.android.com/topic/libraries/architecture/datastore#java)
+
+```
+// At the top level of your kotlin file:val Context.dataStore: DataStore<Preferences> by preferencesDataStore(name = "settings")
+```
+
+### 从 Preferences DataStore 读取内容
+
+由于 Preferences DataStore 不使用预定义的架构，因此您必须使用相应的键类型函数为需要存储在 `DataStore<Preferences>` 实例中的每个值定义一个键。例如，如需为 int 值定义一个键，请使用 [`intPreferencesKey()`](https://developer.android.com/reference/kotlin/androidx/datastore/preferences/core/package-summary#intPreferencesKey(kotlin.String))。然后，使用 [`DataStore.data`](https://developer.android.com/reference/kotlin/androidx/datastore/core/DataStore#data) 属性，通过 `Flow` 提供适当的存储值。
+
+[Kotlin](https://developer.android.com/topic/libraries/architecture/datastore#kotlin)[Java](https://developer.android.com/topic/libraries/architecture/datastore#java)
+
+```
+val EXAMPLE_COUNTER = intPreferencesKey("example_counter")val exampleCounterFlow: Flow<Int> = context.dataStore.data .map { preferences ->  // No type safety.  preferences[EXAMPLE_COUNTER] ?: 0}
+```
+
+### 将内容写入 Preferences DataStore
+
+Preferences DataStore 提供了一个 [`edit()`](https://developer.android.com/reference/kotlin/androidx/datastore/preferences/core/package-summary#edit) 函数，用于以事务方式更新 `DataStore` 中的数据。该函数的 `transform` 参数接受代码块，您可以在其中根据需要更新值。转换块中的所有代码均被视为单个事务。
+
+[Kotlin](https://developer.android.com/topic/libraries/architecture/datastore#kotlin)[Java](https://developer.android.com/topic/libraries/architecture/datastore#java)
+
+```
+suspend fun incrementCounter() { context.dataStore.edit { settings ->  val currentCounterValue = settings[EXAMPLE_COUNTER] ?: 0  settings[EXAMPLE_COUNTER] = currentCounterValue + 1 }}
+```
+
+## 使用 Proto DataStore 存储类型化的对象
+
+Proto DataStore 实现使用 DataStore 和[协议缓冲区](https://developers.google.com/protocol-buffers)将类型化的对象保留在磁盘上。
+
+### 定义架构
+
+Proto DataStore 要求在 `app/src/main/proto/` 目录的 proto 文件中保存预定义的架构。此架构用于定义您在 Proto DataStore 中保存的对象的类型。如需详细了解如何定义 proto 架构，请参阅 [protobuf 语言指南](https://developers.google.com/protocol-buffers/docs/proto3)。
+
+```
+syntax = "proto3"; option java_package = "com.example.application"; option java_multiple_files = true; message Settings {  int32 example_counter = 1; } 
+```
+
+**注意**：您的存储对象的类在编译时由 proto 文件中定义的 `message` 生成。请务必重新构建您的项目。
+
+### 创建 Proto DataStore
+
+创建 Proto DataStore 来存储类型化对象涉及两个步骤：
+
+1. 定义一个实现 `Serializer<T>` 的类，其中 `T` 是 proto 文件中定义的类型。此序列化器类会告知 DataStore 如何读取和写入您的数据类型。请务必为该序列化器添加默认值，以便在尚未创建任何文件时使用。
+2. 使用由 `dataStore` 创建的属性委托来创建 `DataStore<T>` 的实例，其中 `T` 是在 proto 文件中定义的类型。在您的 Kotlin 文件顶层调用该实例一次，便可在应用的所有其余部分通过此属性委托访问该实例。`filename` 参数会告知 DataStore 使用哪个文件存储数据，而 `serializer` 参数会告知 DataStore 第 1 步中定义的序列化器类的名称。
+
+[Kotlin](https://developer.android.com/topic/libraries/architecture/datastore#kotlin)[Java](https://developer.android.com/topic/libraries/architecture/datastore#java)
+
+```
+object SettingsSerializer : Serializer<Settings> { override val defaultValue: Settings = Settings.getDefaultInstance() override suspend fun readFrom(input: InputStream): Settings {  try {   return Settings.parseFrom(input)  } catch (exception: InvalidProtocolBufferException) {   throw CorruptionException("Cannot read proto.", exception)  } } override suspend fun writeTo(  t: Settings,  output: OutputStream) = t.writeTo(output)}val Context.settingsDataStore: DataStore<Settings> by dataStore( fileName = "settings.pb", serializer = SettingsSerializer)
+```
+
+### 从 Proto DataStore 读取内容
+
+使用 `DataStore.data` 显示所存储对象中相应属性的 `Flow`。
+
+[Kotlin](https://developer.android.com/topic/libraries/architecture/datastore#kotlin)[Java](https://developer.android.com/topic/libraries/architecture/datastore#java)
+
+```
+val exampleCounterFlow: Flow<Int> = context.settingsDataStore.data .map { settings ->  // The exampleCounter property is generated from the proto schema.  settings.exampleCounter }
+```
+
+### 将内容写入 Proto DataStore
+
+Proto DataStore 提供了一个 [`updateData()`](https://developer.android.com/reference/kotlin/androidx/datastore/DataStore#updatedata) 函数，用于以事务方式更新存储的对象。`updateData()` 为您提供数据的当前状态，作为数据类型的一个实例，并在原子读-写-修改操作中以事务方式更新数据。
+
+[Kotlin](https://developer.android.com/topic/libraries/architecture/datastore#kotlin)[Java](https://developer.android.com/topic/libraries/architecture/datastore#java)
+
+```
+suspend fun incrementCounter() { context.settingsDataStore.updateData { currentSettings ->  currentSettings.toBuilder()   .setExampleCounter(currentSettings.exampleCounter + 1)   .build()  }}
+```
+
+## 在同步代码中使用 DataStore
+
+**注意**：请尽可能避免在 DataStore 数据读取时阻塞线程。阻塞界面线程可能会导致 [ANR](https://developer.android.com/topic/performance/vitals/anr) 或界面卡顿，而阻塞其他线程可能会导致[死锁](https://en.wikipedia.org/wiki/Deadlock)。
+
+DataStore 的主要优势之一是异步 API，但可能不一定始终能将周围的代码更改为异步代码。如果您使用的现有代码库采用同步磁盘 I/O，或者您的依赖项不提供异步 API，就可能出现这种情况。
+
+Kotlin 协程提供 [`runBlocking()`](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/run-blocking.html) 协程构建器，以帮助消除同步与异步代码之间的差异。您可以使用 `runBlocking()` 从 DataStore 同步读取数据。RxJava 在 `Flowable` 上提供阻塞方法。以下代码会阻塞发起调用的线程，直到 DataStore 返回数据：
+
+[Kotlin](https://developer.android.com/topic/libraries/architecture/datastore#kotlin)[Java](https://developer.android.com/topic/libraries/architecture/datastore#java)
+
+```
+val exampleData = runBlocking { context.dataStore.data.first() }
+```
+
+对界面线程执行同步 I/O 操作可能会导致 ANR 或界面卡顿。您可以通过从 DataStore 异步预加载数据来减少这些问题：
+
+[Kotlin](https://developer.android.com/topic/libraries/architecture/datastore#kotlin)[Java](https://developer.android.com/topic/libraries/architecture/datastore#java)
+
+```
+override fun onCreate(savedInstanceState: Bundle?) {  lifecycleScope.launch {    context.dataStore.data.first()    // You should also handle IOExceptions here.  }}
+```
+
+这样，DataStore 可以异步读取数据并将其缓存在内存中。以后使用 `runBlocking()` 进行同步读取的速度可能会更快，或者如果初始读取已经完成，可能也可以完全避免磁盘 I/O 操作。
+
+
+
+
+
+
+
+
+
+
+
+https://developer.android.com/topic/libraries/architecture/datastore#typed-datastore
+
+https://android-developers.googleblog.com/2020/09/prefer-storing-data-with-jetpack.html
+
+
+https://blog.csdn.net/zzw0221/article/details/109274610
+
+SharedPreferences 有着许多缺陷: 看起来可以在 UI 线程安全调用的同步 API 其实并不安全、没有提示错误的机制、缺少事务 API 等等。DataStore 是 SharedPreferences 的替代方案，它解决了 Shared Preferences 的绝大部分问题。DataStore 包含使用 Kotlin 协程和 Flow 实现的完全异步 API，可以处理数据迁移、保证数据一致性，并且可以处理数据损坏。
+
+https://blog.csdn.net/weixin_42324979/article/details/112650189?utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-3.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-3.control
+
+
+
+缺点:  
+
+- 目前Jetpack Security没有支持DataStore，所以不能像SharedPreference一样支持加密
+- 不能安全的进行IPC，这点相对于SharedPreferences没有提升，有较强IPC需求的话首选MMKV
+- 使用PB进行序列化时需要额外定义IDL，这会产生一定工作量
+  
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/Jetpack/architecture/11.Hilt\347\256\200\344\273\213.md" "b/Jetpack/architecture/11.Hilt\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..38ba0a7e
--- /dev/null
+++ "b/Jetpack/architecture/11.Hilt\347\256\200\344\273\213.md"
@@ -0,0 +1,16 @@
+# 11.Hilt简介
+
+
+
+
+
+https://zhuanlan.zhihu.com/p/335631378
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! `
\ No newline at end of file
diff --git "a/Jetpack/architecture/12.Navigation\347\256\200\344\273\213.md" "b/Jetpack/architecture/12.Navigation\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..18a39661
--- /dev/null
+++ "b/Jetpack/architecture/12.Navigation\347\256\200\344\273\213.md"
@@ -0,0 +1,487 @@
+# 12.Navigation简介
+
+单个Activity嵌套多个Fragment的UI架构模式，已经被大多数Android工程师所接受和采用。但是，对Fragment的管理一直是一件比较麻烦的事情。工程师需要通过FragmentManager和FragmentTransaction来管理Fragment之间的切换。页面的切换通常还包括对应用程序App bar的管理、Fragment间的切换动画，以及Fragment间的参数传递。纯代码的方式使用起来不是特别友好，并且Fragment和App bar在管理和使用的过程中显得很混乱。
+
+为此，Jetpack提供了一个名为Navigation的组件，旨在方便我们管理页面和App bar。
+
+它具有以下优势: 
+
+- 可视化的页面导航图，类似于Apple Xcode中的StoryBoard，便于我们理清页面间的关系。
+- 通过destination和action完成页面间的导航。
+- 方便添加页面切换动画。
+- 页面间类型安全的参数传递。
+- 通过NavigationUI类，对菜单、底部导航、抽屉菜单导航进行统一的管理。
+- 支持深层链接DeepLink。
+
+Navigation 组件旨在用于具有一个主 Activity 和多个 Fragment 目的地的应用。主 Activity 与导航图相关联，且包含一个负责根据需要交换目的地的 `NavHostFragment`。在具有多个 Activity 目的地的应用中，每个 Activity 均拥有其自己的导航图。
+
+## 依赖
+
+如果想要使用Navigation，需要现在build.gradle文件中添加以下依赖: 
+
+```
+dependencies {
+  def nav_version = "2.3.5"
+
+  // Java language implementation
+  implementation "androidx.navigation:navigation-fragment:$nav_version"
+  implementation "androidx.navigation:navigation-ui:$nav_version"
+
+  // Kotlin
+  implementation "androidx.navigation:navigation-fragment-ktx:$nav_version"
+  implementation "androidx.navigation:navigation-ui-ktx:$nav_version"
+
+  // Feature module Support
+  implementation "androidx.navigation:navigation-dynamic-features-fragment:$nav_version"
+
+  // Testing Navigation
+  androidTestImplementation "androidx.navigation:navigation-testing:$nav_version"
+
+  // Jetpack Compose Integration
+  implementation "androidx.navigation:navigation-compose:1.0.0-alpha10"
+}
+
+```
+
+
+
+
+
+## Navigation的主要元素
+
+导航组件由以下三个关键部分组成：
+
+1. Navigation Graph
+
+    在一个集中位置包含所有导航相关信息的 XML 资源。这包括应用内所有单个内容区域（称为*目标*）以及用户可以通过应用获取的可能路径。
+
+2. NavHost
+
+    显示导航图中目标的空白容器。导航组件包含一个默认NavHost实现 (NavHostFragment)，可显示Fragment目标。
+
+3. NavController
+
+    在NavHost中管理应用导航的对象。当用户在整个应用中移动时，NavController会安排NavHost中目标内容的交换。
+
+在应用中导航时，您告诉NavController，您想沿导航图中的特定路径导航至特定目标，或直接导航至特定目标。NavController便会在NavHost中显示相应目标。
+
+
+
+## Navigation Graph(导航图)
+
+导航图是一种资源文件，其中包含您的所有目的地和操作。该图表会显示应用的所有导航路径。
+
+
+
+如需向项目添加导航图，请执行以下操作：
+
+1. 在“Project”窗口中，右键点击 `res` 目录，然后依次选择 **New > Android Resource File**。此时系统会显示 **New Resource File** 对话框。
+2. 在 **File name** 字段中输入名称，例如“nav_graph”。
+3. 从 **Resource type** 下拉列表中选择 **Navigation**，然后点击 **OK**。
+
+```
+<?xml version="1.0" encoding="utf-8"?>
+<navigation xmlns:android="http://schemas.android.com/apk/res/android"
+            xmlns:app="http://schemas.android.com/apk/res-auto"
+            android:id="@+id/nav_graph">
+</navigation>
+```
+
+`<navigation>` 元素是导航图的根元素。当您向图表添加目的地和连接操作时，可以看到相应的 `<destination>` 和 `<action>` 元素在此处显示为子元素。如果您有[嵌套图表](https://developer.android.com/guide/navigation/navigation-nested-graphs)，它们将显示为子 `<navigation>` 元素。
+
+## 向 Activity 添加 NavHost
+
+导航宿主是 Navigation 组件的核心部分之一。导航宿主是一个空容器，用户在您的应用中导航时，目的地会在该容器中交换进出。
+
+导航宿主必须派生于 [`NavHost`](https://developer.android.com/reference/androidx/navigation/NavHost)。Navigation 组件的默认 `NavHost` 实现 ([`NavHostFragment`](https://developer.android.com/reference/androidx/navigation/fragment/NavHostFragment)) 负责处理 Fragment 目的地的交换。
+
+
+
+### 通过 XML 添加 NavHostFragment
+
+以下 XML 示例显示了作为应用主 Activity 一部分的 `NavHostFragment`：
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.constraintlayout.widget.ConstraintLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    tools:context=".MainActivity">
+
+    <androidx.appcompat.widget.Toolbar
+        .../>
+
+    <androidx.fragment.app.FragmentContainerView
+        android:id="@+id/nav_host_fragment"
+        android:name="androidx.navigation.fragment.NavHostFragment"
+        android:layout_width="0dp"
+        android:layout_height="0dp"
+        app:layout_constraintLeft_toLeftOf="parent"
+        app:layout_constraintRight_toRightOf="parent"
+        app:layout_constraintTop_toTopOf="parent"
+        app:layout_constraintBottom_toBottomOf="parent"
+
+        app:defaultNavHost="true"
+        app:navGraph="@navigation/nav_graph" />
+
+    <com.google.android.material.bottomnavigation.BottomNavigationView
+        .../>
+
+</androidx.constraintlayout.widget.ConstraintLayout>
+```
+
+NavHostFragment是一个特殊的Fragment，我们需要将其添加到Activity的布局文件中，作为其他Fragment的容器。
+
+请注意以下几点：
+
+- `android:name` 属性包含 `NavHost` 实现的类名称。
+- `app:navGraph` 属性将 `NavHostFragment` 与导航图相关联。导航图会在此 `NavHostFragment` 中指定用户可以导航到的所有目的地。
+- `app:defaultNavHost="true"` 属性确保您的 `NavHostFragment` 会自动处理系统返回键，即当用户按下手机的返回按钮时，系统能自动将当前所展示的Fragment退出。请注意，只能有一个默认 `NavHost`。如果同一布局（例如，双窗格布局）中有多个宿主，请务必仅指定一个默认 `NavHost`。
+
+
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<navigation xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    app:startDestination="@id/blankFragment"> // 起始fragment
+    <fragment
+        android:id="@+id/blankFragment"
+        android:name="com.example.cashdog.cashdog.BlankFragment"
+        android:label="Blank"
+        tools:layout="@layout/fragment_blank" />
+</navigation>
+```
+
+### Action
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<navigation xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    app:startDestination="@id/blankFragment">
+    <fragment
+        android:id="@+id/blankFragment"
+        android:name="com.example.cashdog.cashdog.BlankFragment"
+        android:label="fragment_blank"
+        tools:layout="@layout/fragment_blank" >
+        <action
+            android:id="@+id/action_blankFragment_to_blankFragment2"
+            app:destination="@id/blankFragment2" />
+    </fragment>
+    <fragment
+        android:id="@+id/blankFragment2"
+        android:name="com.example.cashdog.cashdog.BlankFragment2"
+        android:label="fragment_blank_fragment2"
+        tools:layout="@layout/fragment_blank_fragment2" />
+</navigation>
+
+```
+
+在导航图中，操作由 `<action>` 元素表示。操作至少应包含自己的 ID 和用户应转到的目的地的 ID。
+
+## 导航到目的地
+
+导航到目的地是使用 [`NavController`](https://developer.android.com/reference/androidx/navigation/NavController) 完成的，它是一个在 `NavHost` 中管理应用导航的对象。每个 `NavHost` 均有自己的相应 `NavController`。您可以使用以下方法之一检索 `NavController`：
+
+**Kotlin**：
+
+- [`Fragment.findNavController()`](https://developer.android.com/reference/kotlin/androidx/navigation/fragment/package-summary#findnavcontroller)
+- [`View.findNavController()`](https://developer.android.com/reference/kotlin/androidx/navigation/package-summary#(android.view.View).findNavController())
+- [`Activity.findNavController(viewId: Int)`](https://developer.android.com/reference/kotlin/androidx/navigation/package-summary#findnavcontroller)
+
+**Java**：
+
+- [`NavHostFragment.findNavController(Fragment)`](https://developer.android.com/reference/androidx/navigation/fragment/NavHostFragment#findNavController(android.support.v4.app.Fragment))
+- [`Navigation.findNavController(Activity, @IdRes int viewId)`](https://developer.android.com/reference/androidx/navigation/Navigation#findNavController(android.app.Activity, int))
+- [`Navigation.findNavController(View)`](https://developer.android.com/reference/androidx/navigation/Navigation#findNavController(android.view.View))
+
+使用 `FragmentContainerView` 创建 `NavHostFragment`，或通过 `FragmentTransaction` 手动将 `NavHostFragment` 添加到您的 Activity 时，尝试通过 `Navigation.findNavController(Activity, @IdRes int)` 检索 Activity 的 `onCreate()` 中的 `NavController` 将失败。您应改为直接从 `NavHostFragment` 检索 `NavController`。
+
+```kotlin
+val navHostFragment =
+        supportFragmentManager.findFragmentById(R.id.nav_host_fragment) as NavHostFragment
+val navController = navHostFragment.navController
+navController.navigate(R.id.action_blankFragment_to_blankFragment2)
+```
+
+对于按钮，您还可以使用 [`Navigation`](https://developer.android.com/reference/androidx/navigation/Navigation) 类的 [`createNavigateOnClickListener()`](https://developer.android.com/reference/androidx/navigation/Navigation#createNavigateOnClickListener(int)) 便捷方法导航到目的地，如下例所示：
+
+```kotlin
+button.setOnClickListener(Navigation.createNavigateOnClickListener(R.id.next_fragment, null))
+
+```
+
+
+
+## 使用 DeepLinkRequest 导航
+
+您可以使用 [`navigate(NavDeepLinkRequest)`](https://developer.android.com/reference/androidx/navigation/NavController#navigate(androidx.navigation.NavDeepLinkRequest)) 直接导航到[隐式深层链接目的地](https://developer.android.com/guide/navigation/navigation-deep-link#implicit)，如下例所示：
+
+```kotlin
+val request = NavDeepLinkRequest.Builder
+    .fromUri("android-app://androidx.navigation.app/profile".toUri())
+    .build()
+findNavController().navigate(request)
+
+```
+
+## 导航和返回堆栈
+
+Android 会维护一个[返回堆栈](https://developer.android.com/guide/components/activities/tasks-and-back-stack)，其中包含您之前访问过的目的地。当用户打开您的应用时，应用的第一个目的地就放置在堆栈中。每次调用 [`navigate()`](https://developer.android.com/reference/androidx/navigation/NavController#navigate(int)) 方法都会将另一目的地放置到堆栈的顶部。点按**向上**或**返回**会分别调用 [`NavController.navigateUp()`](https://developer.android.com/reference/androidx/navigation/NavController#navigateUp()) 和 [`NavController.popBackStack()`](https://developer.android.com/reference/androidx/navigation/NavController#popBackStack()) 方法，用于移除（或弹出）堆栈顶部的目的地。
+
+`NavController.popBackStack()` 会返回一个布尔值，表明它是否已成功返回到另一个目的地。当返回 `false` 时，最常见的情况是手动弹出图的起始目的地。
+
+如果该方法返回 `false`，则 `NavController.getCurrentDestination()` 会返回 `null`。您应负责导航到新目的地，或通过对 Activity 调用 `finish()` 来处理弹出情况，如下例所示：
+
+```kotlin
+
+if (!navController.popBackStack()) {
+    // Call finish() on your Activity
+    finish()
+}
+
+```
+
+## popUpTo 和 popUpToInclusive
+
+使用操作进行导航时，您可以选择从返回堆栈上弹出其他目的地。例如，如果您的应用具有初始登录流程，那么在用户登录后，您应将所有与登录相关的目的地从返回堆栈上弹出，这样返回按钮就不会将用户带回登录流程。
+
+如需在从一个目的地导航到另一个目的地时弹出目的地，请在关联的 `<action>` 元素中添加 `app:popUpTo` 属性。`app:popUpTo` 会告知 Navigation 库在调用 `navigate()` 的过程中从返回堆栈上弹出一些目的地。属性值是应保留在堆栈中的最新目的地的 ID。
+
+您还可以添加 `app:popUpToInclusive="true"`，以表明在 `app:popUpTo` 中指定的目的地也应从返回堆栈中移除。
+
+## 通过 <include> 引用其他导航图
+
+在导航图中，您可以使用 `include` 引用其他图。虽然这在功能上与使用嵌套图相同，但 `include` 可让您使用其他项目模块或库项目中的图，如以下示例所示：
+
+```xml
+<!-- (root) nav_graph.xml -->
+<?xml version="1.0" encoding="utf-8"?>
+<navigation xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:id="@+id/nav_graph"
+    app:startDestination="@id/fragment">
+
+    <include app:graph="@navigation/included_graph" />
+
+    <fragment
+        android:id="@+id/fragment"
+        android:name="com.example.myapplication.BlankFragment"
+        android:label="Fragment in Root Graph"
+        tools:layout="@layout/fragment_blank">
+        <action
+            android:id="@+id/action_fragment_to_second_graph"
+            app:destination="@id/second_graph" />
+    </fragment>
+
+    ...
+</navigation>
+```
+
+```xml
+<!-- included_graph.xml -->
+<?xml version="1.0" encoding="utf-8"?>
+<navigation xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:id="@+id/second_graph"
+    app:startDestination="@id/includedStart">
+
+    <fragment
+        android:id="@+id/includedStart"
+        android:name="com.example.myapplication.IncludedStart"
+        android:label="fragment_included_start"
+        tools:layout="@layout/fragment_included_start" />
+</navigation>
+```
+
+
+
+## 创建全局操作
+
+您可以使用全局操作来创建可由多个目的地共用的通用操作。例如，您可能想要不同目的地中的多个按钮导航到同一应用主屏幕。
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<navigation xmlns:app="http://schemas.android.com/apk/res-auto"
+            xmlns:tools="http://schemas.android.com/tools"
+            xmlns:android="http://schemas.android.com/apk/res/android"
+            android:id="@+id/main_nav"
+            app:startDestination="@id/mainFragment">
+
+  ...
+
+  <action android:id="@+id/action_global_mainFragment"
+          app:destination="@id/mainFragment"/>
+
+</navigation>
+```
+
+如需在代码中使用某个全局操作，请将该全局操作的资源 ID 传递到每个界面元素的 [`navigate()`](https://developer.android.com/reference/androidx/navigation/NavController#navigate(int)) 方法，如以下示例所示：
+
+```kotlin
+viewTransactionButton.setOnClickListener { view ->
+    view.findNavController().navigate(R.id.action_global_mainFragment)
+}
+```
+
+## 使用 Safe Args 实现类型安全的导航
+
+如需在目的地之间导航，建议使用 Safe Args Gradle 插件。此插件可生成简单的对象和构建器类，以便在目的地之间实现类型安全的导航。我们强烈建议您在导航以及[在目的地之间传递数据](https://developer.android.com/guide/navigation/navigation-pass-data#Safe-args)时使用 Safe Args。
+
+
+
+如需将 [Safe Args](https://developer.android.com/topic/libraries/architecture/navigation/navigation-pass-data#Safe-args) 添加到您的项目中，请在顶层 `build.gradle` 文件中包含以下 `classpath`：
+
+```xml
+buildscript {
+    repositories {
+        google()
+    }
+    dependencies {
+        def nav_version = "2.3.5"
+        classpath "androidx.navigation:navigation-safe-args-gradle-plugin:$nav_version"
+    }
+}
+```
+
+您还必须应用以下两个可用插件之一。
+
+如需生成适用于 Java 模块或 Java 和 Kotlin 混合模块的 Java 语言代码，请将以下行添加到**应用或模块**的 `build.gradle` 文件中：
+
+`apply plugin: "androidx.navigation.safeargs"`
+
+此外，如需生成适用于 Kotlin 独有的模块的 Kotlin 代码，请添加以下行：
+
+`apply plugin: "androidx.navigation.safeargs.kotlin"`
+
+根据[迁移到 AndroidX](https://developer.android.com/jetpack/androidx/migrate#migrate)) 文档，您的 [`gradle.properties` 文件](https://developer.android.com/studio/build#properties-files)中必须具有 `android.useAndroidX=true`。
+
+启用 Safe Args 后，生成的代码会包含已定义的每个操作的类和方法，以及与每个发送目的地和接收目的地相对应的类。
+
+Safe Args 为生成操作的每个目的地生成一个类。生成的类名称会在源目的地类名称的基础上添加“Directions”。例如，如果源目的地的名称为 `SpecifyAmountFragment`，则生成的类的名称为 `SpecifyAmountFragmentDirections`。
+
+生成的类为源目的地中定义的每个操作提供了一个静态方法。该方法接受任何定义的[操作参数](https://developer.android.com/guide/navigation/navigation-pass-data)为参数，并返回可直接传递到 [`navigate()`](https://developer.android.com/reference/androidx/navigation/NavController.html?skip_cache=true#navigate(androidx.navigation.NavDirections)) 的 [`NavDirections`](https://developer.android.com/reference/androidx/navigation/NavDirections.html?skip_cache=true) 对象。
+
+
+
+### Safe Args 示例
+
+例如，假设我们的导航图包含一个操作，该操作将两个目的地 `SpecifyAmountFragment` 和 `ConfirmationFragment` 连接起来。`ConfirmationFragment` 接受您作为操作的一部分提供的单个 `float` 参数。
+
+Safe Args 会生成一个 `SpecifyAmountFragmentDirections` 类，其中只包含一个 `actionSpecifyAmountFragmentToConfirmationFragment()` 方法和一个名为 `ActionSpecifyAmountFragmentToConfirmationFragment` 的内部类。这个内部类派生自 `NavDirections` 并存储了关联的操作 ID 和 `float` 参数。然后，您可以将返回的 `NavDirections` 对象直接传递到 `navigate()`，如下例所示：
+
+```kotlin
+override fun onClick(v: View) {
+    val amount: Float = ...
+    val action =
+        SpecifyAmountFragmentDirections
+            .actionSpecifyAmountFragmentToConfirmationFragment(amount)
+    v.findNavController().navigate(action)
+}
+```
+
+## 传递参数
+
+Navigation 支持您通过定义目的地参数将数据附加到导航操作。例如，用户个人资料目的地可能会根据用户 ID 参数来确定要显示哪个用户。
+
+通常情况下，强烈建议您仅在目的地之间传递最少量的数据。例如，您应该传递键来检索对象而不是传递对象本身，因为在 Android 上用于保存所有状态的总空间是有限的。如果您需要传递大量数据，不妨考虑使用 [`ViewModel`](https://developer.android.com/reference/androidx/lifecycle/ViewModel)（如[在 Fragment 之间共享数据](https://developer.android.com/topic/libraries/architecture/viewmodel#sharing)中所述）。
+
+```xml
+<action android:id="@+id/startMyFragment"
+    app:destination="@+id/myFragment">
+    <argument
+        android:name="myArg"
+        app:argType="integer"
+        android:defaultValue="1" />
+</action>
+```
+
+通过声明argement节点来指定参数。
+
+启用 Safe Args 后，生成的代码会为每个操作包含以下类型安全的类和方法，以及每个发送和接收目的地。
+
+- 为生成操作的每一个目的地创建一个类。该类的名称是在源目的地的名称后面加上“Directions”。例如，如果源目的地是名为 `SpecifyAmountFragment` 的 Fragment，则生成的类的名称为 `SpecifyAmountFragmentDirections`。
+
+    该类会为源目的地中定义的每个操作提供一个方法。
+
+- 对于用于传递参数的每个操作，都会创建一个 inner 类，该类的名称根据操作的名称确定。例如，如果操作名称为 `confirmationAction,`，则类名称为 `ConfirmationAction`。如果您的操作包含不带 `defaultValue` 的参数，则您可以使用关联的 action 类来设置参数值。
+
+- 为接收目的地创建一个类。该类的名称是在目的地的名称后面加上“Args”。例如，如果目的地 Fragment 的名称为 `ConfirmationFragment,`，则生成的类的名称为 `ConfirmationFragmentArgs`。可以使用该类的 `fromBundle()` 方法检索参数。
+
+```
+override fun onClick(v: View) {  val amountTv: EditText = view!!.findViewById(R.id.editTextAmount)  val amount = amountTv.text.toString().toInt()  val action = SpecifyAmountFragmentDirections.confirmationAction(amount)  v.findNavController().navigate(action)}
+```
+
+在接收目的地的代码中，请使用 [`getArguments()`](https://developer.android.com/reference/androidx/fragment/app/Fragment#getArguments()) 方法来检索 bundle 并使用其内容。使用 `-ktx` 依赖项时，Kotlin 用户还可以使用 `by navArgs()` 属性委托来访问参数。
+
+```kotlin
+val args: ConfirmationFragmentArgs by navArgs()
+
+override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+    val tv: TextView = view.findViewById(R.id.textViewAmount)
+    val amount = args.amount
+    tv.text = amount.toString()
+}
+```
+
+## 使用 Bundle 对象在目的地之间传递参数
+
+如果您不使用 Gradle，仍然可以使用 `Bundle` 对象在目的地之间传递参数。创建 `Bundle` 对象并使用 [`navigate()`](https://developer.android.com/reference/androidx/navigation/NavController#navigate(int)) 将它传递给目的地，如下所示：
+
+```
+val bundle = bundleOf("amount" to amount)view.findNavController().navigate(R.id.confirmationAction, bundle)
+```
+
+在接收目的地的代码中，请使用 [`getArguments()`](https://developer.android.com/reference/androidx/fragment/app/Fragment#getArguments()) 方法来检索 `Bundle` 并使用其内容：
+
+```kotlin
+val tv = view.findViewById<TextView>(R.id.textViewAmount)
+tv.text = arguments?.getString("amount")
+```
+
+
+
+## NavigationUI
+
+导航图是Navigation组件中很重要的一部分，它可以帮助我们快速了解页面之间的关系，再通过NavController便可以完成页面的切换工作。而在页面的切换过程中，通常还伴随着App bar中menu菜单的变化。对于不同的页面，App bar中的menu菜单很可能是不一样的。App bar中的各种按钮和菜单，同样承担着页面切换的工作。例如，当ActionBar左边的返回按钮被单击时，我们需要响应该事件，返回到上一个页面。既然Navigation和App bar都需要处理页面切换事件，那么，为了方便管理，Jetpack引入了NavigationUI组件，使App bar中的按钮和菜单能够与导航图中的页面关联起来。
+
+`NavigationUI` 支持以下顶部应用栏类型：
+
+- [`Toolbar`](https://developer.android.com/reference/android/widget/Toolbar)
+- [`CollapsingToolbarLayout`](https://developer.android.com/reference/com/google/android/material/appbar/CollapsingToolbarLayout)
+- [`ActionBar`](https://developer.android.com/reference/androidx/appcompat/app/ActionBar)
+
+```kotlin
+override fun onCreate(savedInstanceState: Bundle?) {
+    ...
+
+    val navHostFragment =
+        supportFragmentManager.findFragmentById(R.id.nav_host_fragment) as NavHostFragment
+    val navController = navHostFragment.navController
+    val appBarConfiguration = AppBarConfiguration(
+        topLevelDestinationIds = setOf(),
+        fallbackOnNavigateUpListener = ::onSupportNavigateUp
+    )
+    findViewById<Toolbar>(R.id.toolbar)
+        .setupWithNavController(navController, appBarConfiguration)
+}
+
+```
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git a/Jetpack/architecture/13.Jetpack MVVM.md b/Jetpack/architecture/13.Jetpack MVVM.md
new file mode 100644
index 00000000..0ed02013
--- /dev/null
+++ b/Jetpack/architecture/13.Jetpack MVVM.md	
@@ -0,0 +1,47 @@
+# 13.Jetpack MVVM
+
+项目地址:[android-architecture](https://github.com/googlesamples/android-architecture)
+`Google`将该项目命名为`Android`的架构蓝图，我想从名字上已可以看穿一切。
+
+在它的官方介绍中是这样说的:   
+
+> The Android framework offers a lot of flexibility when it comes to defining how to organize and architect an Android app. This freedom, whilst very valuable, can also result in apps with large classes, inconsistent naming and architectures (or lack of) that can make testing, maintaining and extending difficult.
+
+> Android Architecture Blueprints is meant to demonstrate possible ways to help with these common problems. In this project we offer the same application implemented using different architectural concepts and tools.
+
+> You can use these samples as a reference or as a starting point for creating your own apps. The focus here is on code structure, architecture, testing and maintainability. However, bear in mind that there are many ways to build apps with these architectures and tools, depending on your priorities, so these shouldn't be considered canonical examples. The UI is deliberately kept simple.
+
+Jetpack MVVM 是 MVVM 模式在 Android 开发中的一个具体实现，是 Android中 Google 官方提供并推荐的 MVVM实现方式。
+不仅通过数据驱动完成彻底解耦，还兼顾了 Android 页面开发中其他不可预期的错误，例如Lifecycle 能在妥善处理 页面生命周期 避免view空指针问题，ViewModel使得UI发生重建时 无需重新向后台请求数据，节省了开销，让视图重建时更快展示数据。
+首先，请查看下图，该图显示了所有模块应如何彼此交互：
+
+各模块对应MVVM架构：
+
+View层：Activity/Fragment
+ViewModel层：Jetpack ViewModel + Jetpack LivaData
+Model层：Repository仓库，包含 本地持久性数据 和 服务端数据
+
+View层 包含了我们平时写的Activity/Fragment/布局文件等与界面相关的东西。
+ViewModel层 用于持有和UI元素相关的数据，以保证这些数据在屏幕旋转时不会丢失，并且还要提供接口给View层调用以及和仓库层进行通信。
+仓库层 要做的主要工作是判断调用方请求的数据应该是从本地数据源中获取还是从网络数据源中获取，并将获取到的数据返回给调用方。本地数据源可以使用数据库、SharedPreferences等持久化技术来实现，而网络数据源则通常使用Retrofit访问服务器提供的Webservice接口来实现。
+另外，图中所有的箭头都是单向的，例如View层指向了ViewModel层，表示View层会持有ViewModel层的引用，但是反过来ViewModel层却不能持有View层的引用。除此之外，引用也不能跨层持有，比如View层不能持有仓库层的引用，谨记每一层的组件都只能与它相邻层的组件进行交互。
+这种设计打造了一致且愉快的用户体验。无论用户上次使用应用是在几分钟前还是几天之前，现在回到应用时都会立即看到应用在本地保留的数据。如果此数据已过期，则应用的Repository将开始在后台更新数据。
+
+有人可能会有疑惑：怎么完全没有提 DataBinding、双向绑定？
+实际上，这也是我之前的疑惑。 没有提 是因为：
+
+我不想让读者 一提到 MVVM 就和DataBinding联系起来
+我想让读者 抓住 MVVM 数据驱动 的本质。
+而DataBinding提供的双向绑定，是用来完善Jetpack MVVM 的工具，其本身在业界又非常具有争议性。
+掌握本篇内容，已经是Google推荐的开发架构，就已经实现 MVVM 模式。在Google官方的 应用架构指南 中 也同样丝毫没有提到 DataBinding。
+
+
+## 参考
+- [“终于懂了“系列：Jetpack AAC完整解析（四）MVVM - Android架构探索！](https://juejin.cn/post/6921321173661777933)
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! `
\ No newline at end of file
diff --git "a/Jetpack/architecture/14.findViewById\347\232\204\350\277\207\345\216\273\345\217\212\346\234\252\346\235\245.md" "b/Jetpack/architecture/14.findViewById\347\232\204\350\277\207\345\216\273\345\217\212\346\234\252\346\235\245.md"
new file mode 100644
index 00000000..0fc2bd0b
--- /dev/null
+++ "b/Jetpack/architecture/14.findViewById\347\232\204\350\277\207\345\216\273\345\217\212\346\234\252\346\235\245.md"
@@ -0,0 +1,22 @@
+# 14.findViewById的过去及未来
+
+We have lots of alternatives for this, and  you may wonder why do we need another solution. Let’s compare the  different solutions based on these criteria: null-safety, compile-time  safety, and speed.
+
+| Column 1              | **[ButterKnife](https://github.com/JakeWharton/butterknife)** | [**Kotlin Synthetics**](https://developer.android.com/kotlin/ktx) | [**Data Binding**](https://developer.android.com/topic/libraries/data-binding) | [**findViewById**](https://developer.android.com/reference/android/app/Activity#findViewById(int)) | [View Binding](https://developer.android.com/topic/libraries/view-binding) |
+| --------------------- | :----------------------------------------------------------: | :----------------------------------------------------------: | :----------------------------------------------------------: | :----------------------------------------------------------: | :----------------------------------------------------------: |
+| **Fast**              |                             ❌ *                              |                              ✅                               |                             ❌ *                              |                              ✅                               |                              ✅                               |
+| **Null-safe**         |                              ❌                               |                              ❌                               |                              ✅                               |                              ❌                               |                              ✅                               |
+| **Compile-time safe** |                              ❌                               |                              ❌                               |                              ✅                               |                             ✅ **                             |                              ✅                               |
+
+\* ButterKnife and Data Binding solutions are slower because they use an annotation-based approach
+ ** `findViewById()` is compile-time safe since API 26 because we don’t need to cast the type of view anymore.
+
+https://juejin.cn/post/6905942568467759111
+
+https://medium.com/mobile-app-development-publication/how-android-access-view-item-the-past-to-the-future-bb003ae84527
+
+
+
+## 参考
+- [Kotlin 插件的落幕，ViewBinding 的崛起](https://juejin.cn/post/6905942568467759111)
+- [How Android Access View Item: The Past to the Future](https://medium.com/mobile-app-development-publication/how-android-access-view-item-the-past-to-the-future-bb003ae84527)
\ No newline at end of file
diff --git "a/Jetpack/architecture/2.ViewBinding\347\256\200\344\273\213.md" "b/Jetpack/architecture/2.ViewBinding\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..43f23558
--- /dev/null
+++ "b/Jetpack/architecture/2.ViewBinding\347\256\200\344\273\213.md"
@@ -0,0 +1,400 @@
+# 2.ViewBinding简介
+
+ViewBinding是Google在2019年I/O大会上公布的一款Android视图绑定工具，在Android Studio 3.6中添加的一个新功能，更准确的说，它是DataBinding的一个更轻量变体，为什么要使用View Binding呢？答案是性能。许多开发者使用Data Binding库来引用Layout XML中的视图，而忽略它的其他强大功能。相比来说，自动生成代码ViewBinding其实比DataBinding性能更好。但是传统的方式使用View Binding却不是很好，因为会有很多样板代码（垃圾代码）。
+
+通过ViewBinding，你可以更轻松的编写可与视图交互的代码。在模块中启用视图绑定之后，系统会为该模块中的每个XML布局文件生成一个绑定类。绑定类的实例包含对在相应布局中具有ID的所有视图的直接引用。在大多数情况下，视图绑定会替代findViewById。
+
+## 使用方法
+
+### 1.build.gradle中开启
+在build.gradle文件中的androidj节点添加如下代码: 
+```
+android {
+   ...
+    buildFeatures {
+        viewBinding true
+    }
+}
+```
+重新编译后系统会为每个布局文件生成对应的Binding类，该类中包含对应布局中具有id的所有视图的直接饮用。生成类的目录在app/build/generated/data_binding_base_class_source_out中。
+如果项目中存在多个模块，则需要在每个模块的build.gradle文件中都加上该配置。
+假设某个布局文件的名称为result_profile.xml：
+
+```xml
+<LinearLayout ... >
+        <TextView android:id="@+id/name" />
+        <ImageView android:cropToPadding="true" />
+        <Button android:id="@+id/button"
+            android:background="@drawable/rounded_button" />
+    </LinearLayout>
+```
+所生成的绑定类的名称就为ResultProfileBinding。此类具有两个字段：一个是名为name的TextView，另一个是名为button的Button。该布局中的ImageView没有ID，因此绑定类中不存在对它的引用。
+
+每个绑定类还包含一个 getRoot() 方法，用于为相应布局文件的根视图提供直接引用。在此示例中，ResultProfileBinding 类中的 getRoot() 方法会返回 LinearLayout 根视图。
+
+
+如果你希望在生成绑定类时忽略某个布局文件，可以将tools:viewBindingIgnore="true"属性添加到相应布局文件的根视图中: 
+```xml
+<LinearLayout
+            ...
+            tools:viewBindingIgnore="true" >
+        ...
+    </LinearLayout>
+    
+```
+
+### 2.代码中使用
+
+#### 普通Activity
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
+
+    <com.google.android.material.textview.MaterialTextView
+        android:id="@+id/mtv"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_centerInParent="true"
+        android:textSize="50sp"
+        android:textColor="@android:color/holo_green_dark"
+        android:text="welcome" />
+</RelativeLayout>
+```
+```kotlin
+class SplashActivity : BaseActivity() {
+    private lateinit var binding: ActivitySplashBinding
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        binding = ActivitySplashBinding.inflate(layoutInflater)
+        setContentView(binding.root)
+        // mtv为xml中定义的id
+        binding.mtv.text = "Hello World"
+    }
+}
+```
+#### Fragment
+
+在Fragment中，我们需要进行额外的工作来避免内存泄漏，方法是在onDestroyView方法中将ViewBinding引用设置为null。 具体如下:  
+
+```kotlin
+class HomeFragment : Fragment() {
+  private var _binding: HomeFragmentBinding? = null
+  // 只在onCreateView和onDestroyView之间有效
+  private val binding get() = _binding!!
+
+  override fun onCreateView(
+    inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?
+  ): View {
+    _binding = ResultProfileBinding.inflate(inflater, container, false)
+    return binding.root
+  }
+
+  override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+    super.onViewCreated(view, savedInstanceState)
+    binding.tvHelloWorld.text = "Hello Android!"
+  }
+
+  override fun onDestroyView() {
+    super.onDestroyView()
+    _binding = null
+  }
+}
+```
+
+
+You also noticed that we are using two different variables and the _binding variable is set to null in onDestroyView().
+
+That’s because the fragment’s lifecycle is different from the activity’s and the fragment can outlive their views so we can get memory leaks if we don’t set it to null.
+
+The other variable is there to avoid a null check with !! by making one variable nullable and the other one non-null.
+
+#### Adapter
+
+
+还有在Adapter中的使用，因为布局不是只创建一次，而是每个item都会创建，不能像上面那样在Adapter里写一个binding全局变量，不然binding只会得到最后一次创建的视图。所以binding对象应该是给ViewHolder持有。具体如下:  
+```kotlin
+class TextAdapter(
+  private val list: List<String>
+) : RecyclerView.Adapter<TextAdapter.TextViewHolder>() {
+  
+  override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): TextViewHolder {
+    val binding = ItemTextBinding.inflate(LayoutInflater.from(parent.context), parent, false)
+    return TextViewHolder(binding)
+  }
+
+  override fun onBindViewHolder(holder: TextViewHolder, position: Int) {
+    val content = list[position]
+    holder.binding.tvContent.text = content
+  }
+
+  override fun getItemCount() = list.size
+
+  class TextViewHolder(val binding : ItemTextBinding) : RecyclerView.ViewHolder(binding.root)
+}
+```
+#### includ
+
+ViewBinding同样可以被用于<include>中。include又分为两种形式，一种是有<merge>标签的样式，一种是没有的。
+没有<merge>标签的时候需要对include指定id，通过id来获取,例如:  
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content">
+
+    <androidx.appcompat.widget.Toolbar
+        android:id="@+id/toolbar"
+        android:layout_width="0dp"
+        android:layout_height="?actionBarSize"
+        android:background="?colorPrimary"
+        app:layout_constraintEnd_toEndOf="parent"
+        app:layout_constraintStart_toStartOf="parent"
+        app:layout_constraintTop_toTopOf="parent" />
+    
+</androidx.constraintlayout.widget.ConstraintLayout>
+```
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
+
+    <include
+        android:id="@+id/appbar"
+        layout="@layout/app_bar"
+        app:layout_constraintTop_toTopOf="parent" />
+    
+</androidx.constraintlayout.widget.ConstraintLayout>
+```
+```kotlin
+override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        val binding: MainLayoutBinding = MainLayoutBinding.inflate(layoutInflater)
+        setContentView(binding.root)
+        setSupportActionBar(binding.appbar.toolbar)
+    }
+```
+
+在有merge标签的时候,placheholder.xml如下: 
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<merge xmlns:android="http://schemas.android.com/apk/res/android">
+    
+    <TextView
+        android:id="@+id/tvPlaceholder"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content" />
+    
+</merge>
+```
+fragment_order.xml内容如下:  
+```xml
+<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
+
+    <include layout="@layout/placeholder" />
+
+</androidx.constraintlayout.widget.ConstraintLayout>
+```
+这个时候即使我们对include指定了id，在ViewBinding中也不会像普通include那样生成获取对应id的变量。这种情况下，我们需要使用placeholder.xml自动生成的PlaceholderBinding类，然后调用它的bind()方法。 
+```kotlin
+ override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
+        binding = FragmentOrderBinding.inflate(layoutInflater, container, false)
+        placeholderBinding = PlaceholderBinding.bind(binding.root)
+        placeholderBinding.tvPlaceholder.text = getString(R.string.please_wait)
+        return binding.root
+    }
+```
+
+### View Binding 的传统使用方式
+
+- 创建和销毁`viewBinding`的样板代码
+- 如果有很多Fragment,每一个都要拷贝一份相同的代码
+- `viewBinding` 属性是可空的，并且可变的，这可不太妙
+
+而且使用起来不方便，我们希望用更简单的方式,例如:   
+```kotlin
+class MainActivity : AppCompatActivity() {
+    private val binding by viewBinding(ActivityMainBinding::inflate)
+}
+```
+
+怎么办呢？用强大Kotlin委托来重构它。通过属性委托可以自动执行inflate()方法和setContentView()方法。 
+
+### Kotlin 委托属性结合ViewBinding
+
+#### ActivityViewBinding
+
+```kotlin
+import android.os.Looper
+import android.view.LayoutInflater
+import androidx.appcompat.app.AppCompatActivity
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleObserver
+import androidx.lifecycle.OnLifecycleEvent
+import androidx.viewbinding.ViewBinding
+import kotlin.properties.ReadOnlyProperty
+import kotlin.reflect.KProperty
+
+inline fun <reified T : ViewBinding> AppCompatActivity.viewBinding(noinline initializer: (LayoutInflater) -> T) =
+    ViewBindingPropertyDelegate(this, initializer)
+
+class ViewBindingPropertyDelegate<T : ViewBinding>(
+    private val activity: AppCompatActivity,
+    private val initializer: (LayoutInflater) -> T
+) : ReadOnlyProperty<AppCompatActivity, T>, LifecycleObserver {
+
+    private var _value: T? = null
+
+    init {
+        activity.lifecycle.addObserver(this)
+    }
+
+    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
+    @Suppress("Unused")
+    fun onCreate() {
+        if (_value == null) {
+            _value = initializer(activity.layoutInflater)
+        }
+        activity.setContentView(_value?.root!!)
+        activity.lifecycle.removeObserver(this)
+    }
+
+    override fun getValue(thisRef: AppCompatActivity, property: KProperty<*>): T {
+        if (_value == null) {
+            
+            // This must be on the main thread only
+            if (Looper.myLooper() != Looper.getMainLooper()) {
+                throw IllegalThreadStateException("This cannot be called from other threads. It should be on the main thread only.")
+            }
+
+            _value = initializer(thisRef.layoutInflater)
+        }
+        return _value!!
+    }
+}
+```
+
+使用: 
+
+```kotlin
+// 将ActivitySplashBinding的inflate方法当做参数传入
+// 在函数中可以直接传一个方法。静态方法的lambda表达式也是把对象改成类名，所以我们要调用的inflate方法就可以写成 ActivityMainBinding::inflate。
+private val binding: ActivitySplashBinding by viewBinding(ActivitySplashBinding::inflate)
+binding.mtv.text = "Hello World"
+```
+
+不幸的是，该属性委托仅对Activity有效，而对Fragment无效。 
+
+#### FragmentViewBinding
+
+```kotlin
+class FragmentViewBindingDelegate<T : ViewBinding>(
+    val fragment: Fragment,
+    val viewBindingFactory: (View) -> T
+) : ReadOnlyProperty<Fragment, T> {
+    private var binding: T? = null
+
+    init {
+        fragment.lifecycle.addObserver(object : DefaultLifecycleObserver {
+            val viewLifecycleOwnerLiveDataObserver =
+                Observer<LifecycleOwner?> {
+                    val viewLifecycleOwner = it ?: return@Observer
+
+                    viewLifecycleOwner.lifecycle.addObserver(object : DefaultLifecycleObserver {
+                        override fun onDestroy(owner: LifecycleOwner) {
+                            binding = null
+                        }
+                    })
+                }
+
+            override fun onCreate(owner: LifecycleOwner) {
+                fragment.viewLifecycleOwnerLiveData.observeForever(
+                    viewLifecycleOwnerLiveDataObserver
+                )
+            }
+
+            override fun onDestroy(owner: LifecycleOwner) {
+                fragment.viewLifecycleOwnerLiveData.removeObserver(
+                    viewLifecycleOwnerLiveDataObserver
+                )
+            }
+        })
+    }
+
+    override fun getValue(thisRef: Fragment, property: KProperty<*>): T {
+        val binding = binding
+        if (binding != null) {
+            return binding
+        }
+
+        val lifecycle = fragment.viewLifecycleOwner.lifecycle
+        if (!lifecycle.currentState.isAtLeast(Lifecycle.State.INITIALIZED)) {
+            throw IllegalStateException("Should not attempt to get bindings when Fragment views are destroyed.")
+        }
+
+        return viewBindingFactory(thisRef.requireView()).also { this.binding = it }
+    }
+}
+
+fun <T : ViewBinding> Fragment.viewBinding(viewBindingFactory: (View) -> T) =
+    FragmentViewBindingDelegate(this, viewBindingFactory)
+```
+
+然后，使用我们定义的委托来重构`ProfileFragment`，注意在Fragment中使用需要注意传入布局Id,因为在代理getValue的时候会获取requireView:  
+
+```kotlin
+class ProfileFragment : Fragment(R.layout.profile) {
+    private val binding by viewBinding(ProfileBinding::bind)
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        super.onViewCreated(view, savedInstanceState)
+        // Use viewBinding
+    }
+}
+```
+
+很好，我们去掉了创建和销毁ViewBinding的样板代码，现在只需要声明一个委托属性就可以了，是不是简单了？
+
+Android的新库ViewBinding是一个去掉项目中`findViewByid()`很好的解决方案，同时它也替代了著名的`Butter Knife`。ViewBinding 与Kotlin委托属性的巧妙结合，可以让你的代码更加简洁易读。
+
+完整的代码可以查看github:[https://github.com/kirich1409/ViewBindingPropertyDelegate](https://links.jianshu.com/go?to=https%3A%2F%2Fgithub.com%2Fkirich1409%2FViewBindingPropertyDelegate)
+
+## 与findViewById的区别
+
+与使用 findViewById 相比，视图绑定具有一些很显著的优点：
+- Null 安全
+    由于视图绑定会创建对视图的直接引用，因此不存在因视图ID无效而引发Null指针异常的风险。此外，如果视图仅出现在布局的某些配置中，则绑定类中包含其引用的字段会使用@Nullable标记。
+- 类型安全
+    每个绑定类中的字段均具有与它们在XML文件中引用的视图相匹配的类型。这意味着不存在发生类转换异常的风险。
+
+这些差异意味着布局和代码之间的不兼容将会导致构建在编译时（而非运行时）失败。
+
+## 与DataBinding的对别
+ViewBinding与DataBinding均会生成可用于直接引用视图的绑定类。但是，ViewBinding旨在处理更简单的用例，与DataBinding相比，具有以下优势:  
+- 更快的编译速度
+    视图绑定不需要处理注释，因此编译时间更短。
+- 易于使用
+    视图绑定不需要特别标记的XML布局文件，因此在应用中采用速度更快。在模块中启用视图绑定后，它会自动应用于该模块的所有布局。
+
+反过来，与数据绑定相比，视图绑定也具有以下限制:   
+- 视图绑定不支持布局变量或布局表达式，因此不能用于直接在XML布局文件中声明动态界面内容。
+- 视图绑定不支持双向数据绑定。
+
+考虑到这些因素，在某些情况下，最好在项目中同时使用视图绑定和数据绑定。您可以在需要高级功能的布局中使用数据绑定，而在不需要高级功能的布局中使用视图绑定。
+
+# 参考
+
+- [View Binding 与Kotlin委托属性的巧妙结合，告别垃圾代码！](https://www.jianshu.com/p/bf4e81501fbb)
+- [Make Android View Binding great with Kotlin](https://proandroiddev.com/make-android-view-binding-great-with-kotlin-b71dd9c87719)
+- [How to Simplify your Android View Binding Delegation](https://medium.com/easyread/how-to-simplify-your-android-view-binding-delegation-d07812b2a616)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! `
diff --git a/Jetpack/architecture/3.Lifecycle.md b/Jetpack/architecture/3.Lifecycle.md
new file mode 100644
index 00000000..21232ce6
--- /dev/null
+++ b/Jetpack/architecture/3.Lifecycle.md
@@ -0,0 +1,958 @@
+3.Lifecycle
+===
+
+## 背景
+
+在Android应用程序开发中，解耦很大程度上表现为系统组件的生命周期与普通组件之间的解耦。普通组件在使用过程中通常需要依赖于系统组件的生命周期。有时候，我们不得不在系统组件的生命周期回调方法中，主动对普通组件进行调用或控制。因为普通组件无法主动获知系统组件的生命周期事件。
+
+我们希望我们对自定义组件的管理，不依赖于页面生命周期的回调方法。同时，在页面生命周期发生变化时，也能够及时收到通知。这在组件化和架构设计中显得尤为重要。
+
+为此，Google提供了LifeCycle作为解决方案。LifeCycle可以帮助开发者创建可感知生命周期的组件。这样，组件便能够在其内部管理自己的生命周期，从而降低模块间的耦合度，并降低内存泄漏发生的可能性。LifeCycle不只对Activity/Fragment有用，在Service和Application中也能大显身手。
+
+```xml
+dependencies {
+    def lifecycle_version = "2.3.1"
+    def arch_version = "2.1.0"
+
+    // ViewModel
+    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"
+    // LiveData
+    implementation "androidx.lifecycle:lifecycle-livedata-ktx:$lifecycle_version"
+    // Lifecycles only (without ViewModel or LiveData)
+    implementation "androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version"
+
+    // Saved state module for ViewModel
+    implementation "androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version"
+
+    // Jetpack Compose Integration for ViewModel
+    implementation "androidx.lifecycle:lifecycle-viewmodel-compose:1.0.0-alpha04"
+
+    // Annotation processor
+    kapt "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
+    // alternately - if using Java8, use the following instead of lifecycle-compiler
+    implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"
+
+    // optional - helpers for implementing LifecycleOwner in a Service
+    implementation "androidx.lifecycle:lifecycle-service:$lifecycle_version"
+
+    // optional - ProcessLifecycleOwner provides a lifecycle for the whole application process
+    implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version"
+
+    // optional - ReactiveStreams support for LiveData
+    implementation "androidx.lifecycle:lifecycle-reactivestreams-ktx:$lifecycle_version"
+
+    // optional - Test helpers for LiveData
+    testImplementation "androidx.arch.core:core-testing:$arch_version"
+}
+
+```
+
+
+
+## 示例
+
+`Android`开发中，经常需要管理生命周期。举个栗子，我们需要获取用户的地址位置，当这个`Activity`在显示的时候，我们开启定位功能，然后实时获取到定位信息，当页面被销毁的时候，需要关闭定位功能。
+
+```kotlin
+internal class MyLocationListener(
+        private val context: Context,
+        private val callback: (Location) -> Unit
+) {
+
+    fun start() {
+        // connect to system location service
+    }
+
+    fun stop() {
+        // disconnect from system location service
+    }
+}
+
+class MyActivity : AppCompatActivity() {
+    private lateinit var myLocationListener: MyLocationListener
+
+    override fun onCreate(...) {
+        myLocationListener = MyLocationListener(this) { location ->
+            // update UI
+        }
+    }
+
+    public override fun onStart() {
+        super.onStart()
+        myLocationListener.start()
+        // manage other components that need to respond
+        // to the activity lifecycle
+    }
+
+    public override fun onStop() {
+        super.onStop()
+        myLocationListener.stop()
+        // manage other components that need to respond
+        // to the activity lifecycle
+    }
+}
+
+```
+
+虽然此示例看起来没问题，但在真实的应用中，最终会有太多管理界面和其他组件的调用，以响应生命周期的当前状态。管理多个组件会在生命周期方法（如 `onStart()` 和 `onStop()`）中放置大量的代码，这使得它们难以维护。
+
+此外，无法保证组件会在 Activity 或 Fragment 停止之前启动。在我们需要执行长时间运行的操作（如 `onStart()` 中的某种配置检查）时尤其如此。这可能会导致出现一种竞态条件，在这种条件下，`onStop()` 方法会在 `onStart()` 之前结束，这使得组件留存的时间比所需的时间要长。
+
+```kotlin
+class MyActivity : AppCompatActivity() {
+    private lateinit var myLocationListener: MyLocationListener
+
+    override fun onCreate(...) {
+        myLocationListener = MyLocationListener(this) { location ->
+            // update UI
+        }
+    }
+
+    public override fun onStart() {
+        super.onStart()
+        Util.checkUserStatus { result ->
+            // what if this callback is invoked AFTER activity is stopped?
+            if (result) {
+                myLocationListener.start()
+            }
+        }
+    }
+
+    public override fun onStop() {
+        super.onStop()
+        myLocationListener.stop()
+    }
+
+}
+
+```
+
+`android.arch.lifecycle`包提供的类和接口可帮助您用简单和独立的方式解决这些问题。
+
+`Lifecycle`类是一个持有组件(`activity`或`fragment`)生命周期信息的类，其他对象可以观察该状态。`Lifecycle`使用两个重要的枚举部分来管理对应组件的生命周期的状态:   
+
+- `Event`:生命周期事件由系统来分发，这些事件对应于`Activity`和`Fragment`的生命周期函数。
+
+- `State`:`Lifecycle`对象所追踪的组件的当前状态   
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/lifecycle-states.png" width="100%" height="100%">
+
+## LifeCycle的原理
+
+Jetpack为我们提供了两个类: 
+
+- LifecycleOwner: 被观察者
+- LifecycleObserver: 观察者
+
+即通过观察者模式，实现对页面生命周期的监听。 
+
+```java
+public class AppCompatActivity extends FragmentActivity implements AppCompatCallback,
+        TaskStackBuilder.SupportParentable, ActionBarDrawerToggle.DelegateProvider {
+}            
+public class FragmentActivity extends ComponentActivity implements
+        ActivityCompat.OnRequestPermissionsResultCallback,
+        ActivityCompat.RequestPermissionsRequestCodeValidator {
+}            
+
+public class ComponentActivity extends androidx.core.app.ComponentActivity implements
+        LifecycleOwner,
+        ViewModelStoreOwner,
+        SavedStateRegistryOwner,
+        OnBackPressedDispatcherOwner {
+    private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
+    public Lifecycle getLifecycle() {
+        return mLifecycleRegistry;
+    }            
+}           
+public class Fragment implements ComponentCallbacks, OnCreateContextMenuListener, LifecycleOwner,
+        ViewModelStoreOwner, SavedStateRegistryOwner {
+}            
+```
+
+ComponentActivity和Fragment已经默认实现了LifecycleOwner接口。 
+
+
+
+### LifecycleOwner
+
+那什么是`LifecycleOwner`呢？实现`LifecycleOwner`接口就表示这是个有生命周期的类，他有一个`getLifecycle()`方法是必须实现的。   
+
+```java
+/**
+ * A class that has an Android lifecycle. These events can be used by custom components to
+ * handle lifecycle changes without implementing any code inside the Activity or the Fragment.
+ *
+ * @see Lifecycle
+ */
+@SuppressWarnings({"WeakerAccess", "unused"})
+public interface LifecycleOwner {
+    /**
+     * Returns the Lifecycle of the provider.
+     *
+     * @return The lifecycle of the provider.
+     */
+    @NonNull
+    Lifecycle getLifecycle();
+}
+```
+
+从以上源码可知，Activity和Fragment已经替我们实现了被观察者应该实现的那一部分代码。因此，我们不需要再去实现这部分代码。当我们希望监听Activity的生命周期时，只需要实现观察者那一部分的代码，即让自定义组件实现LifecycleObserver接口即可。该接口没有接口方法，无须任何具体实现。
+
+对于前面提到的监听位置的例子。可以把`MyLocationListener`实现`LifecycleObserver`,然后在`Lifecycle（Activity／Fragment）`的`onCreate`方法中初始化。这样`MyLocationListener`就能自行处理生命周期带来的问题。
+
+### 自定义LifecycleOwner
+如果想在自定义的类中实现`LifecyclerOwner`，就需要用到[LifecycleRegistry](https://developer.android.com/reference/android/arch/lifecycle/LifecycleRegistry)类,并且需要自行发送`Event`:  
+
+```java
+class MyActivity : Activity(), LifecycleOwner {
+    private lateinit var lifecycleRegistry: LifecycleRegistry
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        lifecycleRegistry = LifecycleRegistry(this)
+        lifecycleRegistry.markState(Lifecycle.State.CREATED)
+    }
+
+    public override fun onStart() {
+        super.onStart()
+        lifecycleRegistry.markState(Lifecycle.State.STARTED)
+    }
+
+    override fun getLifecycle(): Lifecycle {
+        return lifecycleRegistry
+    }
+}
+```
+
+### LifecycleObserver
+
+```java
+/**
+ * Marks a class as a LifecycleObserver. It does not have any methods, instead, relies on
+ * {@link OnLifecycleEvent} annotated methods.
+ * <p>
+ * @see Lifecycle Lifecycle - for samples and usage patterns.
+ */
+@SuppressWarnings("WeakerAccess")
+public interface LifecycleObserver {
+
+}
+```
+
+注释上写的很明白，该接口依赖OnLifecycleEvent的注解方法
+
+```java
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface OnLifecycleEvent {
+    Lifecycle.Event value();
+}
+public enum Event {
+    /**
+         * Constant for onCreate event of the {@link LifecycleOwner}.
+         */
+    ON_CREATE,
+    /**
+         * Constant for onStart event of the {@link LifecycleOwner}.
+         */
+    ON_START,
+    /**
+         * Constant for onResume event of the {@link LifecycleOwner}.
+         */
+    ON_RESUME,
+    /**
+         * Constant for onPause event of the {@link LifecycleOwner}.
+         */
+    ON_PAUSE,
+    /**
+         * Constant for onStop event of the {@link LifecycleOwner}.
+         */
+    ON_STOP,
+    /**
+         * Constant for onDestroy event of the {@link LifecycleOwner}.
+         */
+    ON_DESTROY,
+    /**
+         * An {@link Event Event} constant that can be used to match all events.
+         */
+    ON_ANY
+}
+```
+
+
+
+## 示例改进
+
+
+
+
+```kotlin
+class MainActivity : AppCompatActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_main)
+        // lifecycle是LifecycleOwner接口的getLifecycle()方法得到的
+        lifecycle.addObserver(MyObserver()) 
+    }
+}
+```
+
+在Activity中只需要引用MyObserver即可，不用再关心Activity生命周期变化对该组件所带来的影响。生命周期的管理完全交给MyObserver内部自行处理。在Activity中要做的只是通过getLifecycle().addObserver()方法，将观察者与被观察者绑定起来。
+
+```kotlin
+class MyObserver : LifecycleObserver {
+
+    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
+    fun connectListener() {
+        ...
+    }
+
+    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
+    fun disconnectListener() {
+        ...
+    }
+}
+```
+
+上面的`lifecycle.addObserver(MyObserver()) `的完整写法应该是`aLifecycleOwner.getLifecycle().addObserver(new MyObserver())`而`aLifecycleOwner`一般是实现了`LifecycleOwner`的类，比如`Activity/Fragment`
+
+```kotlin
+internal class MyLocationListener(
+        private val context: Context,
+        private val lifecycle: Lifecycle,
+        private val callback: (Location) -> Unit
+): LifecycleObserver {
+
+    private var enabled = false
+
+    @OnLifecycleEvent(Lifecycle.Event.ON_START)
+    fun start() {
+        if (enabled) {
+            // connect
+        }
+    }
+
+    fun enable() {
+        enabled = true
+        // 查询状态
+        if (lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
+            // connect if not connected
+        }
+    }
+
+    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
+    fun stop() {
+        // disconnect if connected
+    }
+}
+```
+
+
+
+对于组件中那些需要在页面生命周期发生变化时得到通知的方法，我们需要在这些方法上使用＠OnLifecycleEvent（Lifecycle.Event.ON_XXX）标签进行标识。这样，当页面生命周期发生变化时，这些被标识过的方法便会被自动调用。
+
+LifeCycle完美解决了组件对页面生命周期的依赖问题，使组件能够自己管理其生命周期，而无须在页面中对其进行管理。这无疑大大降低了代码的耦合度，提高了组件的复用程度，也杜绝了由于对页面生命周期管理的疏忽而引发的内存泄漏问题，这在项目工程量大的情况下是非常有帮助的。
+
+## 使用LifecycleService解耦Service与组件
+
+拥有生命周期概念的组件除了Activity和Fragment，还有一个非常重要的组件是Service。为了便于对Service生命周期的监听，达到解耦Service与组件的目的，Android提供了一个名为LifecycleService的类。该类继承自Service，并实现了LifecycleOwner接口。与Activity/Fragment类似，它也提供了一个名为getLifecycle()的方法供我们使用。
+
+想要使用LifecycleService必须先增加lifecycle-service的依赖: 
+
+```
+implementation 'androidx.lifecycle:lifecycle-service:2.3.1'
+```
+
+
+
+```java
+public class LifecycleService
+    extends Service implements LifecycleOwner
+java.lang.Object
+   ↳ 	android.content.Context
+  	   ↳ 	android.content.ContextWrapper
+  	  	   ↳ 	android.app.Service
+  	  	  	   ↳ 	androidx.lifecycle.LifecycleService 
+```
+
+```java
+public class LifecycleService extends Service implements LifecycleOwner {
+
+    private final ServiceLifecycleDispatcher mDispatcher = new ServiceLifecycleDispatcher(this);
+
+    @CallSuper
+    @Override
+    public void onCreate() {
+        mDispatcher.onServicePreSuperOnCreate();
+        super.onCreate();
+    }
+
+    @CallSuper
+    @Nullable
+    @Override
+    public IBinder onBind(@NonNull Intent intent) {
+        mDispatcher.onServicePreSuperOnBind();
+        return null;
+    }
+
+    @SuppressWarnings("deprecation")
+    @CallSuper
+    @Override
+    public void onStart(@Nullable Intent intent, int startId) {
+        mDispatcher.onServicePreSuperOnStart();
+        super.onStart(intent, startId);
+    }
+
+    // this method is added only to annotate it with @CallSuper.
+    // In usual service super.onStartCommand is no-op, but in LifecycleService
+    // it results in mDispatcher.onServicePreSuperOnStart() call, because
+    // super.onStartCommand calls onStart().
+    @CallSuper
+    @Override
+    public int onStartCommand(@Nullable Intent intent, int flags, int startId) {
+        return super.onStartCommand(intent, flags, startId);
+    }
+
+    @CallSuper
+    @Override
+    public void onDestroy() {
+        mDispatcher.onServicePreSuperOnDestroy();
+        super.onDestroy();
+    }
+
+    @Override
+    @NonNull
+    public Lifecycle getLifecycle() {
+        return mDispatcher.getLifecycle();
+    }
+}
+```
+
+
+
+## 整个应用进程的生命周期ProcessLifecycleOwner
+
+具有生命周期的系统组件除Activity、Fragment、Service外，还有Application。很多时候，我们会遇到这样的需求：我们想知道应用程序当前处在前台还是后台，或者当应用程序从后台回到前台时，我们能够得到通知。有不少方案能够实现该需求，但都不够好。在此之前，Google并没有为该需求提供官方解决方案，直到LifeCycle的出现。
+
+
+
+需要先添加lifecycle-process的依赖: 
+
+```
+implementation 'androidx.lifecycle:lifecycle-process:2.3.1'
+```
+
+```java
+
+/**
+ * Class that provides lifecycle for the whole application process.
+ * <p>
+ * You can consider this LifecycleOwner as the composite of all of your Activities, except that
+ * {@link Lifecycle.Event#ON_CREATE} will be dispatched once and {@link Lifecycle.Event#ON_DESTROY}
+ * will never be dispatched. Other lifecycle events will be dispatched with following rules:
+ * ProcessLifecycleOwner will dispatch {@link Lifecycle.Event#ON_START},
+ * {@link Lifecycle.Event#ON_RESUME} events, as a first activity moves through these events.
+ * {@link Lifecycle.Event#ON_PAUSE}, {@link Lifecycle.Event#ON_STOP}, events will be dispatched with
+ * a <b>delay</b> after a last activity
+ * passed through them. This delay is long enough to guarantee that ProcessLifecycleOwner
+ * won't send any events if activities are destroyed and recreated due to a
+ * configuration change.
+ *
+ * <p>
+ * It is useful for use cases where you would like to react on your app coming to the foreground or
+ * going to the background and you don't need a milliseconds accuracy in receiving lifecycle
+ * events.
+ */
+@SuppressWarnings("WeakerAccess")
+public class ProcessLifecycleOwner implements LifecycleOwner {
+```
+
+
+
+ProcessLifecycleOwner的使用方式与Activity、Fragment和Service是类似的，其本质也是观察者模式。由于我们要观察的是整个应用程序，因此，需要在Application中进行相关代码的编写。
+
+```kotlin
+class StApplication : Application() {
+    companion object {
+        private lateinit var instance: Application
+        fun getInstance() = instance
+    }
+
+    override fun onCreate() {
+        super.onCreate()
+        instance = this
+        ProcessLifecycleOwner.get().lifecycle.addObserver(MyApplicationObserver())
+    }
+}
+class MyApplicationObserver : LifecycleObserver {
+    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
+    fun onCreate() {
+
+    }
+    // 前台出现时调用
+    @OnLifecycleEvent(Lifecycle.Event.ON_START)
+    fun onStart() {
+        Log.e("@@@", "onStart")
+    }
+    // 前台出现时调用
+    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
+    fun onResume() {
+        Log.e("@@@", "onResume")
+    }
+    // 退出到后台时调用
+    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
+    fun onPause() {
+        Log.e("@@@", "onPause")
+    }
+    // 退出到后台时调用
+    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
+    fun onStop() {
+        Log.e("@@@", "onStop")
+    }
+}
+```
+
+当应用程序从后台回到前台，或者应用程序被首次打开时，会依次调用Lifecycle.Event.ON_START和Lifecycle.Event.ON_RESUME。
+
+ 当应用程序从前台退到后台（用户按下Home键或任务菜单键），会依次调用Lifecycle.Event.ON_PAUSE和Lifecycle.Event.ON_STOP。需要注意的是，这两个方法的调用会有一定的延后。这是因为系统需要为“屏幕旋转，由于配置发生变化而导致Activity重新创建”的情况预留一些时间。也就是说，系统需要保证当设备出现这种情况时，这两个事件不会被调用。因为当旋转屏幕时，你的应用程序并没有退到后台，它只是进入了横/竖屏模式而已。
+
+## 源码分析
+
+从上面的代码中基本可以看到了大体的实现过程。
+
+首先Activity、Fragment、Service、Application会去实现LifecycleOwner接口，它内部会去使用lifecycleRegistry，而lifecycleRegistry会在系统组件(Activity、Fragment、Service、Application)的声明周期方法中发送Event，给LifecycleObserver实现者中声明了对应注解的方法。
+
+这里使用Fragment类进行源码分析: 
+
+```java
+public class Fragment implements ComponentCallbacks, OnCreateContextMenuListener, LifecycleOwner,
+        ViewModelStoreOwner, SavedStateRegistryOwner {
+    LifecycleRegistry mLifecycleRegistry;   
+         
+    private void initLifecycle() {
+        mLifecycleRegistry = new LifecycleRegistry(this);
+        mSavedStateRegistryController = SavedStateRegistryController.create(this);
+        // >= Android 4.4才支持
+        if (Build.VERSION.SDK_INT >= 19) {
+            mLifecycleRegistry.addObserver(new LifecycleEventObserver() {
+                @Override
+                public void onStateChanged(@NonNull LifecycleOwner source,
+                        @NonNull Lifecycle.Event event) {
+                    if (event == Lifecycle.Event.ON_STOP) {
+                        if (mView != null) {
+                            mView.cancelPendingInputEvents();
+                        }
+                    }
+                }
+            });
+        }
+    }
+            
+    void performCreate(Bundle savedInstanceState) {
+        mChildFragmentManager.noteStateNotSaved();
+        mState = CREATED;
+        mCalled = false;
+        mSavedStateRegistryController.performRestore(savedInstanceState);
+        onCreate(savedInstanceState);
+        mIsCreated = true;
+        if (!mCalled) {
+            throw new SuperNotCalledException("Fragment " + this
+                    + " did not call through to super.onCreate()");
+        }
+        mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
+    }
+            
+    @Override
+    @NonNull
+    public Lifecycle getLifecycle() {
+        return mLifecycleRegistry;
+    }            
+}            
+```
+
+整体比较简单，首先是addObserver()添加，然后就是在Fragment对应的声明周期方法中去调用了mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);所以继续看一下mLifecycleRegistry类及其handleLifecycleEvent()方法:  
+
+```java
+/**
+ * An implementation of {@link Lifecycle} that can handle multiple observers.
+ * <p>
+ * It is used by Fragments and Support Library Activities. You can also directly use it if you have
+ * a custom LifecycleOwner.
+ */
+public class LifecycleRegistry extends Lifecycle {
+    // 使用了WweakReference
+    private final WeakReference<LifecycleOwner> mLifecycleOwner;
+       public LifecycleRegistry(@NonNull LifecycleOwner provider) {
+        this(provider, true);
+    }
+
+    private LifecycleRegistry(@NonNull LifecycleOwner provider, boolean          enforceMainThread) {
+        mLifecycleOwner = new WeakReference<>(provider);
+        // 初始状态
+        mState = INITIALIZED;
+        // 是否强制主线程使用，默认为true
+        mEnforceMainThread = enforceMainThread;
+    }
+    
+    public void addObserver(@NonNull LifecycleObserver observer) {
+        enforceMainThreadIfNeeded("addObserver");
+        State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
+        ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
+        ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
+
+        if (previous != null) {
+            return;
+        }
+        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
+        if (lifecycleOwner == null) {
+            // it is null we should be destroyed. Fallback quickly
+            return;
+        }
+
+        boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
+        State targetState = calculateTargetState(observer);
+        mAddingObserverCounter++;
+        while ((statefulObserver.mState.compareTo(targetState) < 0
+                && mObserverMap.contains(observer))) {
+            pushParentState(statefulObserver.mState);
+            final Event event = Event.upFrom(statefulObserver.mState);
+            if (event == null) {
+                throw new IllegalStateException("no event up from " + statefulObserver.mState);
+            }
+            statefulObserver.dispatchEvent(lifecycleOwner, event);
+            popParentState();
+            // mState / subling may have been changed recalculate
+            targetState = calculateTargetState(observer);
+        }
+
+        if (!isReentrance) {
+            // we do sync only on the top level.
+            sync();
+        }
+        mAddingObserverCounter--;
+    }
+    
+    public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
+        // 检查是不是主线程
+        enforceMainThreadIfNeeded("handleLifecycleEvent");
+        moveToState(event.getTargetState());
+    }
+    
+    private void moveToState(State next) {
+        if (mState == next) {
+            return;
+        }
+        mState = next;
+        // 都是已经正在执行的状态，直接return
+        if (mHandlingEvent || mAddingObserverCounter != 0) {
+            mNewEventOccurred = true;
+            // we will figure out what to do on upper level.
+            return;
+        }
+        mHandlingEvent = true;
+        sync();
+        mHandlingEvent = false;
+    }
+    
+    private void sync() {
+        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
+        if (lifecycleOwner == null) {
+            throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"
+                    + "garbage collected. It is too late to change lifecycle state.");
+        }
+        while (!isSynced()) {
+            mNewEventOccurred = false;
+            // no need to check eldest for nullability, because isSynced does it for us.
+            // 比较的是出现的顺序，如果下一个周期小于当前周期，就执行backwardPass
+            if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
+                // 对Lifecycle.State的前后顺序的比较也就反应了声明周期状态的变换，比如活动此时的生命周期为Resumed（此时mObserverMap中保存的状态为Resumed），而下一个变换的状态为Started(此时的mState为Started)，从声明周期中可以知道此时执行的时onPause（），对应的LIfecycle.Event为ON_PAUSE，那么上述逻辑中此时执行的是
+                backwardPass(lifecycleOwner);
+            }
+            Map.Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
+            if (!mNewEventOccurred && newest != null
+                    && mState.compareTo(newest.getValue().mState) > 0) {
+                forwardPass(lifecycleOwner);
+            }
+        }
+        mNewEventOccurred = false;
+    }
+    
+    private void forwardPass(LifecycleOwner lifecycleOwner) {
+        Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
+                mObserverMap.iteratorWithAdditions();
+        while (ascendingIterator.hasNext() && !mNewEventOccurred) {
+            Map.Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
+            ObserverWithState observer = entry.getValue();
+            while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
+                    && mObserverMap.contains(entry.getKey()))) {
+                pushParentState(observer.mState);
+                final Event event = Event.upFrom(observer.mState);
+                if (event == null) {
+                    throw new IllegalStateException("no event up from " + observer.mState);
+                }
+                observer.dispatchEvent(lifecycleOwner, event);
+                popParentState();
+            }
+        }
+    }
+
+    private void backwardPass(LifecycleOwner lifecycleOwner) {
+        Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
+                mObserverMap.descendingIterator();
+        while (descendingIterator.hasNext() && !mNewEventOccurred) {
+            Map.Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
+            // 获取当前保存的 ObserverWithState  从中提取状态
+            ObserverWithState observer = entry.getValue();
+            while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
+                    && mObserverMap.contains(entry.getKey()))) {
+                // 如果保存的状态大于 要变化的状态 向前修改，查找对应周期变化的事件
+                Event event = Event.downFrom(observer.mState);
+                if (event == null) {
+                    throw new IllegalStateException("no event down from " + observer.mState);
+                }
+                pushParentState(event.getTargetState());
+                // 发送事件
+                observer.dispatchEvent(lifecycleOwner, event);
+                popParentState();
+            }
+        }
+    }
+    /**
+         * Returns the {@link Lifecycle.Event} that will be reported by a {@link Lifecycle}
+         * leaving the specified {@link Lifecycle.State} to a lower state, or {@code null}
+         * if there is no valid event that can move down from the given state.
+         *
+         * @param state the higher state that the returned event will transition down from
+         * @return the event moving down the lifecycle phases from state
+         */
+    public static Event downFrom(@NonNull State state) {
+        switch (state) {
+            case CREATED:
+                return ON_DESTROY;
+            case STARTED:
+                return ON_STOP;
+            case RESUMED:
+                return ON_PAUSE;
+            default:
+                return null;
+        }
+    }
+    
+    
+        /**
+         * Returns the {@link Lifecycle.Event} that will be reported by a {@link Lifecycle}
+         * leaving the specified {@link Lifecycle.State} to a higher state, or {@code null}
+         * if there is no valid event that can move up from the given state.
+         *
+         * @param state the lower state that the returned event will transition up from
+         * @return the event moving up the lifecycle phases from state
+         */
+        @Nullable
+        public static Event upFrom(@NonNull State state) {
+            switch (state) {
+                case INITIALIZED:
+                    return ON_CREATE;
+                case CREATED:
+                    return ON_START;
+                case STARTED:
+                    return ON_RESUME;
+                default:
+                    return null;
+            }
+        }
+}    
+```
+
+发送event是用的ObserverWithState类的observer.dispatchEvent(lifecycleOwner, event);，这里继续看一下ObserverWithState类: 
+
+```java
+    static class ObserverWithState {
+        State mState;
+        LifecycleEventObserver mLifecycleObserver;
+
+        ObserverWithState(LifecycleObserver observer, State initialState) {
+            // 根据observer创建GenericLifecycleObserver对象
+            mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
+            mState = initialState;
+        }
+
+        void dispatchEvent(LifecycleOwner owner, Event event) {
+            State newState = getStateAfter(event);
+            mState = min(mState, newState);
+            mLifecycleObserver.onStateChanged(owner, event);
+            mState = newState;
+        }
+    }
+```
+
+会先调用Lifecycling.lifecycleEventObserver()方法创建一个LifecycleEventObserver对象: 
+
+```java
+// Lifecycling.lifecycleEventObserver()
+   static LifecycleEventObserver lifecycleEventObserver(Object object) {
+        boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
+        boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
+        if (isLifecycleEventObserver && isFullLifecycleObserver) {
+            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
+                    (LifecycleEventObserver) object);
+        }
+        if (isFullLifecycleObserver) {
+            return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
+        }
+
+        if (isLifecycleEventObserver) {
+            return (LifecycleEventObserver) object;
+        }
+
+        final Class<?> klass = object.getClass();
+        int type = getObserverConstructorType(klass);
+        if (type == GENERATED_CALLBACK) {
+            List<Constructor<? extends GeneratedAdapter>> constructors =
+                    sClassToAdapters.get(klass);
+            if (constructors.size() == 1) {
+                GeneratedAdapter generatedAdapter = createGeneratedAdapter(
+                        constructors.get(0), object);
+                return new SingleGeneratedAdapterObserver(generatedAdapter);
+            }
+            GeneratedAdapter[] adapters = new GeneratedAdapter[constructors.size()];
+            for (int i = 0; i < constructors.size(); i++) {
+                adapters[i] = createGeneratedAdapter(constructors.get(i), object);
+            }
+            return new CompositeGeneratedAdaptersObserver(adapters);
+        }
+        return new ReflectiveGenericLifecycleObserver(object);
+    }
+```
+
+这个方法的目的是根据不同类型的obsever来创建对应的LifecycleEventObserver接口的实现类，它的实现类会重写onStateChanged()方法，这里以ReflectiveGenericLifecycleObserver为例:  
+
+```java
+class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
+    private final Object mWrapped;
+    private final CallbackInfo mInfo;
+
+    ReflectiveGenericLifecycleObserver(Object wrapped) {
+        mWrapped = wrapped;
+        // 将当前observer类的class文件传入getInfo方法
+        mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
+    }
+
+    @Override
+    public void onStateChanged(LifecycleOwner source, Event event) {
+        // 调用callbackInfo.invokeCallbacks()
+        mInfo.invokeCallbacks(source, event, mWrapped);
+    }
+}
+```
+
+而CallbackInfo类的实现： 
+
+```java
+CallbackInfo getInfo(Class klass) {
+    CallbackInfo existing = mCallbackMap.get(klass);
+    if (existing != null) {
+        return existing;
+    }
+    existing = createInfo(klass, null);
+    return existing;
+}
+
+    private CallbackInfo createInfo(Class klass, @Nullable Method[] declaredMethods) {
+        Class superclass = klass.getSuperclass();
+        Map<MethodReference, Lifecycle.Event> handlerToEvent = new HashMap<>();
+        if (superclass != null) {
+            CallbackInfo superInfo = getInfo(superclass);
+            if (superInfo != null) {
+                handlerToEvent.putAll(superInfo.mHandlerToEvent);
+            }
+        }
+
+        Class[] interfaces = klass.getInterfaces();
+        for (Class intrfc : interfaces) {
+            for (Map.Entry<MethodReference, Lifecycle.Event> entry : getInfo(
+                    intrfc).mHandlerToEvent.entrySet()) {
+                verifyAndPutHandler(handlerToEvent, entry.getKey(), entry.getValue(), klass);
+            }
+        }
+        // 获取所有observer声明的方法
+        Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);
+        boolean hasLifecycleMethods = false;
+        for (Method method : methods) {
+            // 判断方法上是否有OnLifecycleEvent的注解
+            OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
+            if (annotation == null) {
+                continue;
+            }
+            hasLifecycleMethods = true;
+            Class<?>[] params = method.getParameterTypes();
+            int callType = CALL_TYPE_NO_ARG;
+            if (params.length > 0) {
+                callType = CALL_TYPE_PROVIDER;
+                if (!params[0].isAssignableFrom(LifecycleOwner.class)) {
+                    throw new IllegalArgumentException(
+                            "invalid parameter type. Must be one and instanceof LifecycleOwner");
+                }
+            }
+            // 获取注解对应的event
+            Lifecycle.Event event = annotation.value();
+
+            if (params.length > 1) {
+                callType = CALL_TYPE_PROVIDER_WITH_EVENT;
+                if (!params[1].isAssignableFrom(Lifecycle.Event.class)) {
+                    throw new IllegalArgumentException(
+                            "invalid parameter type. second arg must be an event");
+                }
+                if (event != Lifecycle.Event.ON_ANY) {
+                    throw new IllegalArgumentException(
+                            "Second arg is supported only for ON_ANY value");
+                }
+            }
+            if (params.length > 2) {
+                throw new IllegalArgumentException("cannot have more than 2 params");
+            }
+            // 封装参数和方法
+            MethodReference methodReference = new MethodReference(callType, method);
+            verifyAndPutHandler(handlerToEvent, methodReference, event, klass);
+        }
+        CallbackInfo info = new CallbackInfo(handlerToEvent);
+        // 保存下来
+        mCallbackMap.put(klass, info);
+        mHasLifecycleMethods.put(klass, hasLifecycleMethods);
+        return info;
+    }
+```
+
+而invokeCallback()方法就会去回调执行observer中声明了注解的方法，实现如下: 
+
+```java
+void invokeCallbacks(LifecycleOwner source, Lifecycle.Event event, Object target) {
+    invokeMethodsForEvent(mEventToHandlers.get(event), source, event, target);
+    invokeMethodsForEvent(mEventToHandlers.get(Lifecycle.Event.ON_ANY), source, event,
+                          target);
+}
+
+private static void invokeMethodsForEvent(List<MethodReference> handlers,
+                                          LifecycleOwner source, Lifecycle.Event event, Object mWrapped) {
+    if (handlers != null) {
+        for (int i = handlers.size() - 1; i >= 0; i--) {
+            handlers.get(i).invokeCallback(source, event, mWrapped);
+        }
+    }
+}
+```
+
+
+
+
+
+
+[上一篇: 2.集成(二)](https://github.com/CharonChui/AndroidNote/blob/master/ArchitectureComponents/2.%E9%9B%86%E6%88%90(%E4%BA%8C).md)
+[下一篇: 4.LiveData(四)](https://github.com/CharonChui/AndroidNote/blob/master/ArchitectureComponents/4.LiveData(%E5%9B%9B).md)
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! `
\ No newline at end of file
diff --git a/Jetpack/architecture/4.ViewModel.md b/Jetpack/architecture/4.ViewModel.md
new file mode 100644
index 00000000..9c6c9f47
--- /dev/null
+++ b/Jetpack/architecture/4.ViewModel.md
@@ -0,0 +1,349 @@
+4.ViewModel
+===
+
+`Android`系统提供控件，比如`Activity`和`Fragment`，这些控件都是具有生命周期方法，这些生命周期方法被系统调用。
+
+当这些控件被销毁或者被重建的时候，如果数据保存在这些对象中，那么数据就会丢失。比如在一个界面，保存了一些用户信息，当界面重新创建的时候，就需要重新去获取数据。当然了也可以使用控件自动再带的方法，在`onSaveInstanceState`方法中保存数据，在`onCreate`中重新获得数据，但这仅仅在数据量比较小的情况下。如果数据量很大，这种方法就不能适用了。
+
+另外一个问题就是，经常需要在`Activity`中加载数据，这些数据可能是异步的，因为获取数据需要花费很长的时间。那么`Activity`就需要管理这些数据调用，否则很有可能会产生内存泄露问题。最后需要做很多额外的操作，来保证程序的正常运行。
+
+同时`Activity`不仅仅只是用来加载数据的，还要加载其他资源，做其他的操作，最后`Activity`类变大，就是我们常讲的上帝类。也有不少架构是把一些操作放到单独的类中，比如`MVP`就是这样，创建相同类似于生命周期的函数做代理，这样可以减少`Activity`的代码量，但是这样就会变得很复杂，同时也难以测试。
+
+`ViewModel`是专门用于存放应用程序页面所需的数据。ViewModel将页面所需的数据从页面中剥离出来，页面只需要处理用户交互和展示数据。
+
+Viewmodel解决两个问题: 
+
+1. 数据的变更与view隔离，也就是解耦
+2. 开发者不需要额外去关心因为屏幕旋转带来的数据恢复问题
+
+## 依赖
+
+```
+dependencies {
+    def lifecycle_version = "2.3.1"
+
+    // ViewModel
+    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"
+}
+```
+
+
+
+
+
+实现`ViewModel`
+---
+
+ViewModel是一个抽象类，其中只有一个onCleared()方法。当ViewModel不再被需要，即与之相关的Activity都被销毁时，该方法会被系统调用。我们可以在该方法中执行一些资源释放的相关操作。注意，由于屏幕旋转而导致的Activity重建，并不会调用该方法。
+
+```kotlin
+class TimerViewModel : ViewModel() {
+    private val timer: Timer = Timer()
+    private var timeChangeListener: OnTimeChangeLister? = null
+    private var currentSecond: Int = 0
+    fun start() {
+        timer.schedule(timerTask {
+            currentSecond++
+            timeChangeListener?.onTimeChanged(currentSecond)
+        }, 1000, 1000)
+    }
+
+    override fun onCleared() {
+        super.onCleared()
+        timer.cancel()
+    }
+
+    fun setOnTimeChangeListener(listener: OnTimeChangeLister) {
+        timeChangeListener = listener
+    }
+
+    interface OnTimeChangeLister {
+        fun onTimeChanged(second: Int)
+    }
+}
+```
+
+ViewModel的实例化过程，是通过ViewModelProvider来完成的。ViewModelProvider会判断ViewModel是否存在，若存在则直接返回，否则它会创建一个ViewModel。
+
+```kotlin
+class MainActivity : AppCompatActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_main)
+        val tv = findViewById<TextView>(R.id.tv)
+        val model = ViewModelProvider(this).get(TimerViewModel::class.java)
+        model.setOnTimeChangeListener(object : TimerViewModel.OnTimeChangeLister {
+            override fun onTimeChanged(second: Int) {
+                runOnUiThread {
+                    tv.text = second.toString()
+                }
+            }
+        })
+        model.start()
+    }
+}
+```
+
+运行程序并旋转屏幕。当旋转屏幕导致Activity重建时，计时器并没有停止。这意味着，横/竖屏状态下的Activity所对应的ViewModel是同一个，它并没有被销毁，它所持有的数据也一直都存在着。
+
+
+
+
+
+
+`ViewModel`的生命周期
+---
+
+`ViewModel`在获取`ViewModel`对象时会通过`ViewModelProvider`的传递来绑定对应的声明周期。   
+`ViewModel`只有在`Activity finish`或者`Fragment detach`之后才会销毁。
+
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/viewmodel-lifecycle.png" width="100%" height="100%">
+
+
+
+在`Fragments`间分享数据
+---
+
+有时候一个`Activity`中的两个或多个`Fragment`需要分享数据或者相互通信，这样就会带来很多问题，比如数据获取，相互确定生命周期。
+
+使用`ViewModel`可以很好的解决这个问题。假设有这样两个`Fragment`，一个`Fragment`提供一个列表，另一个`Fragment`提供点击每个`item`现实的详细信息。
+
+
+```java
+public class SharedViewModel extends ViewModel {
+    private final MutableLiveData<Item> selected = new MutableLiveData<Item>();
+
+    public void select(Item item) {
+        selected.setValue(item);
+    }
+
+    public LiveData<Item> getSelected() {
+        return selected;
+    }
+}
+
+public class MasterFragment extends Fragment {
+    private SharedViewModel model;
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        model = ViewModelProviders.of(getActivity()).get(SharedViewModel.class);
+        itemSelector.setOnClickListener(item -> {
+            model.select(item);
+        });
+    }
+}
+
+public class DetailFragment extends LifecycleFragment {
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        SharedViewModel model = ViewModelProviders.of(getActivity()).get(SharedViewModel.class);
+        model.getSelected().observe(this, { item ->
+           // update UI
+        });
+    }
+}
+```
+
+两个`Fragment`都是通过`getActivity()`来获取`ViewModelProvider`。这意味着两个`Activity`都是获取的属于同一个`Activity`的同一个`ShareViewModel`实例。
+这样做优点如下:   
+
+- `Activity`不需要写任何额外的代码，也不需要关心`Fragment`之间的通信。
+- `Fragment`不需要处理除`SharedViewModel`以外其他的代码。这两个`Fragment`不需要知道对方是否存在。
+- `Fragment`的生命周期不会相互影响
+
+
+
+
+`ViewModel`和`SavedInstanceState`对比
+---
+
+`ViewModel`使得在`configuration change`（旋转屏幕等）保存数据变的十分方便，但是这不能用于应用被系统杀死时持久化数据。举个简单的例子，有一个界面展示国家信息。
+不应该把整个国家信息放到`SavedInstanceState`里，而是把国家对应的`id`放到`SavedInstanceState`，等到界面恢复时，再通过`id`去获取详细的信息。这些详细的信息应该被存放在数据库中。
+
+
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/viewModel_saveinstancestate.png" width="100%" height="100%">
+
+
+Jetpack ViewModel 并不等价于 MVVM ViewModel
+
+经常有小伙伴将Jetpack ViewModel 和 MVVM ViewModel，其实这二者根本没有在同一个层次，MVVM ViewModel是MVVM架构中的一个角色，看不见摸不着只是一种思想。 而Jetpack ViewModel是一个实实在在的框架用于做状态托管，有对应的作用域可跟随Activity/Fragment生命周期，但这种特性恰好可以充当MVVM ViewModel的角色，分隔数据层和视图层并做数据托管。
+
+所以结论是Jetpack ViewModel可以充当MVVM ViewModel 但二者并不等价
+
+
+但jetpack的组件是可以分别使用的，所以可以先熟悉各个组件，然后往自己的项目里套。我个人觉得特别好的组件有：ViewModel，LiveData，Room，Navigation，极好的架构梳理觉得一般的：data-binding，view-binding，感觉有一定用，但也有成本，不用也行觉得不好用的：Paging，感觉封装太死板。如果前后端同步是紧要业务行为，那么我宁愿自己写这个功能
+
+
+
+## ViewModel原理
+
+```kotlin
+val model = ViewModelProvider(this).get(TimerViewModel::class.java)
+```
+
+首先看ViewModelProvider的源码:  
+
+```java
+public class ViewModelProvider {
+    private final Factory mFactory;
+    private final ViewModelStore mViewModelStore;
+
+    /**
+     * Creates {@code ViewModelProvider}. This will create {@code ViewModels}
+     * and retain them in a store of the given {@code ViewModelStoreOwner}.
+     * <p>
+     * This method will use the
+     * {@link HasDefaultViewModelProviderFactory#getDefaultViewModelProviderFactory() default factory}
+     * if the owner implements {@link HasDefaultViewModelProviderFactory}. Otherwise, a
+     * {@link NewInstanceFactory} will be used.
+     */
+    public ViewModelProvider(@NonNull ViewModelStoreOwner owner) {
+        this(owner.getViewModelStore(), owner instanceof HasDefaultViewModelProviderFactory
+                ? ((HasDefaultViewModelProviderFactory) owner).getDefaultViewModelProviderFactory()
+                : NewInstanceFactory.getInstance());
+    }
+    
+    public ViewModelProvider(@NonNull ViewModelStore store, @NonNull Factory factory) {
+        mFactory = factory;
+        mViewModelStore = store;
+    }
+    
+        public <T extends ViewModel> T get(@NonNull Class<T> modelClass) {
+        String canonicalName = modelClass.getCanonicalName();
+        if (canonicalName == null) {
+            throw new IllegalArgumentException("Local and anonymous classes can not be ViewModels");
+        }
+        return get(DEFAULT_KEY + ":" + canonicalName, modelClass);
+    }
+     public <T extends ViewModel> T get(@NonNull String key, @NonNull Class<T> modelClass) {
+        ViewModel viewModel = mViewModelStore.get(key);
+
+        if (modelClass.isInstance(viewModel)) {
+            if (mFactory instanceof OnRequeryFactory) {
+                ((OnRequeryFactory) mFactory).onRequery(viewModel);
+            }
+            return (T) viewModel;
+        } else {
+            //noinspection StatementWithEmptyBody
+            if (viewModel != null) {
+                // TODO: log a warning.
+            }
+        }
+        if (mFactory instanceof KeyedFactory) {
+            viewModel = ((KeyedFactory) mFactory).create(key, modelClass);
+        } else {
+            viewModel = mFactory.create(modelClass);
+        }
+        mViewModelStore.put(key, viewModel);
+        return (T) viewModel;
+    }
+    
+}    
+```
+
+
+
+
+
+ViewModelProvider接收一个ViewModelStoreOwner对象作为参数。在以上示例代码中该参数是this，指代当前的Activity。这是因为我们的Activity继承自ComponentActivity，而在androidx依赖包中，ComponentActivity默认实现了ViewModelStoreOwner接口。
+
+```java
+public class ComponentActivity extends androidx.core.app.ComponentActivity implements
+        LifecycleOwner,
+        ViewModelStoreOwner,
+        SavedStateRegistryOwner,
+        OnBackPressedDispatcherOwner {
+            
+    public ViewModelStore getViewModelStore() {
+        if (getApplication() == null) {
+            throw new IllegalStateException("Your activity is not yet attached to the "
+                    + "Application instance. You can't request ViewModel before onCreate call.");
+        }
+        if (mViewModelStore == null) {
+            NonConfigurationInstances nc =
+                    (NonConfigurationInstances) getLastNonConfigurationInstance();
+            if (nc != null) {
+                // Restore the ViewModelStore from NonConfigurationInstances
+                mViewModelStore = nc.viewModelStore;
+            }
+            if (mViewModelStore == null) {
+                mViewModelStore = new ViewModelStore();
+            }
+        }
+        return mViewModelStore;
+    }            
+}
+```
+
+```java
+public interface ViewModelStoreOwner {
+    /**
+     * Returns owned {@link ViewModelStore}
+     *
+     * @return a {@code ViewModelStore}
+     */
+    @NonNull
+    ViewModelStore getViewModelStore();
+}
+```
+
+ViewModelStore类的代码是: 
+
+```java
+public class ViewModelStore {
+
+    private final HashMap<String, ViewModel> mMap = new HashMap<>();
+
+    final void put(String key, ViewModel viewModel) {
+        ViewModel oldViewModel = mMap.put(key, viewModel);
+        if (oldViewModel != null) {
+            oldViewModel.onCleared();
+        }
+    }
+
+    final ViewModel get(String key) {
+        return mMap.get(key);
+    }
+
+    Set<String> keys() {
+        return new HashSet<>(mMap.keySet());
+    }
+
+    /**
+     *  Clears internal storage and notifies ViewModels that they are no longer used.
+     */
+    public final void clear() {
+        for (ViewModel vm : mMap.values()) {
+            vm.clear();
+        }
+        mMap.clear();
+    }
+}
+```
+
+从ViewModelStore的源码可以看出，ViewModel实际上是以HashMap<String，ViewModel>的形式被缓存起来了。ViewModel与页面之间没有直接的关联，它们通过ViewModelProvider进行关联。当页面需要ViewModel时，会向ViewModelProvider索要，ViewModelProvider检查该ViewModel是否已经存在于缓存中，若存在，则直接返回，若不存在，则实例化一个。因此，Activity由于配置变化导致的销毁重建并不会影响ViewModel，ViewModel是独立于页面而存在的。也正因为此，我们在使用ViewModel时，需要特别注意，不要向ViewModel中传入任何类型的Context或带有Context引用的对象，这可能会导致页面无法被销毁，从而引发内存泄漏。
+
+
+
+## ViewModel与AndroidViewModel
+
+前面提到过，在使用ViewModel时，不能将任何类型的Context或含有Context引用的对象传入ViewModel，因为这可能会导致内存泄漏。但如果你希望在ViewModel中使用Context，该怎么办呢？可以使用AndroidViewModel类，它继承自ViewModel，并接收Application作为Context。这意味着，它的生命周期和Application是一样的，那么这就不算是一个内存泄漏了。
+
+
+
+
+
+在上面的示例中，我们通过自定义接口OnTimeChangeListener来完成ViewModel与页面之间的通信。这不是一个好的方案。Jetpack为我们提供了LiveData组件来解决这个问题。通过LiveData，当ViewModel中的数据发生变化时，页面能自动收到通知，进而更新UI。
+
+
+
+[上一篇: 4.LiveData(四)](https://github.com/CharonChui/AndroidNote/blob/master/ArchitectureComponents/4.LiveData(%E5%9B%9B).md)
+[下一篇: 6.Room(六)](https://github.com/CharonChui/AndroidNote/blob/master/ArchitectureComponents/6.Room(%E5%85%AD).md)
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! `
\ No newline at end of file
diff --git a/Jetpack/architecture/5.LiveData.md b/Jetpack/architecture/5.LiveData.md
new file mode 100644
index 00000000..5c4e4c44
--- /dev/null
+++ b/Jetpack/architecture/5.LiveData.md
@@ -0,0 +1,430 @@
+5.LiveData
+===
+
+ViewModel的主要作用是存放页面所需要的各种数据。我们在示例代码中定义了接口，当数据发生变化时，采用接口的方式实现对页面的通知。对此前面已经做了相关说明，通过接口的方式对页面进行通知是可行的，但如果要观察的数据很多，则需要定义大量的接口，代码会显得十分冗余。为此，Jetpack提供了LiveData组件。
+
+LiveData是一个可被观察的数据容器类。具体说来，可以将LiveData理解为一个数据的容器，它将数据包装起来，使数据成为被观察者，当该数据发生变化时，观察者能够获得通知。我们不需要自己去实现观察者模式，LiveData内部已经默认实现好了，我们只要使用就可以了。
+
+LiveData取代了上一章中所定义的接口，帮助我们完成ViewModel与页面之间的通信。
+
+> LiveData is an observable data holder class. Unlike a regular observable, LiveData is lifecycle-aware, meaning it respects the lifecycle of other app components, such as activities, fragments, or services. This awareness ensures LiveData only updates app component observers that are in an active lifecycle state.
+
+`LiveData`是一种持有可被观察数据的类。和其他可被观察的类不同的是，`LiveData`是有生命周期感知能力的，这意味着它可以在`activities`,`fragments`,或者`services`生命周期是活跃状态时更新这些组件。那么什么是活跃状态呢？上篇文章中提到的`STARTED`和`RESUMED`就是活跃状态，只有在这两个状态下`LiveData`是会通知数据变化的。
+
+要想使用`LiveData`（或者这种有可被观察数据能力的类）就必须配合实现了`LifecycleOwner`的对象使用。在这种情况下，当对应的生命周期对象`DESTROYED`时，才能移除观察者。这对`Activity`或者`Fragment`来说显得尤为重要，因为他们可以在生命周期结束的时候立刻解除对数据的订阅，从而避免内存泄漏等问题。
+
+
+
+
+使用`LiveData`的优点:   
+
+- `UI`和实时数据保持一致 因为`LiveData`采用的是观察者模式，这样一来就可以在数据发生改变时获得通知，更新`UI`。
+- 避免内存泄漏,观察者被绑定到组件的生命周期上，当被绑定的组件销毁（`destory`）时，观察者会立刻自动清理自身的数据。
+- 不会再产生由于`Activity`处于`stop`状态而引起的崩溃 例如:当`Activity`处于后台状态时，是不会收到`LiveData`的任何事件的。
+- 不需要再解决生命周期带来的问题`LiveData`可以感知被绑定的组件的生命周期，只有在活跃状态才会通知数据变化。
+- 实时数据刷新,当组件处于活跃状态或者从不活跃状态到活跃状态时总是能收到最新的数据
+- 解决`Configuration Change`问题,在屏幕发生旋转或者被回收再次启动，立刻就能收到最新的数据。
+- 数据共享,如果对应的`LiveData`是单例的话，就能在`app`的组件间分享数据。
+
+## LiveData与ViewModel
+
+ViewModel用于存放页面所需要的各种数据，不仅如此，我们还可以在其中放一些与数据相关的业务逻辑。例如，我们可以在ViewModel中进行数据的加工、获取等操作。因此，ViewModel中的数据可能会随着业务的变化而变化。对页面来说，它并不关心ViewModel中的业务逻辑，它只关心需要展示的数据是什么，并且希望在数据发生变化时，能及时得到通知并做出更新。LiveData的作用就是，在ViewModel中的数据发生变化时通知页面。因此，LiveData通常被放在ViewModel
+
+
+
+
+
+
+
+使用`LiveData`:      
+
+- 创建一个持有某种数据类型的`LiveData`(通常是在`ViewModel`中)
+- 创建一个定义了`onChange()`方法的观察者。这个方法是控制`LiveData`中数据发生变化时，采取什么措施 (比如更新界面)。通常是在`UI Controller`(`Activity/Fragment`)中创建这个观察者。
+- 通过`observe()`方法连接观察者和`LiveData`。`observe()`方法需要携带一个`LifecycleOwner`类。这样就可以让观察者订阅`LiveData`中的数据，实现实时更新。
+
+
+创建`LiveData`对象
+--- 
+
+LiveData是一个抽象类，不能直接使用。通常我们使用的是它的直接子类MutableLiveData。
+
+`LiveData`是一个数据的包装。具体的包装对象可以是任何数据，包括集合（比如`List`）。`LiveData`通常在`ViewModel`中创建，然后通过`getter`方法获取。具体可以看一下代码:   
+
+```kotlin
+class TimerViewModel : ViewModel() {
+    private val timer: Timer = Timer()
+    private var currentSecond: MutableLiveData<Int> = MutableLiveData()
+    fun start() {
+        timer.schedule(timerTask {
+            var value = currentSecond.value
+            val plus = value?.plus(1)
+            currentSecond.postValue(plus)
+        }, 1000, 1000)
+    }
+
+    fun getCurrentSecond() : LiveData<Int> {
+        return currentSecond
+    }
+    override fun onCleared() {
+        super.onCleared()
+        timer.cancel()
+    }
+}
+```
+
+观察`LiveData`中的数据
+---
+
+
+通常情况下都是在组件的`onCreate()`方法中开始观察数据，原因有以下两点:   
+
+- 系统会多次调用`onResume()`方法
+- 确保`Activity/Fragment`在处于活跃状态时立刻可以展示数据。
+
+```kotlin
+class MainActivity : AppCompatActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_main)
+        val tv = findViewById<TextView>(R.id.tv)
+        val model = ViewModelProvider(this).get(TimerViewModel::class.java)
+        // 得到ViewModel中的LiveData
+        val liveData = model.getCurrentSecond() as MutableLiveData<Int>
+        liveData.observe(this, object : Observer<Int> {
+            override fun onChanged(t: Int?) {
+                tv.text = t.toString()
+            }
+        })
+        // 重置
+        liveData.postValue(0)
+        model.start()
+    }
+}
+```
+
+更新`LiveData`对象
+---
+
+
+如果想要在`UI Controller`中改变`LiveData`中的值呢？（比如点击某个`Button`把性别从男设置成女）。`LiveData`并没有提供这样的功能，但是`Architecture Component`提供了`MutableLiveData`这样一个类，可以通过`setValue(T)`和`postValue(T)`方法来修改存储在`LiveData`中的数据。`MutableLiveData`是`LiveData`的一个子类，从名称上也能看出这个类的作用。举个直观点的例子:  
+
+```java
+mButton.setOnClickListener(new OnClickListener() {
+    @Override
+    public void onClick(View v) {
+        String anotherName = "John Doe";
+        mModel.getCurrentName().setValue(anotherName);
+    }
+})
+```
+调用`setValue()`方法就可以把`LiveData`中的值改为`John Doe`。同样通过这种方法修改`LiveData`中的值同样会触发所有对这个数据感兴趣的类。那么`setValue()`和`postValue()`有什么不同呢？区别就是`setValue()`只能在主线程中调用，而`postValue()`可以在子线程中调用。
+
+
+
+## observeForever
+
+LiveData还提供了一个名为observeForever()的方法，使用起来与observe()没有太大差别。它们的区别主要在于，当LiveData所包装的数据发生变化时，无论页面处于什么状态，observeForever()都能收到通知。因此，在用完之后，一定要记得调用removeObserver()方法来停止对LiveData的观察，否则LiveData会一直处于激活状态，Activity则永远不会被系统自动回收，这就造成了内存泄漏。
+
+
+
+## 源码
+
+从上面的使用中，我们知道主要有两个重要的方法，分别是observe()方法和setValue()方法: 
+
+```java
+    @MainThread
+    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
+        assertMainThread("observe");
+        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
+            // ignore
+            return;
+        }
+        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
+        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
+        if (existing != null && !existing.isAttachedTo(owner)) {
+            throw new IllegalArgumentException("Cannot add the same observer"
+                    + " with different lifecycles");
+        }
+        if (existing != null) {
+            return;
+        }
+        // 将Observer与Activity的生命周期关联在一起。因此，LiveData能够感知页面的生命周期。它可以检测页面当前的状态是否为激活状态，或者页面是否被销毁。只有在页面处于激活状态（Lifecycle.State.ON_STARTED或Lifecycle.State.ON_RESUME）时，页面才能收到来自LiveData的通知，若页面被销毁（Lifecycle.State.ON_DESTROY），那么LiveData会自动清除与页面的关联，从而避免可能引发的内存泄漏问题。
+        owner.getLifecycle().addObserver(wrapper);
+    }
+```
+
+```java
+
+    /**
+     * Sets the value. If there are active observers, the value will be dispatched to them.
+     * <p>
+     * This method must be called from the main thread. If you need set a value from a background
+     * thread, you can use {@link #postValue(Object)}
+     *
+     * @param value The new value
+     */
+    @MainThread
+    protected void setValue(T value) {
+        assertMainThread("setValue");
+        mVersion++;
+        mData = value;
+        dispatchingValue(null);
+    }
+
+    void dispatchingValue(@Nullable ObserverWrapper initiator) {
+        if (mDispatchingValue) {
+            mDispatchInvalidated = true;
+            return;
+        }
+        mDispatchingValue = true;
+        do {
+            mDispatchInvalidated = false;
+            if (initiator != null) {
+                considerNotify(initiator);
+                initiator = null;
+            } else {
+                for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
+                        mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
+                    // 遍历mObservers，调用considerNotify()更新数据
+                    considerNotify(iterator.next().getValue());
+                    if (mDispatchInvalidated) {
+                        break;
+                    }
+                }
+            }
+        } while (mDispatchInvalidated);
+        mDispatchingValue = false;
+    }
+```
+
+```java
+// considerNotify()方法:   
+    private void considerNotify(ObserverWrapper observer) {
+        if (!observer.mActive) {
+            return;
+        }
+        // Check latest state b4 dispatch. Maybe it changed state but we didn't get the event yet.
+        //
+        // we still first check observer.active to keep it as the entrance for events. So even if
+        // the observer moved to an active state, if we've not received that event, we better not
+        // notify for a more predictable notification order.
+        if (!observer.shouldBeActive()) {
+            observer.activeStateChanged(false);
+            return;
+        }
+        if (observer.mLastVersion >= mVersion) {
+            return;
+        }
+        observer.mLastVersion = mVersion;
+        //回调onChanged()方法
+        observer.mObserver.onChanged((T) mData);
+    }
+```
+
+
+
+
+
+
+`Room`和`LiveData`配合使用
+--- 
+
+`Room`可以返回`LiveData`的数据类型。这样对数据库中的任何改动都会被传递出去。这样修改完数据库就能获取最新的数据，减少了主动获取数据的代码。
+
+继承`LiveData`扩展功能
+---
+
+`LiveData`的活跃状态包括:`STARTED`或者`RESUMED`两种状态。那么如何在活跃状态下把数据传递出去呢？下面是示例代码:  
+
+```kotlin
+class StockLiveData(symbol: String) : LiveData<BigDecimal>() {
+    private val stockManager = StockManager(symbol)
+
+    private val listener = { price: BigDecimal ->
+        value = price
+    }
+
+    override fun onActive() {
+        stockManager.requestPriceUpdates(listener)
+    }
+
+    override fun onInactive() {
+        stockManager.removeUpdates(listener)
+    }
+}
+```
+
+上面有三个重要的方法:   
+
+- onActive()： 当LiveData对象具有活动观察者时调用该方法
+- onInactive(): 当LiveData对象没有任何活动观察者时调用该方法
+- setValue(T): 更新LiveData实例的值，并通知任何活动的观察者有关更改的信息
+
+可以像下面这样使用`StockLiveData`:   
+```kotlin
+public class MyFragment : Fragment() {
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        super.onViewCreated(view, savedInstanceState)
+        val myPriceListener: LiveData<BigDecimal> = ...
+        myPriceListener.observe(viewLifecycleOwner, Observer<BigDecimal> { price: BigDecimal? ->
+            // Update the UI.
+        })
+    }
+}
+```
+上面`observe()`方法中的第一个参数传递的是`fragment`的实例，该`fragment`实现了`LifecycleOwner`接口。这样做是为了将`observer`和`Lifecycle`对象绑定到一起，这意味着:      
+- 如果当前的`Lifecycle`对象不是出于活跃期，就算`value`值有改变也不会回调到`observer`中
+- 在`Lifecycle`对象销毁后哦，`observer`对象也会自动移除
+
+实际上`LiveData`对象是适应生命周期也就意味着你需要在多个`activities`,`fragments`和`services`中进行共享，所以通常我们会将`LiveData`的示例设计成单例的:   
+```kotlin
+class StockLiveData(symbol: String) : LiveData<BigDecimal>() {
+    private val stockManager: StockManager = StockManager(symbol)
+
+    private val listener = { price: BigDecimal ->
+        value = price
+    }
+
+    override fun onActive() {
+        stockManager.requestPriceUpdates(listener)
+    }
+
+    override fun onInactive() {
+        stockManager.removeUpdates(listener)
+    }
+
+    companion object {
+        private lateinit var sInstance: StockLiveData
+
+        @MainThread
+        fun get(symbol: String): StockLiveData {
+            sInstance = if (::sInstance.isInitialized) sInstance else StockLiveData(symbol)
+            return sInstance
+        }
+    }
+}
+class StockLiveData(symbol: String) : LiveData<BigDecimal>() {
+    private val stockManager: StockManager = StockManager(symbol)
+
+    private val listener = { price: BigDecimal ->
+        value = price
+    }
+
+    override fun onActive() {
+        stockManager.requestPriceUpdates(listener)
+    }
+
+    override fun onInactive() {
+        stockManager.removeUpdates(listener)
+    }
+
+    companion object {
+        private lateinit var sInstance: StockLiveData
+
+        @MainThread
+        fun get(symbol: String): StockLiveData {
+            sInstance = if (::sInstance.isInitialized) sInstance else StockLiveData(symbol)
+            return sInstance
+        }
+    }
+}
+```
+这样就可以在`fragment`中像如下这样使用:   
+```kotlin
+class MyFragment : Fragment() {
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        super.onViewCreated(view, savedInstanceState)
+        StockLiveData.get(symbol).observe(viewLifecycleOwner, Observer<BigDecimal> { price: BigDecimal? ->
+            // Update the UI.
+        })
+    }
+}    
+```
+
+转换LiveData
+---
+
+你可能有时会在`LiveData`分发给`observers`之前想要修改一下存储在`LiveData`中的值，或者你想根据当前的值进行修改返回另一个值。`Lifecycle`提供了`Transformations`类来通过里面的`helper`方法解决这种问题。 
+
+- `Transformations.map()`
+
+可以将`LiveData`中的数据进行改变。
+
+
+```java
+val userLiveData: LiveData<User> = UserLiveData()
+val userName: LiveData<String> = Transformations.map(userLiveData) {
+    user -> "${user.name} ${user.lastName}"
+}
+```
+将`LiveData`中的`User`数据转换成`String`  
+
+
+- `Transformations.switchMap()`
+
+```java
+private fun getUser(id: String): LiveData<User> {
+  ...
+}
+val userId: LiveData<String> = ...
+val user = Transformations.switchMap(userId) { id -> getUser(id) }
+
+```
+
+
+和上面的`map()`方法很像。区别在于传递给`switchMap()`的函数必须返回`LiveData`对象。
+和`LiveData`一样,`Transformation`也可以在观察者的整个生命周期中存在。只有在观察者处于观察`LiveData`状态时,`Transformation`才会运算。`Transformation`是延迟运算的（`calculated lazily`），而生命周期感知的能力确保不会因为延迟发生任何问题。
+
+如果在`ViewModel`对象的内部需要一个`Lifecycle`对象，那么使用`Transformation`是一个不错的方法。举个例子:假如有个`UI`组件接受输入的地址，返回对应的邮政编码。那么可以 实现一个`ViewModel`和这个组件绑定:   
+```java
+class MyViewModel(private val repository: PostalCodeRepository) : ViewModel() {
+
+    private fun getPostalCode(address: String): LiveData<String> {
+        // DON'T DO THIS
+        return repository.getPostCode(address)
+    }
+}
+```
+
+看代码中的注释，有个`// DON'T DO THIS`(不要这么干),这是为什么？有一种情况是如果`UI`组件被回收后又被重新创建，那么又会触发一次`repository.getPostCode(address)`询，而不是重用上次已经获取到的查询。那么应该怎样避免这个问题呢？看一下下面的代码:  
+
+```java
+class MyViewModel(private val repository: PostalCodeRepository) : ViewModel() {
+    private val addressInput = MutableLiveData<String>()
+    val postalCode: LiveData<String> = Transformations.switchMap(addressInput) {
+            address -> repository.getPostCode(address) }
+
+    private fun setInput(address: String) {
+        addressInput.value = address
+    }
+}
+
+```
+
+`postalCode`变量的修饰符是`public`和`final`，因为这个变量的是不会改变的。哎？不会改变？那我输入不同的地址还总返回相同邮编？先打住，`postalCode`这个变量存在的作用是把输入的`addressInput`转换成邮编，那么只有在输入变化时才会调用`repository.getPostCode()`方法。这就好比你用`final`来修饰一个数组，虽然这个变量不能再指向其他数组，但是数组里面的内容是可以被修改的。绕来绕去就一点:当输入是相同的情况下，用了`switchMap()`可以减少没有必要的请求。并且同样，只有在观察者处于活跃状态时才会运算并将结果通知观察者。
+
+
+
+
+合并多个`LiveData`中的数据
+---
+
+`MediatorLiveData`是`LiveData`的子类，可以通过`MediatorLiveData`合并多个`LiveData`来源的数据。同样任意一个来源的`LiveData`数据发生变化，`MediatorLiveData`都会通知观察他的对象。说的有点抽象，举个例子。比如`UI`接收来自本地数据库和网络数据，并更新相应的`UI`。可以把下面两个`LiveData`加入到`MeidatorLiveData`中:   
+
+- 关联数据库的`LiveData`
+- 关联联网请求的`LiveData`
+相应的`UI`只需要关注`MediatorLiveData`就可以在任意数据来源更新时收到通知。
+
+
+
+[上一篇: 3.Lifecycle(三)](https://github.com/CharonChui/AndroidNote/blob/master/ArchitectureComponents/3.Lifecycle(%E4%B8%89).md)
+[下一篇: 5.ViewModel(五)](https://github.com/CharonChui/AndroidNote/blob/master/ArchitectureComponents/5.ViewModel(%E4%BA%94).md)
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! `
\ No newline at end of file
diff --git "a/Jetpack/architecture/6.DataBinding\347\256\200\344\273\213.md" "b/Jetpack/architecture/6.DataBinding\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..1d68094e
--- /dev/null
+++ "b/Jetpack/architecture/6.DataBinding\347\256\200\344\273\213.md"
@@ -0,0 +1,23 @@
+# 6.DataBinding简介
+
+
+
+https://developer.android.com/topic/libraries/data-binding
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/ArchitectureComponents/6.Room(\345\205\255).md" b/Jetpack/architecture/7.Room.md
similarity index 99%
rename from "ArchitectureComponents/6.Room(\345\205\255).md"
rename to Jetpack/architecture/7.Room.md
index aeb29823..04d06a56 100644
--- "a/ArchitectureComponents/6.Room(\345\205\255).md"
+++ b/Jetpack/architecture/7.Room.md
@@ -1,4 +1,4 @@
-6.Room(六)
+7.Room
 ===
 
 `Room`是一个持久化工具，和`ormlite`、`greenDao`类似，都是`ORM`工具。在开发中我们可以利用`Room`来操作`sqlite`数据库。
diff --git "a/ArchitectureComponents/7.PagingLibrary(\344\270\203).md" b/Jetpack/architecture/8.PagingLibrary.md
similarity index 75%
rename from "ArchitectureComponents/7.PagingLibrary(\344\270\203).md"
rename to Jetpack/architecture/8.PagingLibrary.md
index fce0a881..24e9810b 100644
--- "a/ArchitectureComponents/7.PagingLibrary(\344\270\203).md"
+++ b/Jetpack/architecture/8.PagingLibrary.md
@@ -1,4 +1,4 @@
-7.PagingLibrary(七)
+8.PagingLibrary
 ===
 
 
diff --git "a/Jetpack/architecture/9.App Startup\347\256\200\344\273\213.md" "b/Jetpack/architecture/9.App Startup\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..57deef76
--- /dev/null
+++ "b/Jetpack/architecture/9.App Startup\347\256\200\344\273\213.md"	
@@ -0,0 +1,607 @@
+# 9.App Startup简介
+
+[App Startup](https://developer.android.google.cn/topic/libraries/app-startup)
+
+App Startup库提供了一种直接，高效的方法，可以在应用程序启动时初始化组件。第三方库开发人员和应用程序开发人员都可以使用App Startup来简化启动顺序并显式设置初始化顺序。
+
+App Startup允许共享单个内容提供者来进行组件的初始化，而无需为需要初始化的每个组件定义单独的内容提供者。这可以大大缩短应用程序的启动时间。
+
+这里提到了内容提供者，会让人摸不到头脑，内容提供者会应用初始化有什么关系？ 
+
+## 背景
+
+我们在使用一些第三方库时一般都需要在Application.onCreate()方法中进行一些init或者install等初始化操作: 
+
+```kotlin
+class StApplication : Application() {
+    override fun onCreate() {
+        Fresco.initialize(this)
+        LitePalApplication.initialize(this)
+        Adxxx.init(this)
+        ....
+    }
+}      
+```
+
+但是在之前[LeakCanary源码分析](https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/LeakCanary%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90.md)的文章中曾经介绍过LeakCanary是如何做到不用任何一行Java代码就能实现监测内存泄露功能的。 这里我们回顾一下: 
+
+## How does LeakCanary get installed by only adding a dependency?[¶](https://square.github.io/leakcanary/faq/#how-does-leakcanary-get-installed-by-only-adding-a-dependency)
+
+On Android, content providers are created after the Application  instance is created but before Application.onCreate() is called. The `leakcanary-object-watcher-android` artifact has a non exported ContentProvider defined in its `AndroidManifest.xml` file. When that ContentProvider is installed, it adds activity and fragment lifecycle listeners to the application.
+
+对于Application的onCreate()方法，官方文档中是这样说的:
+
+Called when the application is starting, before any activity,  service, or receiver objects(excluding content providers)have been  created.
+
+看到这里，大呼内行...这个实现太巧妙了。尽然是通过在AndroidManifest.xml中注册一个内容提供者，这个内容提供者的创建会在Application.onCreate()之前，在它创建的时候去做install的操作。
+
+```xml
+  <application>
+    <provider
+        android:name="leakcanary.internal.AppWatcherInstaller$MainProcess"
+        android:authorities="${applicationId}.leakcanary-installer"
+        android:enabled="@bool/leak_canary_watcher_auto_install"
+        android:exported="false"/>
+  </application>
+```
+
+
+
+```kotlin
+/**
+ * Content providers are loaded before the application class is created. [AppWatcherInstaller] is
+ * used to install [leakcanary.AppWatcher] on application start.
+ */
+internal sealed class AppWatcherInstaller : ContentProvider() {
+
+  /**
+   * [MainProcess] automatically sets up the LeakCanary code that runs in the main app process.
+   */
+  internal class MainProcess : AppWatcherInstaller()
+
+  /**
+   * When using the `leakcanary-android-process` artifact instead of `leakcanary-android`,
+   * [LeakCanaryProcess] automatically sets up the LeakCanary code
+   */
+  internal class LeakCanaryProcess : AppWatcherInstaller()
+
+  override fun onCreate(): Boolean {
+    val application = context!!.applicationContext as Application
+    // 调用install方法进行初始化  
+    AppWatcher.manualInstall(application)
+    return true
+  }
+
+  override fun query(
+    uri: Uri,
+    strings: Array<String>?,
+    s: String?,
+    strings1: Array<String>?,
+    s1: String?
+  ): Cursor? {
+    return null
+  }
+
+  override fun getType(uri: Uri): String? {
+    return null
+  }
+
+  override fun insert(
+    uri: Uri,
+    contentValues: ContentValues?
+  ): Uri? {
+    return null
+  }
+
+  override fun delete(
+    uri: Uri,
+    s: String?,
+    strings: Array<String>?
+  ): Int {
+    return 0
+  }
+
+  override fun update(
+    uri: Uri,
+    contentValues: ContentValues?,
+    s: String?,
+    strings: Array<String>?
+  ): Int {
+    return 0
+  }
+}
+```
+
+
+
+## 通过ContentProvider进行初始化的优缺点
+
+优点: 
+
+大大简化了我们的接入成本，无须任何Java代码即可使用。
+
+缺点: 
+
+- ContentProvider会增加许多额外的耗时。
+
+    应用和库往往需要在Application.onCreate()之前初始化组件，如: WorkManager、ProcessLifecycleObserver、FirebaseApp 等。这往往通过使用ContentProvider来实现不同依赖的初始化。通过 App Startup，您无需为每个组件单独定义ContentProvider进行初始化，而可以定义多个 Initializer去共享相同的ContentProvider。每减少一个ContentProvider通常会有约2ms的收益，这可以显著提高应用启动速度。
+
+    毕竟ContentProvider是Android四大组件之一，这个组件相对来说是比较重量级的。也就是说，本来我的初始化操作可能是一个非常轻量级的操作，依赖于ContentProvider之后就变成了一个重量级的操作了。假如一个应用使用了很多第三方库，而每个库都会用一个ContentProvider进行初始化，那就会大大影响应用的启动时间。
+
+    关于ContentProvider的耗时，Google官方也有给出一个测试结果：
+
+    在一台搭载Android 10系统的Pixel2手机上测试的情况。可以看到，一个空的ContentProvider大约会占用2ms的耗时，随着ContentProvider的增加，耗时也会跟着一起增加。如果你的应用程序中使用了50个ContentProvider，那么将会占用接近20ms的耗时。
+
+    注意这还只是空ContentProvider的耗时，并没有算上你在ContentProvider中执行逻辑的耗时。这个测试结果告诉我们，虽然刚才所介绍的使用ContentProvider来进行初始化的设计方式很巧妙，但是如果每个第三方库都自己创建了一个ContentProvider，那么最终我们App的启动速度就会受到比较大的影响。
+    有没有办法解决这个问题呢？
+
+    所以得出结论，当集成的库使用的ContentProvider达到一定个数之后，确实能减少耗时，但是减少的不多，比如这里我们是10个ContentProvider集成App Startup后能减少的耗时在10ms左右，一般一个项目集成了五十个使用ContentProvider的库，耗时减少应该能在20ms之内。
+
+    所以App Startup解决的就是这个耗时时间，虽然不多，但是也确实有减少耗时的功能。
+
+- Android会以不确定的顺序初始化内容提供者
+
+
+
+## App Startup原理
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/app_startup_old.png?raw=true)
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/app_startup_new.png?raw=true)
+
+
+
+App Startup提供了一种更高效的方法，可在应用程序启动时初始化组件并显式定义其依赖关系它可以将所有用于初始化的ContentProvider合并成一个，从而使App的启动速度变得更快。而且它还可以指定不同组件初始化的依赖关系。
+
+两点特性：
+
+- 可以共享单个Contentprovider。
+- 可以明确地设置初始化顺序。
+
+具体来讲，App Startup内部也创建了一个ContentProvider，并提供了一套用于初始化的标准。然后对于其他第三方库来说，你们就不需要再自己创建ContentProvider了，都按我的这套标准进行实现就行了，我可以保证你们的库在App启动之前都成功进行初始化。
+当App启动的时候会自动执行App Startup库中内置的一个名为 InitializationProvider 的 ContentProvider，该 ContentProvider 在合并后的AndroidManifest.xml文件中查找条目来发现Initializer，然后逐个调用它们的create()方法来进行初始化操作。完成上一阶段之后，加载组件之前会先加载该组件的所有依赖项。因此，可以确保组件的所有依赖项都已完成初始化后才对其进行初始化。
+
+
+
+
+
+## 使用
+
+### 1.添加依赖
+
+想要在库或者app中使用Jetpack Startup组件，需要在Gradle文件中添加一下代码: 
+
+```xml
+dependencies {
+    implementation "androidx.startup:startup-runtime:1.0.0"
+}
+```
+
+### 2.定义组件初始化器
+
+想要使用App Startup在应用启动时自动初始化组件，你必须要为每一个要初始化的组件定义一个实现Initializer<T>接口的组件初始化器(initializer)。
+
+Initialize接口是Startup封装的组件接口，用于指定组件的初始化逻辑和初始化顺序。
+
+这个接口里面有两个重要的方法: 
+
+- create()：初始化操作
+
+    包含所有组件初始化所需要的操作，并且返回一个该组件T的实例
+
+- dependencies(): 依赖关系
+
+    返回该组件initializer所需要依赖的一个包含其他Initializer<T>对象的list集合。可以在该方法中去控制应用启动时initializers的执行顺序。
+
+假设你的应用需要依赖WorkManager，并在启动时进行初始化，需要定义一个WorkManagerInitializer类实现Initializer<WorkManager>接口: 
+
+```kotlin
+// Initializes WorkManager.
+class WorkManagerInitializer : Initializer<WorkManager> {
+    override fun create(context: Context): WorkManager {
+        val configuration = Configuration.Builder().build()
+        WorkManager.initialize(context, configuration)
+        return WorkManager.getInstance(context)
+    }
+    override fun dependencies(): List<Class<out Initializer<*>>> {
+        // No dependencies on other libraries.
+        return emptyList()
+    }
+}
+```
+
+dependencies()方法中返回了一个空的list，因为WorkManager不需要依赖其他任何库。 
+
+假设你需要使用另外一个叫做ExampleLogger的库，该库依赖于WorkManager。这种情况下你必须保证应用程序启动后先初始化WorkManager。这里定义一个ExampleLoggerInitializer类实现Initializer<ExampleLogger>接口:  
+
+```kotlin
+// Initializes ExampleLogger.
+class ExampleLoggerInitializer : Initializer<ExampleLogger> {
+    override fun create(context: Context): ExampleLogger {
+        // WorkManager.getInstance() is non-null only after
+        // WorkManager is initialized.
+        return ExampleLogger(WorkManager.getInstance(context))
+    }
+
+    override fun dependencies(): List<Class<out Initializer<*>>> {
+        // Defines a dependency on WorkManagerInitializer so it can be
+        // initialized after WorkManager is initialized.
+        return listOf(WorkManagerInitializer::class.java)
+    }
+}
+```
+
+这里因为在dependencies()方法中包含了WorkManagerInitializer，App Startup会在ExampleLogger初始化前先初始化WorkManager。
+
+### 3.配置manifest文件
+
+App Startup包含一个称为InitializationProvider的特殊内容提供程序，它可用于发现和调用组件初始化器。 App Startup通过首先检查manifest文件下的InitializationProvider条目下的<meta-data>条目来发现组件初始化程序。然后，App Startup为其已经发现的所有初始化器调用dependencies()方法。
+
+这就意味着，为了使组件初始化器可被App Startup发现，必须满足以下条件之一:  
+
+- 组件初始化器在InitializationProvider清单条目下具有一个对应的<meta-data>条目。
+- 组件初始化器已在另一个可发现的初始化器中的dependencies()方法中列出。
+
+再次考虑带有WorkManagerInitializer和ExampleLoggerInitializer的示例。为确保App Startup可以发现这些初始化器，请将以下内容添加到清单文件中：  
+
+```xml
+<provider
+    android:name="androidx.startup.InitializationProvider"
+    android:authorities="${applicationId}.androidx-startup"
+    android:exported="false"
+    tools:node="merge">
+    <!-- This entry makes ExampleLoggerInitializer discoverable. -->
+    <meta-data  android:name="com.example.ExampleLoggerInitializer"
+          android:value="androidx.startup" />
+</provider>
+```
+
+要点如下：
+
+- 1、组件名必须是`androidx.startup.InitializationProvider`；
+- 2、需要声明`android:exported="false"`，以限制其他应用访问此组件；
+- 3、要求`android:authorities`在整个手机唯一，通常使用${applicationId}作为前缀；
+- 4、需要声明`tools:node="merge"`，确保`manifest merger tool`能够正确解析冲突的节点；用来合并所有申明了`InitializationProvider`的`ContentProvider`。
+- 5、meta-data `name`为组件的 Initializer实现类全限定名，`value`为`androidx.startup`。
+
+您不需要为WorkManagerInitializer添加<meta-data>条目，因为WorkManagerInitializer是ExampleLoggerInitializer的依赖项。这意味着，如果ExampleLoggerInitializer是可发现的，则WorkManagerInitializer也是如此。
+
+
+
+### 运行lint工具检查
+
+为了检查你是否正确使用了App Startup组件，可以运行./gradlew :app:lintDebug命令来校验。
+
+### 手动初始化
+
+通常当你使用App Startup时，InitializationProvider使用一个名为AppInitializer的组件来自动发现并运行你的initializers组件。然而，你也可以使用AppInitializer来手动启动这些初始化组件，这叫做延迟初始化，可以帮助你减少启动消耗。 如果你要手动初始化，你需要首先关闭自动初始化功能。
+
+#### 关闭单个组件的自动初始化
+
+为了关闭单个组件的自动初始化，需要在 <meta-data> 条目下为 Initializer 增加 tools:node="remove" 属性，这将禁用自动初始化。
+例如，添加如下代码到manifest中关闭ExampleLogger的自动初始化：
+
+```xml
+<provider
+    android:name="androidx.startup.InitializationProvider"
+    android:authorities="${applicationId}.androidx-startup"
+    android:exported="false"
+    tools:node="merge">
+    <meta-data android:name="com.example.ExampleLoggerInitializer"
+              tools:node="remove" />
+</provider>
+```
+
+假设我们在项目中引入的某个第三方依赖库自身使用到了Startup进行自动初始化，我们希望将之改为延迟初始化的方式，但我们无法直接修改第三方依赖库的AndroidManifest文件，此时就可以通过AndroidManifest的合并规则来移除指定的Initializer。
+
+假设第三方依赖库的Initializer的包名路径是 `xxx.xxx.InitializerImpl`，在主项目工程的AndroidManifes文件中主动对其进行声明，并添加 `tools:node="remove"` 语句要求在合并AndroidManifest文件时移除自身，这样Startup就不会自动初始化InitializerImpl了。
+
+
+
+
+
+如果想要禁用所有组件的自动初始化功能，同时又需要使用manifet文件合并工具的合并规则，就需要移除manifet文件中InitializationProvider中的整个节点: 
+
+```xml
+<provider
+    android:name="androidx.startup.InitializationProvider"
+    android:authorities="${applicationId}.androidx-startup"
+    tools:node="remove" />
+```
+
+可以手动使用AppInitialize来进行组件和它所依赖组件的初始化，例如: 
+
+```kotlin
+AppInitializer.getInstance(context)
+    .initializeComponent(ExampleLoggerInitializer::class.java)
+```
+
+App Startup同样会初始化WorkManager，因为WorkManager是ExampleLogger的一个依赖。 
+
+App Startup中会缓存初始化后的结果，重复调用initializeComponent()方法不会导致重复初始化。
+
+## 源码分析
+
+```java
+/**
+ * The {@link ContentProvider} which discovers {@link Initializer}s in an application and
+ * initializes them before {@link Application#onCreate()}.
+ *
+ * @hide
+ */
+@RestrictTo(RestrictTo.Scope.LIBRARY)
+public final class InitializationProvider extends ContentProvider {
+    @Override
+    public boolean onCreate() {
+        Context context = getContext();
+        if (context != null) {
+            AppInitializer.getInstance(context).discoverAndInitialize();
+        } else {
+            throw new StartupException("Context cannot be null");
+        }
+        return true;
+    }
+
+    @Nullable
+    @Override
+    public Cursor query(
+            @NonNull Uri uri,
+            @Nullable String[] projection,
+            @Nullable String selection,
+            @Nullable String[] selectionArgs,
+            @Nullable String sortOrder) {
+        throw new IllegalStateException("Not allowed.");
+    }
+
+    @Nullable
+    @Override
+    public String getType(@NonNull Uri uri) {
+        throw new IllegalStateException("Not allowed.");
+    }
+
+    @Nullable
+    @Override
+    public Uri insert(@NonNull Uri uri, @Nullable ContentValues values) {
+        throw new IllegalStateException("Not allowed.");
+    }
+
+    @Override
+    public int delete(
+            @NonNull Uri uri,
+            @Nullable String selection,
+            @Nullable String[] selectionArgs) {
+        throw new IllegalStateException("Not allowed.");
+    }
+
+    @Override
+    public int update(
+            @NonNull Uri uri,
+            @Nullable ContentValues values,
+            @Nullable String selection,
+            @Nullable String[] selectionArgs) {
+        throw new IllegalStateException("Not allowed.");
+    }
+}
+```
+
+代码很简单，里面调用AppInitializer.discoverAndInitialize()方法: 
+
+```java
+
+/**
+ * An {@link AppInitializer} can be used to initialize all discovered [ComponentInitializer]s.
+ * <br/>
+ * The discovery mechanism is via `<meta-data>` entries in the merged `AndroidManifest.xml`.
+ */
+@SuppressWarnings("WeakerAccess")
+public final class AppInitializer {
+
+    // Tracing
+    private static final String SECTION_NAME = "Startup";
+
+    /**
+     * The {@link AppInitializer} instance.
+     */
+    private static volatile AppInitializer sInstance;
+
+    /**
+     * Guards app initialization.
+     */
+    private static final Object sLock = new Object();
+
+    @NonNull
+    final Map<Class<?>, Object> mInitialized;
+
+    @NonNull
+    final Set<Class<? extends Initializer<?>>> mDiscovered;
+
+    @NonNull
+    final Context mContext;
+
+    /**
+     * Creates an instance of {@link AppInitializer}
+     *
+     * @param context The application context
+     */
+    AppInitializer(@NonNull Context context) {
+        mContext = context.getApplicationContext();
+        mDiscovered = new HashSet<>();
+        mInitialized = new HashMap<>();
+    }
+
+    /**
+     * @param context The Application {@link Context}
+     * @return The instance of {@link AppInitializer} after initialization.
+     */
+    @NonNull
+    @SuppressWarnings("UnusedReturnValue")
+    public static AppInitializer getInstance(@NonNull Context context) {
+        if (sInstance == null) {
+            synchronized (sLock) {
+                if (sInstance == null) {
+                    sInstance = new AppInitializer(context);
+                }
+            }
+        }
+        return sInstance;
+    }
+
+    /**
+     * Initializes a {@link Initializer} class type.
+     *
+     * @param component The {@link Class} of {@link Initializer} to initialize.
+     * @param <T>       The instance type being initialized
+     * @return The initialized instance
+     */
+    @NonNull
+    @SuppressWarnings("unused")
+    public <T> T initializeComponent(@NonNull Class<? extends Initializer<T>> component) {
+        return doInitialize(component, new HashSet<Class<?>>());
+    }
+
+    /**
+     * Returns <code>true</code> if the {@link Initializer} was eagerly initialized..
+     *
+     * @param component The {@link Initializer} class to check
+     * @return <code>true</code> if the {@link Initializer} was eagerly initialized.
+     */
+    public boolean isEagerlyInitialized(@NonNull Class<? extends Initializer<?>> component) {
+        // If discoverAndInitialize() was never called, then nothing was eagerly initialized.
+        return mDiscovered.contains(component);
+    }
+
+    @NonNull
+    @SuppressWarnings({"unchecked", "TypeParameterUnusedInFormals"})
+    <T> T doInitialize(
+            @NonNull Class<? extends Initializer<?>> component,
+            @NonNull Set<Class<?>> initializing) {
+        synchronized (sLock) {
+            boolean isTracingEnabled = Trace.isEnabled();
+            try {
+                if (isTracingEnabled) {
+                    // Use the simpleName here because section names would get too big otherwise.
+                    Trace.beginSection(component.getSimpleName());
+                }
+                if (initializing.contains(component)) {
+                    String message = String.format(
+                            "Cannot initialize %s. Cycle detected.", component.getName()
+                    );
+                    throw new IllegalStateException(message);
+                }
+                Object result;
+                // 先检查是否已经初始化过
+                if (!mInitialized.containsKey(component)) {
+                    initializing.add(component);
+                    try {
+                        // 先反射检查denpendencies()方法
+                        Object instance = component.getDeclaredConstructor().newInstance();
+                        Initializer<?> initializer = (Initializer<?>) instance;
+                        List<Class<? extends Initializer<?>>> dependencies =
+                                initializer.dependencies();
+
+                        if (!dependencies.isEmpty()) {
+                            for (Class<? extends Initializer<?>> clazz : dependencies) {
+                                if (!mInitialized.containsKey(clazz)) {
+                                    doInitialize(clazz, initializing);
+                                }
+                            }
+                        }
+                        if (StartupLogger.DEBUG) {
+                            StartupLogger.i(String.format("Initializing %s", component.getName()));
+                        }
+                        // 调用create()方法
+                        result = initializer.create(mContext);
+                        if (StartupLogger.DEBUG) {
+                            StartupLogger.i(String.format("Initialized %s", component.getName()));
+                        }
+                        initializing.remove(component);
+                        // 缓存已经初始化过的组件
+                        mInitialized.put(component, result);
+                    } catch (Throwable throwable) {
+                        throw new StartupException(throwable);
+                    }
+                } else {
+                    result = mInitialized.get(component);
+                }
+                return (T) result;
+            } finally {
+                Trace.endSection();
+            }
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    void discoverAndInitialize() {
+        try {
+            Trace.beginSection(SECTION_NAME);
+            ComponentName provider = new ComponentName(mContext.getPackageName(),
+                    InitializationProvider.class.getName());
+            ProviderInfo providerInfo = mContext.getPackageManager()
+                    .getProviderInfo(provider, GET_META_DATA);
+            Bundle metadata = providerInfo.metaData;
+            String startup = mContext.getString(R.string.androidx_startup);
+            if (metadata != null) {
+                // 遍历metadata节点
+                Set<Class<?>> initializing = new HashSet<>();
+                Set<String> keys = metadata.keySet();
+                for (String key : keys) {
+                    String value = metadata.getString(key, null);
+                    // 检查value为androidx.startup的值
+                    if (startup.equals(value)) {
+                        // 反射
+                        Class<?> clazz = Class.forName(key);
+                        if (Initializer.class.isAssignableFrom(clazz)) {
+                            Class<? extends Initializer<?>> component =
+                                    (Class<? extends Initializer<?>>) clazz;
+                            mDiscovered.add(component);
+                            if (StartupLogger.DEBUG) {
+                                StartupLogger.i(String.format("Discovered %s", key));
+                            }
+                            doInitialize(component, initializing);
+                        }
+                    }
+                }
+            }
+        } catch (PackageManager.NameNotFoundException | ClassNotFoundException exception) {
+            throw new StartupException(exception);
+        } finally {
+            Trace.endSection();
+        }
+    }
+}
+```
+
+
+
+## 遗憾
+
+
+
+优点：使用 App Startup 框架，可以简化启动序列并显式设置初始化依赖顺序，在简单、高效这方面，App Startup 基本满足需求。
+
+不足：App Startup 框架的不足也是因为它太简单了，提供的特性太过简单，往往并不能完美契合商业化需求。例如以下特性 App Startup 就无法满足：
+
+异步处理呢？虽然我们可以在`create()`方法中手动创建子线程进行异步任务，但一个异步任务依赖另一个异步任务又该如何处理呢？多个异步任务完成之后，统一逻辑处理又在哪里呢？依赖任务完成后的回调又在哪里？亦或者是依赖任务完成后的通知？
+
+- InitializationProvider的onCreate()方法是在主线程被调用的，导致每个Initializer默认就都是运行在主线程，这对于某些初始化时间过长，需要运行在子线程的组件来说就不太适用了。且Initializer的 `create(context: Context)` 方法的本意是完成组件的初始化并返回初始化的结果值，如果在此处通过主动new Thread来运行耗时组件的初始化，那么我们就无法返回有意义的结果值，间接导致后续也无法通过 AppInitializer获取到缓存的初始化结果值。
+- 对于已经使用 ContentProvider 完成初始化逻辑的第三方依赖库，我们一般也无法直接修改其初始化逻辑（除非 clone 该项目导到本地直接修改源码），所以在初始阶段 Startup 的意义主要在于统一项目本地组件的初始化入口，需要等到 Startup 被大多数开发者接受并使用后，才更加具有性能优势
+
+- 缺乏异步等待：同步等待指的是在当前线程先初始化所依赖的组件，再初始化当前组件，App Startup 是支持的，但是异步等待就不支持了。举个例子，如果某组件的初始化需要依赖于其它耗时组件（初始化时间过长，需要运行在子线程）的结果值，此时Startup一样不适用。
+- 缺乏依赖回调：当前组件所依赖的组件初始化完成后，未发出回调。
+
+如果你的项目都是同步初始化的话，并且使用到了多个`ContentProvider`，`App Startup`可能有一定的优化空间，毕竟统一到了一个`ContentProvider`中，同时支持了简单的顺序依赖。
+
+值得一提的是，`App Startup`中只提供了使用反射来获取初始化的组件实例，这对于一些没有过多依赖的初始化项目来说，盲目使用`App Startup`来优化是否会对启动速度进一步造成影响呢？
+
+所以就有了下面这个库，App Startup的进阶版[Android Startup](https://github.com/idisfkj/android-startup)。
+
+[Why I abandoned the Jetpack App Startup?](https://medium.com/@idisfkj/why-i-abandoned-the-jetpack-app-startup-9963bd8865ef)
+
+[Android Startup](https://github.com/idisfkj/android-startup)
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/Jetpack/ui/Jetpack Compose\347\256\200\344\273\213.md" "b/Jetpack/ui/Jetpack Compose\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..150ccb9e
--- /dev/null
+++ "b/Jetpack/ui/Jetpack Compose\347\256\200\344\273\213.md"	
@@ -0,0 +1,22 @@
+# Jetpack Compose简介
+
+
+
+Jetpack Compose是用于构建原生Android UI的现代工具包。 Jetpack Compose使用更少的代码，强大的工具和直观的Kotlin API，简化并加速了Android上的UI开发。这是Android Developers 官网对它的描述。
+
+
+
+在Android中，UI工具包的历史可追溯到至少10年前。自那时以来，情况发生了很大变化，例如我们使用的设备，用户的期望，以及开发人员对他们所使用的开发工具和语言的期望。
+
+以上只是我们需要新UI工具的一个原因，另外一个重要的原因是`View.java`这个类实在是太大了，有太多的代码，它大到你甚至无法在Githubs上查看该文件，因为它实际上包含了`30000`行代码，这很疯狂，而我们所使用的几乎每一个Android UI 组件都需要继承于View。
+
+GogleAndroid团队的Anna-Chiara表示，他们对已经实现的一些API感到遗憾，因为他们也无法在不破坏功能的情况下收回、修复或扩展这些API，因此现在是一个崭新起点的好时机。
+
+这就是为什么Jetpack Compose 让我们看到了曙光。
+
+
+
+作者：依然范特稀西
+链接：https://www.jianshu.com/p/19c4e10370ba
+来源：简书
+著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
\ No newline at end of file
diff --git "a/Jetpack/ui/material/1.MaterialToolbar\347\256\200\344\273\213.md" "b/Jetpack/ui/material/1.MaterialToolbar\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..ea27c991
--- /dev/null
+++ "b/Jetpack/ui/material/1.MaterialToolbar\347\256\200\344\273\213.md"
@@ -0,0 +1,281 @@
+# 1.MaterialToolbar简介
+
+### Actionbar简介
+
+从Android 3.0(API 11)开始，所有使用默认主题背景的Activity均使用ActionBar作为应用栏。不过，经过不同Android版本的演化，原生ActionBar的行为会有所不同，具体取决于设备用的是哪个版本的Android系统。所以Android提供了Toolbar，可以让这些功能在任何设备上保持一致。 所以，你应用使用支持库中的Toolbar来实现Activity的应用栏，来确保你的应用能在最大范围的设备上保持一致的行为。
+
+
+
+在使用的时候你会发现除了androidx.appcompat.widget.Toolbar之后还有一个com.google.android.material.appbar.MaterialToolbar。
+MaterialToolbar is a Toolbar that implements certain Material features, such as elevation overlays for Dark Themes. 
+
+
+
+## 使用
+
+- 禁止Action Bar                  
+    ToolBar相当于是ActionBar的替代版，因此需要制定一个不带ActionBar的主题，
+    可以通过自定义`theme`继承`xxx.NoActionBar`或者在`theme`中通过以下配置来进行禁用`ActionBar`。
+    
+    ```xml
+    <item name="windowActionBar">false</item>
+    <item name="android:windowNoTitle">true</item>
+    ```
+    
+    
+    ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/material_color.png?raw=true)         
+    里面没有`colorAccent`的颜色，唯独colorAccent这个属性比较难理解，它不是用来指定Checkbox等某一个按钮的颜色，而是更多表达了一个强调的意思，比如一些控件的选中状态也会使用colorAccent的颜色。
+    
+- 确保Activity继承自AppCompatActivity
+
+- 在布局文件中进行声明
+menu的实现如下:   
+```xml
+<menu xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools" tools:context=".MainActivity">
+
+        <item
+            android:id="@+id/action_search"
+            android:title="@string/action_search"
+            android:orderInCategory="100"
+            android:icon="@drawable/ic_action_search"
+            app:showAsAction="ifRoom" />
+
+        <item
+            android:id="@+id/action_settings"
+            android:title="@string/action_settings"
+            android:orderInCategory="100"
+            app:showAsAction="never" />
+
+</menu>
+```
+app:showAsAction属性用于指定操作是否应在应用栏中显示为按钮。如果您设置了app:showAsAction="ifRoom"，那么只要应用栏中有足够的空间，此操作便会显示为按钮；如果空间不足，无法容纳的操作就会被发送到溢出菜单。如果您设置了app:showAsAction="never"，此操作会始终列在溢出菜单中，而不会显示在应用栏中。
+```xml
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical">
+
+    <com.google.android.material.appbar.MaterialToolbar
+        android:id="@+id/tb_main"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content" />
+
+    <com.google.android.material.textview.MaterialTextView
+        android:id="@+id/mtv_main"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="hahahhd"
+        android:textSize="20sp" />
+</LinearLayout>
+```
+
+```kotlin
+ override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_main)
+        val mMaterialToolbar = findViewById<MaterialToolbar>(R.id.tb_main)
+        mMaterialToolbar.navigationIcon = getDrawable(R.drawable.vct_menu)
+        mMaterialToolbar.inflateMenu(R.menu.menu_toolbar_main)
+        mMaterialToolbar.title = "title"
+        mMaterialToolbar.setNavigationOnClickListener {
+            Snackbar.make(mMaterialToolbar, "click", Snackbar.LENGTH_SHORT).show()
+        }
+        mMaterialToolbar.setOnMenuItemClickListener {
+            Log.e("@@@", "lll")
+            true
+        }
+     
+        // 将ToolBar设置为ActionBar，这样一设置后他就能像ActionBar一样直接显示menu目录中的菜单资源如果不用该方法，那ToolBar就只是一个普通的View，对menu要用inflateMenu去加载布局。
+        // setSupportActionBar(mMaterialToolbar);
+        // getSupportActionBar().setDisplayShowHomeEnabled(true);
+    }
+```
+如果Toolbar仅仅是用来对以往的ActionBar做一次替换，那也太没创意啦！完全没必要去替换了，因为它们表现出来的都是一样的，而且并没有让我们觉得用起来比ActionBar方便。那为啥要替换呢，总应该有他的理由吧：ActionBar是固定在顶部，并不能移动，我觉得这是最大的不好，而我们的ToolBar可以让我们随便摆放，就就可以带来很多灵活性和效果啦！
+
+
+接下来我们看一下`ToolBar`中具体有哪些内容:    
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/ToolBar_content.jpg?raw=true)               
+
+我们可以通过对应的方法来修改他们的属性:                 
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/toolbarCode.png?raw=true)
+
+ActionBar最左侧的这个按钮就叫做HomeAsUp按钮，它默认的图标是一个返回的箭头，含义是返回上一个活动，可以通过setDisplayHomeAsUpEnabled来让导航按钮显示出来。 
+可以在onOptionsItemSelected()方法中对HomeAsUp安阿牛的点击事件进行处理，HomeAsUp按钮的id永远都是android.R.id.home。
+如需在 Activity 中支持向上功能，您需要声明 Activity 的父级。为此，您可以在应用清单中设置 android:parentActivityName 属性。 
+例如，假设应用有一个名为 MainActivity 的主 Activity 和一个子 Activity。以下清单代码声明了这两个 Activity，并指定了父/子关系： 
+```xml
+ <application ... >
+        ...
+
+        <!-- The main/home activity (it has no parent activity) -->
+
+        <activity
+            android:name="com.example.myfirstapp.MainActivity" ...>
+            ...
+        </activity>
+
+        <!-- A child of the main activity -->
+        <activity
+            android:name="com.example.myfirstapp.MyChildActivity"
+            android:label="@string/title_activity_child"
+            android:parentActivityName="com.example.myfirstapp.MainActivity" >
+
+            <!-- Parent activity meta-data to support 4.0 and lower -->
+            <meta-data
+                android:name="android.support.PARENT_ACTIVITY"
+                android:value="com.example.myfirstapp.MainActivity" />
+        </activity>
+    </application>
+
+```
+如需为具有父 Activity 的 Activity 启用“向上”按钮，请调用应用栏的 setDisplayHomeAsUpEnabled() 方法。通常，您需要在创建 Activity 时调用此方法。例如，以下 onCreate() 方法将 Toolbar 设置为 MyChildActivity 的应用栏，然后启用该应用栏的“向上”按钮。
+```kotlin
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_my_child)
+
+        // my_child_toolbar is defined in the layout file
+        setSupportActionBar(findViewById(R.id.my_child_toolbar))
+
+        // Get a support ActionBar corresponding to this toolbar and enable the Up button
+        supportActionBar?.setDisplayHomeAsUpEnabled(true)
+    }
+    
+```
+​您不需要在 Activity 的 onOptionsItemSelected() 方法中捕获向上操作。相反，该方法应该调用其父类，如响应操作中所示。该父类方法会根据应用清单的规定，通过导航到父 Activity 响应“向上”操作。              
+
+对于`ToolBar`中的`Menu`部分我们可以通过一下方法来设置:     
+
+```java
+toolbar.inflateMenu(R.menu.menu_main);
+toolbar.setOnMenuItemClickListener();
+```
+
+或者也可以直接在`Activity`的`onCreateOptionsMenu`及`onOptionsItemSelected`来处理。 
+
+
+
+## DrawerLayout+Toolbar
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/drawerlayout_toolbar.png?raw=true)
+
+现在想实现侧边栏结合Toolbar的效果。 
+
+```xml
+<style name="Theme.JetpackSample.AppBarOverlay" parent="ThemeOverlay.AppCompat.Dark.ActionBar" />
+
+<style name="Theme.JetpackSample.PopupOverlay" parent="ThemeOverlay.AppCompat.Light" />
+```
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.drawerlayout.widget.DrawerLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:id="@+id/drawer_layout"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:fitsSystemWindows="true"
+    tools:openDrawer="start">
+
+    <androidx.coordinatorlayout.widget.CoordinatorLayout
+        android:layout_width="match_parent"
+        android:layout_height="match_parent">
+
+        <com.google.android.material.appbar.AppBarLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            // 指定状态栏的theme，例如状态栏中文字是灰还是白                                                         
+            android:theme="@style/Theme.JetpackSample.AppBarOverlay">
+
+            <com.google.android.material.appbar.MaterialToolbar
+                android:id="@+id/toolbar"
+                android:layout_width="match_parent"
+                android:layout_height="?attr/actionBarSize"
+                android:background="?attr/colorPrimary"
+                // 指定menu等弹出的效果                                                
+                app:popupTheme="@style/Theme.JetpackSample.PopupOverlay" />
+
+        </com.google.android.material.appbar.AppBarLayout>
+
+        <FrameLayout
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            android:background="#00f" />
+
+        <com.google.android.material.floatingactionbutton.FloatingActionButton
+            android:id="@+id/fab"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_gravity="bottom|end"
+            android:layout_marginEnd="16dp"
+            android:layout_marginBottom="16dp"
+            app:srcCompat="@android:drawable/ic_dialog_email" />
+
+    </androidx.coordinatorlayout.widget.CoordinatorLayout>
+
+    <com.google.android.material.navigation.NavigationView
+        android:id="@+id/nav_view"
+        android:layout_width="wrap_content"
+        android:layout_height="match_parent"
+        android:layout_gravity="start"
+        android:fitsSystemWindows="true"
+        app:headerLayout="@layout/nav_header_main"
+        app:menu="@menu/activity_main_drawer" />
+</androidx.drawerlayout.widget.DrawerLayout>
+```
+
+把Toolbar设置成ActionBar，可以让我们少处理很多点击逻辑。
+
+```kotlin
+class MainActivity : BaseActivity() {
+    private val binding by viewBinding(ActivityMainBinding::inflate)
+    private lateinit var actionBarDrawerToggle: ActionBarDrawerToggle
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        binding.fab.setOnClickListener { view ->
+            Snackbar.make(view, "Replace with your own action", Snackbar.LENGTH_LONG)
+                .setAction("Action", null).show()
+        }
+
+        actionBarDrawerToggle = ActionBarDrawerToggle(
+            this,
+            binding.drawerLayout,
+            binding.toolbar,
+            R.string.open,
+            R.string.close
+        )
+        binding.drawerLayout.addDrawerListener(actionBarDrawerToggle)
+        actionBarDrawerToggle.syncState()
+        setSupportActionBar(binding.toolbar)
+    }
+
+    override fun onCreateOptionsMenu(menu: Menu): Boolean {
+        // Inflate the menu; this adds items to the action bar if it is present.
+        menuInflater.inflate(R.menu.main, menu)
+        return true
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem): Boolean {
+        // navigation icon的点击交给actionbardrawertoggle来处理
+        if (actionBarDrawerToggle.onOptionsItemSelected(item)) {
+            return true;
+        }
+        // 处理其他menu的点击事件
+        when (item.itemId) {
+            R.id.action_settings -> Log.e("@@@", "settings")
+        }
+        return super.onOptionsItemSelected(item);
+    }
+}
+```
+
+[ActionBarDrawerToggle](http://www.nowamagic.net/academy/tag/ActionBarDrawerToggle) 的作用：
+
+- 改变android.R.id.home返回图标。
+- Drawer拉出、隐藏，带有android.R.id.home动画效果。
+- 监听Drawer拉出、隐藏；
+
diff --git "a/Jetpack/ui/material/2.NavigationView\347\256\200\344\273\213.md" "b/Jetpack/ui/material/2.NavigationView\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..546e04da
--- /dev/null
+++ "b/Jetpack/ui/material/2.NavigationView\347\256\200\344\273\213.md"
@@ -0,0 +1,192 @@
+# 2.NavigationView简介
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/navigation_view.png)
+
+NavigationView包含两个部分：menu和headerLayout。menu是用来在NavigationView中显示具体的菜单项的，headerLayout则是用来在NavigationView中显示头部布局的。
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/navigator_view.png?raw=true)
+
+一般来说NavigationView会和DrawerLayout一起用的比较多。
+
+## DrawerLayout
+
+- DrawerLayout 是作为一个页面（视窗）的顶层容器，它允许可以从页面（视窗）的边缘拉出。
+- 抽屉的子View通过`android:layout_gravity`属性可以决定抽取的抽取方向，一般是向左或者向右，（如果平台版本支持的话还可以上下抽出）。需要注意的是，每个页面的抽屉只能有一个抽出方向，如果你配置了多个抽出方向，那么抛异常。而且该属性必须指定。
+- 使用DrawerLayout的时候，第一个子View可以作为在 主内容 View，主内容View高度一般为match_parent并且不设置layout_gravity，然后，我们需要在 主内容 View后面添加一个View作为 `抽屉` View ，抽屉View可以通过layout_gravity属性设置一个合适的抽出方向。抽屉View通常高度是match_parent ，而宽度是固定的。
+
+
+
+## NavigationView
+
+NavigationView是一个标准的android程序的导航菜单。菜单的内容由xml布局文件进行填充。
+
+
+
+## 使用
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.drawerlayout.widget.DrawerLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:id="@+id/drawer"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:fitsSystemWindows="true"
+    // 指定位置                                       
+    tools:openDrawer="start"> 
+	// 主内容
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:orientation="vertical">
+
+        <com.google.android.material.appbar.MaterialToolbar
+            android:id="@+id/tb_main"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:background="@color/design_default_color_primary_dark" />
+
+        <com.google.android.material.textview.MaterialTextView
+            android:id="@+id/mtv_main"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="hahahhd"
+            android:textSize="20sp" />
+    </LinearLayout>
+	// 抽屉
+    <com.google.android.material.navigation.NavigationView
+        android:id="@+id/navigtaion"
+        android:layout_width="wrap_content"
+        android:layout_height="match_parent"
+        // 必须指定layout_gravity                                                   
+        android:layout_gravity="start"
+        // header的布局                                                   
+        app:headerLayout="@layout/header"
+        // menu的布局                                                   
+        app:menu="@menu/menu_navigation" />
+</androidx.drawerlayout.widget.DrawerLayout>
+```
+
+```kotlin
+class MainActivity : BaseActivity() {
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_main)
+        val mMaterialToolbar = findViewById<MaterialToolbar>(R.id.tb_main)
+        val mDrawerLayout = findViewById<DrawerLayout>(R.id.drawer)
+        val mNavigationView = findViewById<NavigationView>(R.id.navigtaion)
+        mMaterialToolbar.navigationIcon = getDrawable(R.drawable.vct_menu)
+        mMaterialToolbar.inflateMenu(R.menu.menu_toolbar_main)
+        mMaterialToolbar.title = "title"
+        mMaterialToolbar.setNavigationOnClickListener {
+            mDrawerLayout.openDrawer(mNavigationView)
+        }
+        mMaterialToolbar.setOnMenuItemClickListener {
+            Log.e("@@@", "lll")
+            true
+        }
+        mDrawerLayout.addDrawerListener(object : DrawerLayout.DrawerListener {
+            override fun onDrawerSlide(drawerView: View, slideOffset: Float) {
+            }
+
+            override fun onDrawerOpened(drawerView: View) {
+            }
+
+            override fun onDrawerClosed(drawerView: View) {
+            }
+
+            override fun onDrawerStateChanged(newState: Int) {
+            }
+
+        })
+        mNavigationView.setNavigationItemSelectedListener { menuItem ->
+            // Handle menu item selected
+            menuItem.isChecked = true
+            mDrawerLayout.closeDrawer(mNavigationView)
+            true
+        }
+    }
+}
+```
+
+header.xml如下:  
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:orientation="vertical">
+
+    <TextView
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_marginStart="24dp"
+        android:layout_marginTop="24dp"
+        android:layout_marginEnd="24dp"
+        android:text="header_title"
+        android:textAppearance="?attr/textAppearanceHeadline6" />
+
+    <TextView
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_marginStart="24dp"
+        android:layout_marginEnd="24dp"
+        android:layout_marginBottom="24dp"
+        android:text="header_text"
+        android:textAppearance="?attr/textAppearanceBody2"
+        android:textColor="@color/material_on_surface_emphasis_medium" />
+
+</LinearLayout>
+```
+
+menu_navigation.xml如下: 
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<menu xmlns:android="http://schemas.android.com/apk/res/android">
+    <group
+        android:id="@+id/group1"
+        android:checkableBehavior="single">
+        <item
+            android:id="@+id/item1"
+            android:icon="@mipmap/ic_launcher"
+            android:title="title1"/>
+            android:checked="true" />
+        <item
+            android:id="@+id/item2"
+            android:icon="@mipmap/ic_launcher"
+            android:title="title2"/>
+        <item
+            android:id="@+id/item3"
+            android:icon="@mipmap/ic_launcher"
+            android:title="title3"/>
+    </group>
+
+    <group
+        android:id="@+id/group2"
+        android:checkableBehavior="single">
+        <item
+            android:id="@+id/item11"
+            android:icon="@mipmap/ic_launcher"
+            android:title="title1"
+            android:checked="true" />
+        <item
+            android:id="@+id/item22"
+            android:icon="@mipmap/ic_launcher"
+            android:title="title2"/>
+        <item
+            android:id="@+id/item33"
+            android:icon="@mipmap/ic_launcher"
+            android:title="title3"/>
+    </group>
+</menu>
+```
+
+
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/navigation_drawer.png)
+
+[Navigation Drawer](https://material.io/components/navigation-drawer/android)
\ No newline at end of file
diff --git "a/Jetpack/ui/material/3.NestedScrollView\347\256\200\344\273\213.md" "b/Jetpack/ui/material/3.NestedScrollView\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..ba852382
--- /dev/null
+++ "b/Jetpack/ui/material/3.NestedScrollView\347\256\200\344\273\213.md"
@@ -0,0 +1,993 @@
+# 3.NestedScrollView简介
+```java
+public class NestedScrollView
+extends FrameLayout implements NestedScrollingParent3, NestedScrollingChild3, ScrollingView 
+
+NestedScrollView is just like ScrollView, but it supports acting as both a nested scrolling parent and child on both new and old versions of Android. Nested scrolling is enabled by default. 
+```
+
+NestedScrollView即支持嵌套滑动的ScrollView，因此我们可以简单的把NestedScrollView类比为ScrollView，其作用就是作为控件父布局，从而具备(嵌套)滑动的功能。
+
+它与ScrollView的区别就在于NestedScrollView支持嵌套滑动，无论是作为父控件还是子控件，嵌套滑动都支持，且默认开启。
+因此，在一些需要支持嵌套滑动的情景中，比如一个ScrollView内部内部包裹一个RecyclerView，那么就会产生滑动冲突，这个问题就需要你自己去解决。而如果使用 NestedScrollView包裹RecyclerView，嵌套滑动天然支持，你无需做什么就可以实现前面想要实现的功能了。
+
+我们通常为RecyclerView增加一个Header和Footer的方法是通过定义不同的viewType来区分的，而如果使用NestedScrollView，我们完全可以把RecyclerView当成一个单独的控件，然后在其上面增加一个控件作为Header，在其下面增加一个控件作为Footer。
+
+
+虽然NestedScrollView内嵌RecyclerView和其他控件可以实现Header和Footer，但还是不推荐上面这种做法（建议还是直接使用RecyclerView自己添加Header和Footer），因为虽然NestedScrollView支持嵌套滑动，但是在实际应用中，嵌套滑动可能会带来其他的一些奇奇怪怪的副作用，Google也推荐我们能不使用嵌套滑动就尽量不要使用。
+
+
+我们知道，在Android系统对于Touch事件有一套自己的分发机制，其中主要涉及到以下三个方法：
+- dispatchTouchEvent()：主要是在View和ViewGroup中进行事件分发
+- onInterceptTouchEvent()：进行Touch事件的拦截
+- onTouchEvent()：Touch事件的处理
+
+但是这里分发过程会有个问题，如果子View消费本次事件，父View就没法再对触摸事件进行处理，同理，如果父View将事件拦截了，本次触摸手势内就无法再讲事件分发给子View。这种情况如果如果想要处理父View和子View的嵌套滑动就比较困难了。因此，当有嵌套滑动场景时，我们都需要自己手动解决事件冲突。而在Android 5.0 Lollipop之后，Google官方通过嵌套滑动(NestedScrolling)机制解决了传统Android事件分发无法共享事件这个问题。
+
+## NestedScrolling机制
+
+嵌套滑动机制的基本原理可以认为是事件共享，即当子控件(内部NestedScrollingChild)接收到滑动事件，准备要滑动时，会先通知父控件(startNestedScroll）；然后在滑动之前，会先询问父控件(NestedScrollingParent)是否要滑动（dispatchNestedPreScroll)；如果父控件响应该事件进行了滑动，那么就会通知子控件它具体消耗了多少滑动距离；然后交由子控件处理剩余的滑动距离；最后子控件滑动结束后，如果滑动距离还有剩余，就会再问一下父控件是否需要在继续滑动剩下的距离（dispatchNestedScroll)...
+
+那么如果想让我们自定义的View或者ViewGroup实现嵌套滑动功能，应该怎样做呢？
+
+其实，在Android 5.0之后，系统自带的View和ViewGroup都增加了嵌套滑动机制相关的方法了（但是默认不会被调用，因此默认不具备嵌套滑动功能），所以如果在Android 5.0及之后的平台上，自定义View只要覆写相应的嵌套滑动机制相关方法即可；但是为了提供低版本兼容性，Google 官方还提供了两个接口，分别作为嵌套滑动机制父控件接口和子控件接口:  
+- NestedScrollingParent：作为父控件，支持嵌套滑动功能。
+- NestedScrollingChild：作为子控件，支持嵌套滑动功能。
+
+前面我们说过NestedScrollView无论是作为父控件还是子控件都支持嵌套滑动，就是因为它同时实现了 NestedScrollingParent和NestedScrollingChild。
+
+下面我们就先说下NestedScrollingParent和NestedScrollingChild这两个类。
+
+
+## 嵌套滑动机制兼容处理
+LOLLIPOP(SDK21)之后嵌套滑动的相关逻辑作为普通方法直接写进了最新的(SDK21之后)View和ViewGroup类.普通方法是指这个方法不是继承自接口或者其他类, 例如[View#dispatchNestedScroll](https://developer.android.com/reference/android/view/View.html#dispatchNestedScroll(int, int, int, int, int[])), 可以看到官方标注了Added in API level21标示,也就是说这是在SDK21版本之后添加进去的一个普通方法.
+
+### 向前兼容而SDK21之前的版本
+
+官方在android.support.v4兼容包中提供了两个接口NestedScrollingChild和NestedScrollingParent, 还有两个辅助类NestedScrollingChildHelper和NestedScrollingParentHelper来帮助控件实现嵌套滑动.这个兼容的原理很简单：两个接口NestedScrollingChild和NestedScrollingParent分别定义上面提到的View和ViewParent新增的普通方法。
+在嵌套滑动中会要求控件要么是继承于SDK21之后的View或ViewGroup,要么实现了这两个接口,这是控件能够进行嵌套滑动的前提条件.那么怎么知道调用的方法是控件自有的方法, 还是接口的方法? 在代码中是通过ViewCompat和ViewParentCompat类来实现.ViewCompat和ViewParentCompat通过当前的Build.VERSION.SDK_INT来判断当前版本, 然后选择不同的实现类, 这样就可以根据版本选择调用的方法.
+例如如果版本是SDK21之前, 那么就会判断控件是否实现了接口,然后调用接口的方法,如果是SDK21之后, 那么就可以直接调用对应的方法.
+
+### 辅助类
+除了接口兼容包还提供了NestedScrollingChildHelper和NestedScrollingParentHelper两个辅助类, 这两个辅助类实际上就是对应View和ViewParent中新增的普通方法, 代码就不贴了, 简单对比下就可以发现, 对应方法实现的逻辑基本一样, 所以只要在接口方法内对应调用辅助类的方法就可以兼容嵌套滑动了.
+
+例如在NestedScrollingChild#startNestedScroll方法中调用NestedScrollingChildHelper#startNestedScroll，这里实际用了代理模式来让SDK21之前的控件具有了新增的方法。
+
+#### 默认处理逻辑
+
+虽然View和ViewGroup(SDK21之后)本身就具有嵌套滑动的相关方法, 但是默认情况是是不会被调用, 因为View和ViewGroup本身不支持滑动。
+NestedScrolling提供了一套父View和子View滑动交互机制。要完成这样的交互，父View需要实现 NestedScrollingParent接口，而子View需要实现NestedScrollingChild接口。
+
+### NestedScrollingChild
+如果你有一个可以滑动的View，需要被用来作为嵌入滑动的子View，就必须实现本接口。在此View中，包含一个NestedScrollingChildHelper辅助类。
+
+NestedScrollingChild接口的实现，基本上就是调用该Helper类的对应的方法，因为Helper类中已经实现好了Child和Parent交互的逻辑。原来的View处理的Touch事件，并实现滑动的逻辑大体上不需要改变。
+需要做的就是，如果要准备开始滑动了，需要告诉Parent，你要准备进入滑动状态了，调用startNestedScroll()。你在滑动之前，先问一下Parent是否需要滑动，也就是调用dispatchNestedPreScroll()。如果父类滑动了一定距离，你需要重新计算一下父类滑动后剩下给你的滑动距离剩余量。然后，你自己进行余下的滑动。最后，如果滑动距离还有剩余，你就再问一下，Parent是否需要继续滑动你剩下的距离，也就是调用dispatchNestedScroll()。
+
+- startNestedScroll
+
+    起始方法, 主要作用是找到接收滑动距离信息的外控件，表示view开始滚动了,一般是在ACTION_DOWN中调用，如果返回true则表示父布局支持嵌套滚动。一般也是直接代理给NestedScrollingChildHelper的同名方法即可。这个时候正常情况会触发Parent的onStartNestedScroll()方法.
+
+- dispatchNestedPreScroll
+
+    在当前View消费滚动距离之前把滑动距离传给父布局。相当于把优先处理权交给Parent。返回true代表Parent消费了滚动距离
+
+- dispatchNestedScroll
+
+    在当前View消费滚动距离之后。通过调用该方法，把剩下的滚动距离传给父布局。如果当前没有发送嵌套滚动，或者不支持嵌套滚动，调用该方法也没啥用。
+
+- stopNestedScroll
+
+    结束方法, 主要作用就是清空嵌套滑动的相关状态。一般是在事件结束比如ACTION_UP或者ACTION_CANCLE中调用,告诉父布局滚动结束。
+
+- setNestedScrollingEnabled和isNestedScrollingEnabled
+
+    一对get&set方法, 用来判断控件是否支持嵌套滑动.
+
+- dispatchNestedPreFling
+
+    在当前View自己处理惯性滑动前，先将滑动事件分发给Parent。返回true表示Parent已经处理了滑动事件。一般来说如果想自己处理惯性的滑动事件，就不应该调用该方法给Parent处理。如果给了Parent并且返回true，那表示Parent已经处理了，自己就不应该再做处理。返回false则表示Parent没有处理，但是不代表Parent后面就不用处理了。
+
+- dispatchNestedFling
+
+    将惯性滑动的速度分发给Parent。返回true表示Parent处理了滑动事件。
+
+### NestedScrollingParent
+作为一个可以嵌入NestedScrollingChild的父View，需要实现NestedScrollingParent，这个接口的方法和NestedScrollingChild大致有一一对应的关系。同样，它也有一个NestedScrollingParentHelper辅助类来默默的帮助你实现和Child交互的逻辑。
+
+滑动动作是Child主动发起，Parent接收滑动回调并作出响应。
+从上面的Child分析可知，滑动开始的调用startNestedScroll()，Parent收到onStartNestedScroll()回调，决定是否需要配合Child一起进行处理滑动，如果需要配合，还会回调onNestedScrollAccepted()。
+每次滑动前，Child先询问Parent是否需要滑动，即dispatchNestedPreScroll()，这就回调到Parent的onNestedPreScroll()，Parent可以在这个回调中“劫持”掉Child的滑动，也就是先于Child滑动。
+Child滑动以后，会调用onNestedScroll()，回调到Parent的onNestedScroll()，这里就是Child滑动后，剩下的给Parent处理，也就是后于Child滑动。
+最后，滑动结束，调用onStopNestedScroll()表示本次处理结束。因为内控件是发起者,所以外控件的大部分方法都是被内控件的对应方法回调的.    
+
+- onStartNestedScroll
+
+    对应startNestedScroll,当NestedScrollingChild调用方法startNestedScroll()时,会调用该方法。主要就是通过返回值告诉系统是否需要对后续的滚动进行处理。返回true表示我需要进行处理，后续的滚动会触发相应的回到，返回false表示我不需要处理，后面也就不会进行相应的回调了。
+
+- onNestedScrollAccepted
+
+    如果onStartNestedScroll()方法返回的是true的话,那么紧接着就会调用该方法.它是让嵌套滚动在开始滚动之前,让布局容器(viewGroup)或者它的父类执行一些配置的初始化的。
+
+- onNestedPreScroll
+
+    关键方法,接收内控件处理滑动前的滑动距离信息,在这里外控件可以优先响应滑动操作, 消耗部分或者全部滑动距离.
+
+- onNestedScroll(View target, int dx, int dy, int[] consumed)
+
+    当子view调用dispatchNestedPreScroll()方法时会调用该方法。也就是在NestedScrollingChild在处理滑动之前，会先将机会给Parent处理。如果Parent想先消费部分滚动距离，将消费的距离放入consumed。consumed表示Parent要消费的滚动距离,consumed[0]和consumed[1]分别表示父布局在x和y方向上消费的距离.
+
+- onStopNestedScroll
+
+    停止滚动了,当子view调用stopNestedScroll()时会调用该方法,用来做一些收尾工作.
+
+- onNestedFling
+
+    你可以捕获对内部NestedScrollingChild的fling事件，如果return true则表示消费了滑动事件
+
+- onNestedPreFling
+
+    在惯性滑动距离处理之前，会调用该方法，同onNestedPreScroll()一样，也是给Parent优先处理的权利。返回true则表示Parent要处理本次滑动事件，Child就不要处理了。
+
+### NestedScrollingParentHelper
+
+这个类比较简单，方法也很简单，基本上就是一些赋值操作。所以就不多介绍了。这里就说下它的两个成员变量: 
+- mViewGroup：用于记录所关联的ViewGroup。起始也就是我们需要进程滑动处理的NestedScrollingParent
+- mNestedScrollAxes：这个就是滑动的方向了。
+然后另外需要注意的就是记得在NestedScrollingParent的实现类中，将相同签名的方法代理给我们的Helper类就可以了。
+
+```java
+/**
+ * Helper class for implementing nested scrolling parent views compatible with Android platform
+ * versions earlier than Android 5.0 Lollipop (API 21).
+ *
+ * <p>{@link android.view.ViewGroup ViewGroup} subclasses should instantiate a final instance
+ * of this class as a field at construction. For each <code>ViewGroup</code> method that has
+ * a matching method signature in this class, delegate the operation to the helper instance
+ * in an overridden method implementation. This implements the standard framework policy
+ * for nested scrolling.</p>
+ *
+ * <p>Views invoking nested scrolling functionality should always do so from the relevant
+ * {@link androidx.core.view.ViewCompat}, {@link androidx.core.view.ViewGroupCompat} or
+ * {@link androidx.core.view.ViewParentCompat} compatibility
+ * shim static methods. This ensures interoperability with nested scrolling views on Android
+ * 5.0 Lollipop and newer.</p>
+ */
+public class NestedScrollingParentHelper {
+    private int mNestedScrollAxesTouch;
+    private int mNestedScrollAxesNonTouch;
+
+    /**
+     * Construct a new helper for a given ViewGroup
+     */
+    public NestedScrollingParentHelper(@NonNull ViewGroup viewGroup) {
+    }
+
+    /**
+     * Called when a nested scrolling operation initiated by a descendant view is accepted
+     * by this ViewGroup.
+     *
+     * <p>This is a delegate method. Call it from your {@link android.view.ViewGroup ViewGroup}
+     * subclass method/{@link androidx.core.view.NestedScrollingParent} interface method with
+     * the same signature to implement the standard policy.</p>
+     */
+    public void onNestedScrollAccepted(@NonNull View child, @NonNull View target,
+            @ScrollAxis int axes) {
+        onNestedScrollAccepted(child, target, axes, ViewCompat.TYPE_TOUCH);
+    }
+
+    /**
+     * Called when a nested scrolling operation initiated by a descendant view is accepted
+     * by this ViewGroup.
+     *
+     * <p>This is a delegate method. Call it from your {@link android.view.ViewGroup ViewGroup}
+     * subclass method/{@link androidx.core.view.NestedScrollingParent2} interface method with
+     * the same signature to implement the standard policy.</p>
+     */
+    public void onNestedScrollAccepted(@NonNull View child, @NonNull View target,
+            @ScrollAxis int axes, @NestedScrollType int type) {
+        if (type == ViewCompat.TYPE_NON_TOUCH) {
+            mNestedScrollAxesNonTouch = axes;
+        } else {
+            mNestedScrollAxesTouch = axes;
+        }
+    }
+
+    /**
+     * Return the current axes of nested scrolling for this ViewGroup.
+     *
+     * <p>This is a delegate method. Call it from your {@link android.view.ViewGroup ViewGroup}
+     * subclass method/{@link androidx.core.view.NestedScrollingParent} interface method with
+     * the same signature to implement the standard policy.</p>
+     */
+    @ScrollAxis
+    public int getNestedScrollAxes() {
+        return mNestedScrollAxesTouch | mNestedScrollAxesNonTouch;
+    }
+
+    /**
+     * React to a nested scroll operation ending.
+     *
+     * <p>This is a delegate method. Call it from your {@link android.view.ViewGroup ViewGroup}
+     * subclass method/{@link androidx.core.view.NestedScrollingParent} interface method with
+     * the same signature to implement the standard policy.</p>
+     */
+    public void onStopNestedScroll(@NonNull View target) {
+        onStopNestedScroll(target, ViewCompat.TYPE_TOUCH);
+    }
+
+    /**
+     * React to a nested scroll operation ending.
+     *
+     * <p>This is a delegate method. Call it from your {@link android.view.ViewGroup ViewGroup}
+     * subclass method/{@link androidx.core.view.NestedScrollingParent2} interface method with
+     * the same signature to implement the standard policy.</p>
+     */
+    public void onStopNestedScroll(@NonNull View target, @NestedScrollType int type) {
+        if (type == ViewCompat.TYPE_NON_TOUCH) {
+            mNestedScrollAxesNonTouch = ViewGroup.SCROLL_AXIS_NONE;
+        } else {
+            mNestedScrollAxesTouch = ViewGroup.SCROLL_AXIS_NONE;
+        }
+    }
+}
+```
+
+### NestedScrollingChildHelper
+这个类其实就是NestedScrollingChild的标准实现。只是Java没有多继承，我们自定义View的时候只能通过实现NestedScrollingChild接口，然后在重写需要方法中，交个这个标准实现来处理就行了，相当于一种代理模式吧。
+```java
+import static androidx.core.view.ViewCompat.TYPE_NON_TOUCH;
+import static androidx.core.view.ViewCompat.TYPE_TOUCH;
+
+import android.view.View;
+import android.view.ViewParent;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.core.view.ViewCompat.NestedScrollType;
+import androidx.core.view.ViewCompat.ScrollAxis;
+
+/**
+ * Helper class for implementing nested scrolling child views compatible with Android platform
+ * versions earlier than Android 5.0 Lollipop (API 21).
+ *
+ * <p>{@link android.view.View View} subclasses should instantiate a final instance of this
+ * class as a field at construction. For each <code>View</code> method that has a matching
+ * method signature in this class, delegate the operation to the helper instance in an overridden
+ * method implementation. This implements the standard framework policy for nested scrolling.</p>
+ *
+ * <p>Views invoking nested scrolling functionality should always do so from the relevant
+ * {@link androidx.core.view.ViewCompat}, {@link androidx.core.view.ViewGroupCompat} or
+ * {@link androidx.core.view.ViewParentCompat} compatibility
+ * shim static methods. This ensures interoperability with nested scrolling views on Android
+ * 5.0 Lollipop and newer.</p>
+ */
+public class NestedScrollingChildHelper {
+    private ViewParent mNestedScrollingParentTouch;
+    private ViewParent mNestedScrollingParentNonTouch;
+    private final View mView;
+    private boolean mIsNestedScrollingEnabled;
+    private int[] mTempNestedScrollConsumed;
+
+    /**
+     * Construct a new helper for a given view.
+     */
+    public NestedScrollingChildHelper(@NonNull View view) {
+        mView = view;
+    }
+
+    /**
+     * Enable nested scrolling.
+     *
+     * <p>This is a delegate method. Call it from your {@link android.view.View View} subclass
+     * method/{@link androidx.core.view.NestedScrollingChild} interface method with the same
+     * signature to implement the standard policy.</p>
+     *
+     * @param enabled true to enable nested scrolling dispatch from this view, false otherwise
+     */
+    public void setNestedScrollingEnabled(boolean enabled) {
+        if (mIsNestedScrollingEnabled) {
+            ViewCompat.stopNestedScroll(mView);
+        }
+        mIsNestedScrollingEnabled = enabled;
+    }
+
+    /**
+     * Check if nested scrolling is enabled for this view.
+     *
+     * <p>This is a delegate method. Call it from your {@link android.view.View View} subclass
+     * method/{@link androidx.core.view.NestedScrollingChild} interface method with the same
+     * signature to implement the standard policy.</p>
+     *
+     * @return true if nested scrolling is enabled for this view
+     */
+    public boolean isNestedScrollingEnabled() {
+        return mIsNestedScrollingEnabled;
+    }
+
+    /**
+     * Check if this view has a nested scrolling parent view currently receiving events for
+     * a nested scroll in progress with the type of touch.
+     *
+     * <p>This is a delegate method. Call it from your {@link android.view.View View} subclass
+     * method/{@link androidx.core.view.NestedScrollingChild} interface method with the same
+     * signature to implement the standard policy.</p>
+     *
+     * @return true if this view has a nested scrolling parent, false otherwise
+     */
+    public boolean hasNestedScrollingParent() {
+        return hasNestedScrollingParent(TYPE_TOUCH);
+    }
+
+    /**
+     * Check if this view has a nested scrolling parent view currently receiving events for
+     * a nested scroll in progress with the given type.
+     *
+     * <p>This is a delegate method. Call it from your {@link android.view.View View} subclass
+     * method/{@link androidx.core.view.NestedScrollingChild} interface method with the same
+     * signature to implement the standard policy.</p>
+     *
+     * @return true if this view has a nested scrolling parent, false otherwise
+     */
+    public boolean hasNestedScrollingParent(@NestedScrollType int type) {
+        return getNestedScrollingParentForType(type) != null;
+    }
+
+    /**
+     * Start a new nested scroll for this view.
+     *
+     * <p>This is a delegate method. Call it from your {@link android.view.View View} subclass
+     * method/{@link androidx.core.view.NestedScrollingChild} interface method with the same
+     * signature to implement the standard policy.</p>
+     *
+     * @param axes Supported nested scroll axes.
+     *             See {@link androidx.core.view.NestedScrollingChild#startNestedScroll(int)}.
+     * @return true if a cooperating parent view was found and nested scrolling started successfully
+     */
+    public boolean startNestedScroll(@ScrollAxis int axes) {
+        return startNestedScroll(axes, TYPE_TOUCH);
+    }
+
+    /**
+     * Start a new nested scroll for this view.
+     *
+     * <p>This is a delegate method. Call it from your {@link android.view.View View} subclass
+     * method/{@link androidx.core.view.NestedScrollingChild2} interface method with the same
+     * signature to implement the standard policy.</p>
+     *
+     * @param axes Supported nested scroll axes.
+     *             See {@link androidx.core.view.NestedScrollingChild2#startNestedScroll(int,
+     *             int)}.
+     * @return true if a cooperating parent view was found and nested scrolling started successfully
+     */
+    public boolean startNestedScroll(@ScrollAxis int axes, @NestedScrollType int type) {
+        if (hasNestedScrollingParent(type)) {
+            // Already in progress
+            return true;
+        }
+        if (isNestedScrollingEnabled()) {
+            ViewParent p = mView.getParent();
+            View child = mView;
+            while (p != null) {
+                if (ViewParentCompat.onStartNestedScroll(p, child, mView, axes, type)) {
+                    setNestedScrollingParentForType(type, p);
+                    ViewParentCompat.onNestedScrollAccepted(p, child, mView, axes, type);
+                    return true;
+                }
+                if (p instanceof View) {
+                    child = (View) p;
+                }
+                p = p.getParent();
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Stop a nested scroll in progress.
+     *
+     * <p>This is a delegate method. Call it from your {@link android.view.View View} subclass
+     * method/{@link androidx.core.view.NestedScrollingChild} interface method with the same
+     * signature to implement the standard policy.</p>
+     */
+    public void stopNestedScroll() {
+        stopNestedScroll(TYPE_TOUCH);
+    }
+
+    /**
+     * Stop a nested scroll in progress.
+     *
+     * <p>This is a delegate method. Call it from your {@link android.view.View View} subclass
+     * method/{@link androidx.core.view.NestedScrollingChild2} interface method with the same
+     * signature to implement the standard policy.</p>
+     */
+    public void stopNestedScroll(@NestedScrollType int type) {
+        ViewParent parent = getNestedScrollingParentForType(type);
+        if (parent != null) {
+            ViewParentCompat.onStopNestedScroll(parent, mView, type);
+            setNestedScrollingParentForType(type, null);
+        }
+    }
+
+    /**
+     * Dispatch one step of a nested scrolling operation to the current nested scrolling parent.
+     *
+     * <p>This is a delegate method. Call it from your {@link android.view.View View} subclass
+     * method/{@link androidx.core.view.NestedScrollingChild} interface method with the same
+     * signature to implement the standard policy.</p>
+     *
+     * @return <code>true</code> if the parent consumed any of the nested scroll distance
+     */
+    public boolean dispatchNestedScroll(int dxConsumed, int dyConsumed,
+            int dxUnconsumed, int dyUnconsumed, @Nullable int[] offsetInWindow) {
+        return dispatchNestedScrollInternal(dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed,
+                offsetInWindow, TYPE_TOUCH, null);
+    }
+
+    /**
+     * Dispatch one step of a nested scrolling operation to the current nested scrolling parent.
+     *
+     * <p>This is a delegate method. Call it from your {@link NestedScrollingChild2} interface
+     * method with the same signature to implement the standard policy.
+     *
+     * @return <code>true</code> if the parent consumed any of the nested scroll distance
+     */
+    public boolean dispatchNestedScroll(int dxConsumed, int dyConsumed, int dxUnconsumed,
+            int dyUnconsumed, @Nullable int[] offsetInWindow, @NestedScrollType int type) {
+        return dispatchNestedScrollInternal(dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed,
+                offsetInWindow, type, null);
+    }
+
+    /**
+     * Dispatch one step of a nested scrolling operation to the current nested scrolling parent.
+     *
+     * <p>This is a delegate method. Call it from your {@link NestedScrollingChild3} interface
+     * method with the same signature to implement the standard policy.
+     */
+    public void dispatchNestedScroll(int dxConsumed, int dyConsumed, int dxUnconsumed,
+            int dyUnconsumed, @Nullable int[] offsetInWindow, @NestedScrollType int type,
+            @Nullable int[] consumed) {
+        dispatchNestedScrollInternal(dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed,
+                offsetInWindow, type, consumed);
+    }
+
+    private boolean dispatchNestedScrollInternal(int dxConsumed, int dyConsumed,
+            int dxUnconsumed, int dyUnconsumed, @Nullable int[] offsetInWindow,
+            @NestedScrollType int type, @Nullable int[] consumed) {
+        if (isNestedScrollingEnabled()) {
+            final ViewParent parent = getNestedScrollingParentForType(type);
+            if (parent == null) {
+                return false;
+            }
+
+            if (dxConsumed != 0 || dyConsumed != 0 || dxUnconsumed != 0 || dyUnconsumed != 0) {
+                int startX = 0;
+                int startY = 0;
+                if (offsetInWindow != null) {
+                    mView.getLocationInWindow(offsetInWindow);
+                    startX = offsetInWindow[0];
+                    startY = offsetInWindow[1];
+                }
+
+                if (consumed == null) {
+                    consumed = getTempNestedScrollConsumed();
+                    consumed[0] = 0;
+                    consumed[1] = 0;
+                }
+
+                ViewParentCompat.onNestedScroll(parent, mView,
+                        dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed, type, consumed);
+
+                if (offsetInWindow != null) {
+                    mView.getLocationInWindow(offsetInWindow);
+                    offsetInWindow[0] -= startX;
+                    offsetInWindow[1] -= startY;
+                }
+                return true;
+            } else if (offsetInWindow != null) {
+                // No motion, no dispatch. Keep offsetInWindow up to date.
+                offsetInWindow[0] = 0;
+                offsetInWindow[1] = 0;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Dispatch one step of a nested pre-scrolling operation to the current nested scrolling parent.
+     *
+     * <p>This is a delegate method. Call it from your {@link android.view.View View} subclass
+     * method/{@link androidx.core.view.NestedScrollingChild} interface method with the same
+     * signature to implement the standard policy.</p>
+     *
+     * @return true if the parent consumed any of the nested scroll
+     */
+    public boolean dispatchNestedPreScroll(int dx, int dy, @Nullable int[] consumed,
+            @Nullable int[] offsetInWindow) {
+        return dispatchNestedPreScroll(dx, dy, consumed, offsetInWindow, TYPE_TOUCH);
+    }
+
+    /**
+     * Dispatch one step of a nested pre-scrolling operation to the current nested scrolling parent.
+     *
+     * <p>This is a delegate method. Call it from your {@link android.view.View View} subclass
+     * method/{@link androidx.core.view.NestedScrollingChild2} interface method with the same
+     * signature to implement the standard policy.</p>
+     *
+     * @return true if the parent consumed any of the nested scroll
+     */
+    public boolean dispatchNestedPreScroll(int dx, int dy, @Nullable int[] consumed,
+            @Nullable int[] offsetInWindow, @NestedScrollType int type) {
+        if (isNestedScrollingEnabled()) {
+            final ViewParent parent = getNestedScrollingParentForType(type);
+            if (parent == null) {
+                return false;
+            }
+
+            if (dx != 0 || dy != 0) {
+                int startX = 0;
+                int startY = 0;
+                if (offsetInWindow != null) {
+                    mView.getLocationInWindow(offsetInWindow);
+                    startX = offsetInWindow[0];
+                    startY = offsetInWindow[1];
+                }
+
+                if (consumed == null) {
+                    consumed = getTempNestedScrollConsumed();
+                }
+                consumed[0] = 0;
+                consumed[1] = 0;
+                ViewParentCompat.onNestedPreScroll(parent, mView, dx, dy, consumed, type);
+
+                if (offsetInWindow != null) {
+                    mView.getLocationInWindow(offsetInWindow);
+                    offsetInWindow[0] -= startX;
+                    offsetInWindow[1] -= startY;
+                }
+                return consumed[0] != 0 || consumed[1] != 0;
+            } else if (offsetInWindow != null) {
+                offsetInWindow[0] = 0;
+                offsetInWindow[1] = 0;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Dispatch a nested fling operation to the current nested scrolling parent.
+     *
+     * <p>This is a delegate method. Call it from your {@link android.view.View View} subclass
+     * method/{@link androidx.core.view.NestedScrollingChild} interface method with the same
+     * signature to implement the standard policy.</p>
+     *
+     * @return true if the parent consumed the nested fling
+     */
+    public boolean dispatchNestedFling(float velocityX, float velocityY, boolean consumed) {
+        if (isNestedScrollingEnabled()) {
+            ViewParent parent = getNestedScrollingParentForType(TYPE_TOUCH);
+            if (parent != null) {
+                return ViewParentCompat.onNestedFling(parent, mView, velocityX,
+                        velocityY, consumed);
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Dispatch a nested pre-fling operation to the current nested scrolling parent.
+     *
+     * <p>This is a delegate method. Call it from your {@link android.view.View View} subclass
+     * method/{@link androidx.core.view.NestedScrollingChild} interface method with the same
+     * signature to implement the standard policy.</p>
+     *
+     * @return true if the parent consumed the nested fling
+     */
+    public boolean dispatchNestedPreFling(float velocityX, float velocityY) {
+        if (isNestedScrollingEnabled()) {
+            ViewParent parent = getNestedScrollingParentForType(TYPE_TOUCH);
+            if (parent != null) {
+                return ViewParentCompat.onNestedPreFling(parent, mView, velocityX,
+                        velocityY);
+            }
+        }
+        return false;
+    }
+
+    /**
+     * View subclasses should always call this method on their
+     * <code>NestedScrollingChildHelper</code> when detached from a window.
+     *
+     * <p>This is a delegate method. Call it from your {@link android.view.View View} subclass
+     * method/{@link androidx.core.view.NestedScrollingChild} interface method with the same
+     * signature to implement the standard policy.</p>
+     */
+    public void onDetachedFromWindow() {
+        ViewCompat.stopNestedScroll(mView);
+    }
+
+    /**
+     * Called when a nested scrolling child stops its current nested scroll operation.
+     *
+     * <p>This is a delegate method. Call it from your {@link android.view.View View} subclass
+     * method/{@link androidx.core.view.NestedScrollingChild} interface method with the same
+     * signature to implement the standard policy.</p>
+     *
+     * @param child Child view stopping its nested scroll. This may not be a direct child view.
+     */
+    public void onStopNestedScroll(@NonNull View child) {
+        ViewCompat.stopNestedScroll(mView);
+    }
+
+    private ViewParent getNestedScrollingParentForType(@NestedScrollType int type) {
+        switch (type) {
+            case TYPE_TOUCH:
+                return mNestedScrollingParentTouch;
+            case TYPE_NON_TOUCH:
+                return mNestedScrollingParentNonTouch;
+        }
+        return null;
+    }
+
+    private void setNestedScrollingParentForType(@NestedScrollType int type, ViewParent p) {
+        switch (type) {
+            case TYPE_TOUCH:
+                mNestedScrollingParentTouch = p;
+                break;
+            case TYPE_NON_TOUCH:
+                mNestedScrollingParentNonTouch = p;
+                break;
+        }
+    }
+
+    private int[] getTempNestedScrollConsumed() {
+        if (mTempNestedScrollConsumed == null) {
+            mTempNestedScrollConsumed = new int[2];
+        }
+        return mTempNestedScrollConsumed;
+    }
+}
+```
+
+
+
+## 从NestedScrollView看嵌套机制
+
+说完上面一大通, 终于可以开始分析源码来了解嵌套滑动机制起作用的具体逻辑了，首先是NestedScrollView.onTouchEvent方法: 
+```java
+    @Override
+    public boolean onTouchEvent(MotionEvent ev) {
+        initVelocityTrackerIfNotExists();
+
+        final int actionMasked = ev.getActionMasked();
+
+        if (actionMasked == MotionEvent.ACTION_DOWN) {
+            mNestedYOffset = 0;
+        }
+
+        MotionEvent vtev = MotionEvent.obtain(ev);
+        vtev.offsetLocation(0, mNestedYOffset);
+
+        switch (actionMasked) {
+            case MotionEvent.ACTION_DOWN: {
+                if (getChildCount() == 0) {
+                    return false;
+                }
+                if ((mIsBeingDragged = !mScroller.isFinished())) {
+                    final ViewParent parent = getParent();
+                    if (parent != null) {
+                        parent.requestDisallowInterceptTouchEvent(true);
+                    }
+                }
+
+                /*
+                 * If being flinged and user touches, stop the fling. isFinished
+                 * will be false if being flinged.
+                 */
+                if (!mScroller.isFinished()) {
+                    abortAnimatedScroll();
+                }
+
+                // Remember where the motion event started
+                mLastMotionY = (int) ev.getY();
+                mActivePointerId = ev.getPointerId(0);
+                // 内部会调用mChildHelper.startNestedScroll(axes, type);
+                startNestedScroll(ViewCompat.SCROLL_AXIS_VERTICAL, ViewCompat.TYPE_TOUCH);
+                break;
+            }
+            case MotionEvent.ACTION_MOVE:
+
+            break;
+            ....
+
+```
+继续看mChildHelper.startNestedScroll(axes, type): 
+```java
+    public boolean startNestedScroll(@ScrollAxis int axes, @NestedScrollType int type) {
+        if (hasNestedScrollingParent(type)) {
+            // Already in progress
+            return true;
+        }
+        // 首先子view要先使用嵌套滑动机制
+        if (isNestedScrollingEnabled()) {
+            ViewParent p = mView.getParent();
+            View child = mView;
+            while (p != null) {
+                // 遍历视图层级，找到父控件为NestedScrollingParent2或NestedScrollingParent，并且onStartNestedScroll返回true，表示接受该嵌套滑动事件 
+                if (ViewParentCompat.onStartNestedScroll(p, child, mView, axes, type)) {
+                    setNestedScrollingParentForType(type, p);
+                    // 找到父控件后，立即调用父控件的onNestedScrollAccepted
+                    ViewParentCompat.onNestedScrollAccepted(p, child, mView, axes, type);
+                    return true;
+                }
+                if (p instanceof View) {
+                    child = (View) p;
+                }
+                p = p.getParent();
+            }
+        }
+        return false;
+    }
+```
+至此，ACTION_DOWN事件的处理就结束了。
+
+接下来看下NestedScrollView对于ACTION_MOVE事件的处理：
+```java
+case MotionEvent.ACTION_MOVE:
+                final int activePointerIndex = ev.findPointerIndex(mActivePointerId);
+                if (activePointerIndex == -1) {
+                    Log.e(TAG, "Invalid pointerId=" + mActivePointerId + " in onTouchEvent");
+                    break;
+                }
+
+                final int y = (int) ev.getY(activePointerIndex);
+                int deltaY = mLastMotionY - y;
+                //子view准备滑动，通知父控件
+                // 内部调用mChildHelper.dispatchNestedPreScroll(dx, dy, consumed, offsetInWindow, type);
+                if (dispatchNestedPreScroll(0, deltaY, mScrollConsumed, mScrollOffset,
+                        ViewCompat.TYPE_TOUCH)) {
+                    // 父控件消费了mScrollConsumed[1]，子 view 还剩下 deltaY 距离可以消费
+                    deltaY -= mScrollConsumed[1];
+                    mNestedYOffset += mScrollOffset[1];
+                }
+                if (!mIsBeingDragged && Math.abs(deltaY) > mTouchSlop) {
+                    final ViewParent parent = getParent();
+                    if (parent != null) {
+                        parent.requestDisallowInterceptTouchEvent(true);
+                    }
+                    mIsBeingDragged = true;
+                    if (deltaY > 0) {
+                        deltaY -= mTouchSlop;
+                    } else {
+                        deltaY += mTouchSlop;
+                    }
+                }
+                // 拖动状态下
+                if (mIsBeingDragged) {
+                    // Scroll to follow the motion event
+                    mLastMotionY = y - mScrollOffset[1];
+
+                    final int oldY = getScrollY();
+                    final int range = getScrollRange();
+                    final int overscrollMode = getOverScrollMode();
+                    boolean canOverscroll = overscrollMode == View.OVER_SCROLL_ALWAYS
+                            || (overscrollMode == View.OVER_SCROLL_IF_CONTENT_SCROLLS && range > 0);
+
+                    // Calling overScrollByCompat will call onOverScrolled, which
+                    // calls onScrollChanged if applicable.
+                    if (overScrollByCompat(0, deltaY, 0, getScrollY(), 0, range, 0,
+                            0, true) && !hasNestedScrollingParent(ViewCompat.TYPE_TOUCH)) {
+                        // Break our velocity if we hit a scroll barrier.
+                        mVelocityTracker.clear();
+                    }
+
+                    final int scrolledDeltaY = getScrollY() - oldY;
+                    final int unconsumedY = deltaY - scrolledDeltaY;
+
+                    mScrollConsumed[1] = 0;
+                    // 子view消费滑动事件后，将消费距离详情通知父控件，内部调用ChildHelper.dispatchNestedScroll
+                    dispatchNestedScroll(0, scrolledDeltaY, 0, unconsumedY, mScrollOffset,
+                            ViewCompat.TYPE_TOUCH, mScrollConsumed);
+
+                    mLastMotionY -= mScrollOffset[1];
+                    mNestedYOffset += mScrollOffset[1];
+
+                    if (canOverscroll) {
+                        deltaY -= mScrollConsumed[1];
+                        ensureGlows();
+                        final int pulledToY = oldY + deltaY;
+                        if (pulledToY < 0) {
+                            EdgeEffectCompat.onPull(mEdgeGlowTop, (float) deltaY / getHeight(),
+                                    ev.getX(activePointerIndex) / getWidth());
+                            if (!mEdgeGlowBottom.isFinished()) {
+                                mEdgeGlowBottom.onRelease();
+                            }
+                        } else if (pulledToY > range) {
+                            EdgeEffectCompat.onPull(mEdgeGlowBottom, (float) deltaY / getHeight(),
+                                    1.f - ev.getX(activePointerIndex)
+                                            / getWidth());
+                            if (!mEdgeGlowTop.isFinished()) {
+                                mEdgeGlowTop.onRelease();
+                            }
+                        }
+                        if (mEdgeGlowTop != null
+                                && (!mEdgeGlowTop.isFinished() || !mEdgeGlowBottom.isFinished())) {
+                            ViewCompat.postInvalidateOnAnimation(this);
+                        }
+                    }
+                }
+                break;
+```
+所以，NestedScrollView 在 ACTION_MOVE 事件里，主要做了两件事:在每次滑动前调用dispatchNestedPreScroll和在拖动状态下分发dispatchNestedScroll。dispatchNestedScroll会调用mChildHelper.dispatchNestedPreScroll(dx, dy, consumed, offsetInWindow, type);
+```java
+  public boolean dispatchNestedPreScroll(int dx, int dy, @Nullable int[] consumed,
+            @Nullable int[] offsetInWindow, @NestedScrollType int type) {
+        if (isNestedScrollingEnabled()) {
+            final ViewParent parent = getNestedScrollingParentForType(type);
+            if (parent == null) {
+                return false;
+            }
+
+            if (dx != 0 || dy != 0) {
+                int startX = 0;
+                int startY = 0;
+                if (offsetInWindow != null) {
+                    mView.getLocationInWindow(offsetInWindow);
+                    startX = offsetInWindow[0];
+                    startY = offsetInWindow[1];
+                }
+
+                if (consumed == null) {
+                    consumed = getTempNestedScrollConsumed();
+                }
+                consumed[0] = 0;
+                consumed[1] = 0;
+                // 回调父控件方法：onNestedPreScroll
+                ViewParentCompat.onNestedPreScroll(parent, mView, dx, dy, consumed, type);
+
+                if (offsetInWindow != null) {
+                    mView.getLocationInWindow(offsetInWindow);
+                    offsetInWindow[0] -= startX;
+                    offsetInWindow[1] -= startY;
+                }
+                // true为父控件消费了滑动距离
+                return consumed[0] != 0 || consumed[1] != 0;
+            } else if (offsetInWindow != null) {
+                offsetInWindow[0] = 0;
+                offsetInWindow[1] = 0;
+            }
+        }
+        return false;
+    }
+```
+接着在来看下dispatchNestedScroll，内部调用了ChildHelper.dispatchNestedScroll: 
+```java
+    // dispatchNestedPreScroll是让父控件优先消费滑动距离（在子 view 消费之前）；而dispatchNestedScroll是让父控件延后消费剩余滑动距离（在子 view 消费之后）。
+    public boolean dispatchNestedScroll(int dxConsumed, int dyConsumed,
+            int dxUnconsumed, int dyUnconsumed, @Nullable int[] offsetInWindow) {
+        return dispatchNestedScrollInternal(dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed,
+                offsetInWindow, TYPE_TOUCH, null);
+    }
+
+        private boolean dispatchNestedScrollInternal(int dxConsumed, int dyConsumed,
+            int dxUnconsumed, int dyUnconsumed, @Nullable int[] offsetInWindow,
+            @NestedScrollType int type, @Nullable int[] consumed) {
+        if (isNestedScrollingEnabled()) {
+            final ViewParent parent = getNestedScrollingParentForType(type);
+            if (parent == null) {
+                return false;
+            }
+            // 如果子 view 消费了滑动距离，或者是滑动距离还有剩余
+            if (dxConsumed != 0 || dyConsumed != 0 || dxUnconsumed != 0 || dyUnconsumed != 0) {
+                int startX = 0;
+                int startY = 0;
+                if (offsetInWindow != null) {
+                    mView.getLocationInWindow(offsetInWindow);
+                    startX = offsetInWindow[0];
+                    startY = offsetInWindow[1];
+                }
+
+                if (consumed == null) {
+                    consumed = getTempNestedScrollConsumed();
+                    consumed[0] = 0;
+                    consumed[1] = 0;
+                }
+                // 通知父控件滑动距离详情
+                ViewParentCompat.onNestedScroll(parent, mView,
+                        dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed, type, consumed);
+
+                if (offsetInWindow != null) {
+                    mView.getLocationInWindow(offsetInWindow);
+                    offsetInWindow[0] -= startX;
+                    offsetInWindow[1] -= startY;
+                }
+                return true;
+            } else if (offsetInWindow != null) {
+                // No motion, no dispatch. Keep offsetInWindow up to date.
+                offsetInWindow[0] = 0;
+                offsetInWindow[1] = 0;
+            }
+        }
+        return false;
+    }
+```
+
+最后再来看下 NestedScrollView 对于 ACTION_UP 和 ACTION_CANCEL 事件的处理：
+```java
+case MotionEvent.ACTION_UP:
+                final VelocityTracker velocityTracker = mVelocityTracker;
+                velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
+                int initialVelocity = (int) velocityTracker.getYVelocity(mActivePointerId);
+                if ((Math.abs(initialVelocity) > mMinimumVelocity)) {
+                    // 子view在消费fling事件前，需要先询问父控件是否消费该事件
+                    if (!dispatchNestedPreFling(0, -initialVelocity)) {
+                        // 父控件不消费，则自己消费并回调fling事件给父控件
+                        dispatchNestedFling(0, -initialVelocity, true);
+                        // 开启新一轮滑动事件
+                        fling(-initialVelocity);
+                    }
+                } else if (mScroller.springBack(getScrollX(), getScrollY(), 0, 0, 0,
+                        getScrollRange())) {
+                    ViewCompat.postInvalidateOnAnimation(this);
+                }
+                mActivePointerId = INVALID_POINTER;
+                // 回收工作以及调用stopNestedScroll通知父控件滑动结束
+                endDrag();
+                break;
+            case MotionEvent.ACTION_CANCEL:
+                if (mIsBeingDragged && getChildCount() > 0) {
+                    if (mScroller.springBack(getScrollX(), getScrollY(), 0, 0, 0,
+                            getScrollRange())) {
+                        ViewCompat.postInvalidateOnAnimation(this);
+                    }
+                }
+                mActivePointerId = INVALID_POINTER;
+                endDrag();
+                break;
+```
+而在 ACTION_UP 事件中，会先判断下当前子 view 是否还存在惯性滑动速度，如果存在，则调用dispatchNestedPreFling询问父控件是否要消费该 fling 事件，如果父控件不消费，则调用dispatchNestedFling自己消费这个事件，并将结果通知到父控件。然后还有一个关键步骤，它开启了新的一轮嵌套滑动事件，开启方法如下：
+```java
+    public void fling(int velocityY) {
+        if (getChildCount() > 0) {
+            // scroller 驱动 fling 滑动
+            mScroller.fling(getScrollX(), getScrollY(), // start
+                    0, velocityY, // velocities
+                    0, 0, // x
+                    Integer.MIN_VALUE, Integer.MAX_VALUE, // y
+                    0, 0); // overscroll
+            runAnimatedScroll(true);
+        }
+    }
+
+     private void runAnimatedScroll(boolean participateInNestedScrolling) {
+        if (participateInNestedScrolling) {
+            // 参数为NON_TOUCH通知父控件开启新一轮嵌套滑动时间
+            startNestedScroll(ViewCompat.SCROLL_AXIS_VERTICAL, ViewCompat.TYPE_NON_TOUCH);
+        } else {
+            stopNestedScroll(ViewCompat.TYPE_NON_TOUCH);
+        }
+        mLastScrollerY = getScrollY();
+        // Scroller不会真正的起到滑动功能，只是负责一个计算功能，然后调用View.invalidate让View重新绘制
+        ViewCompat.postInvalidateOnAnimation(this);
+    }
+```
+
+在Android Design Support库中非常总要的CoordinatorLayout组件就是使用了这套机制，实现了Toolbar的收起和展开功能。
+
+
+
+## 参考
+[看穿 > NestedScrolling 机制 >](https://juejin.cn/post/6844903761060577294)
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/Jetpack/ui/material/4.CoordinatorLayout\347\256\200\344\273\213.md" "b/Jetpack/ui/material/4.CoordinatorLayout\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..1f60e739
--- /dev/null
+++ "b/Jetpack/ui/material/4.CoordinatorLayout\347\256\200\344\273\213.md"
@@ -0,0 +1,154 @@
+# 4.CoordinatorLayout简介
+
+官方文档的第一句话就非常醒目：CoordinatorLayout is a super-powered FrameLayout,非常直白，CoordinatorLayout继承于ViewGroup,它就是一个超级强大Framelayout。说白了就是可以通过Behavior协调子View 。
+
+```xml
+<android.support.design.widget.CoordinatorLayout xmlns:tools="http://schemas.android.com/tools"
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:id="@+id/coordinatorLayout"
+    xmlns:app="http://schemas.android.com/apk/res-auto">
+
+    <View
+        android:id="@+id/view_girl"
+        android:layout_width="70dp"
+        android:layout_height="70dp"
+        android:layout_marginLeft="200dp"
+        android:background="@mipmap/make_music_voice_changer_female" />
+
+    <View
+        android:id="@+id/view_uncle"
+        android:layout_width="100dp"
+        android:layout_height="100dp"
+        android:background="@mipmap/make_music_voice_changer_uncle"
+        app:layout_behavior="com.example.md.mdview.RunBehavior"/>
+</android.support.design.widget.CoordinatorLayout>
+```
+
+布局中有两个子view，操作viewgirl，viewuncle也会相应跟着走，这就要写一个联动关系，用自定义Behavior实现:  
+
+```java
+public class RunBehavior extends CoordinatorLayout.Behavior<View>{
+
+    public RunBehavior(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    @Override
+    public boolean onDependentViewChanged(CoordinatorLayout parent, View child, View dependency) {
+        int top = dependency.getTop();
+        int left = dependency.getLeft();
+
+        ViewGroup.MarginLayoutParams params = (ViewGroup.MarginLayoutParams) child.getLayoutParams();
+        params.topMargin = top - 400;
+        params.leftMargin = left;
+        child.setLayoutParams(params);
+        return true;
+    }
+
+    @Override
+    public boolean layoutDependsOn(CoordinatorLayout parent, View child, View dependency) {
+        return true;
+    }
+}
+```
+
+CoordinatorLayout的使用核心是Behavior，Behavior就是执行你定制的动作。
+
+在讲Behavior之前必须先理解两个概念：Child和Dependency，什么意思呢？Child当然是子View的意思了，是谁的子View呢，当然是CoordinatorLayout的子View；其实Child是指要执行动作的CoordinatorLayout的子View。而Dependency是指Child依赖的View。简而言之，就是如果Dependency这个View发生了变化，那么Child这个View就要相应发生变化。发生变化是具体发生什么变化呢？这里就要引入Behavior，Child发生变化的具体执行的代码都是放在Behavior这个类里面。
+
+Behavior里面主要有两个方法: 
+- public boolean layoutDependsOn(CoordinatorLayout parent, View child, View dependency)
+
+    判断child的布局是否依赖dependency，根据条件过滤判断返回值，返回true联动。如果返回flase不联动，即behavior不生效
+
+- public boolean onDependentViewChanged(CoordinatorLayout parent, View child, View dependency)
+
+    当dependency发生改变时(位置、高度等)，执行这个函数，返回true表示child的位置或者宽要发生变化，否则返回false
+
+最后，别忘了在XML中通过layout_behavior来指定具体的行为: 
+
+```bash
+app:layout_behavior="com.example.md.mdview.RunBehavior"
+```
+
+
+
+### 基于CoordinatorLayout联动的两点规律
+ 1、父布局肯定是CoordinatorLayout
+ 2、一定会设置`app:layout_scrollFlags`和`app:layout_behavior`两个属性。
+
+有同学可能会想一定要是 NestedScrollView 吗？ 
+
+当然不是，在 CoordinatorLayout 中嵌套滑动的本质是一个 NestedScrollingChild 对象。 
+
+NestedScrollingChild 是一个接口，目前它的实现类有 4 个，分别是SwipeRefreshLayout、RecyclerView、NestedScrollView、NestedScrollView。
+
+ **滑动的View：**滑动的view官方建议使用NestedScrollView或者RecyclerView。ListView在5.0以下就没有效果了。
+ **高阶的使用：**高阶使用当然是自定义behavior了。
+
+
+
+#### CoordinatorLayout与FloadingActionButton
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout     
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/contentView"
+    android:orientation="vertical"     
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
+    <android.support.design.widget.FloatingActionButton
+        android:id="@+id/fab"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_alignParentBottom="true"
+        android:layout_alignParentRight="true"
+        android:onClick="onClick"
+        android:layout_marginRight="10dp"
+        android:layout_marginBottom="10dp"/>
+</RelativeLayout>
+```
+
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/smacker_floatingbutton.webp?raw=true)        
+
+可以看到FloatingActionButton会被SmackBar遮挡，为了解决遮挡的问题，就需要使用到CoordinatorLayout。
+CoordinatorLayout可以监听其所有子控件的各种事件，然后自动帮助我们做出最为合理的响应。如果我们能让CoordinatorLayout监听到Snackbar的弹出事件，那么它会自动将内部的FloatingActionButton向上偏移，从而确保不会被Snackbar遮挡到。
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<android.support.design.widget.CoordinatorLayout 
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:id="@+id/contentView"
+    android:orientation="vertical" 
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
+    <LinearLayout
+        android:id="@+id/anchorView"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:orientation="vertical"/>
+    <android.support.design.widget.FloatingActionButton
+        android:id="@+id/fab"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        app:layout_anchor="@id/anchorView"
+        app:layout_anchorGravity="bottom|right"
+        android:onClick="onClick"
+        android:layout_marginRight="10dp"
+        android:layout_marginBottom="10dp"/>
+</android.support.design.widget.CoordinatorLayout>
+```
+
+这样之后，悬浮按钮会在弹出Snakebar的时候自动向上偏移了Snackbar的同等高度，从而确保不会被遮挡住，当Snackbar消失的时候，悬浮按钮会自动向下偏移回到原来位置。
+另外悬浮按钮的向上和向下偏移也是伴随着动画效果的，且和Snackbar完全同步，整体效果看上去特别赏心悦目。
+
+或者我们也可以不把FloatingActionButton放到布局中，只是make()方法时传入的view是在布局中即可，我们回过头来再思考一下，刚才说的是CoordinatorLayout可以监听其所有子控件的各种事件，但是Snackbar好像并不是CoordinatorLayout的子控件吧，为什么它却可以被监听到呢？
+
+其实道理很简单，我们在Snackbar的make()方法中传入的参数就是用来指定Snackbar是基于哪个View来触发的，如果我们传入的是FloatingActionButton本身，而FloatingActionButton是CoordinatorLayout中的子控件，因此这个事件就理所应当能被监听到了。
+
diff --git "a/Jetpack/ui/material/5.AppBarLayout\347\256\200\344\273\213.md" "b/Jetpack/ui/material/5.AppBarLayout\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..7611f0b1
--- /dev/null
+++ "b/Jetpack/ui/material/5.AppBarLayout\347\256\200\344\273\213.md"
@@ -0,0 +1,94 @@
+# 5.AppBarLayout简介
+
+AppbarLayout是Material Design的一个控件。它继承自LinearLayout，布局方向为垂直方向。所以你可以把它当成垂直布局的LinearLayout来使用。AppBarLayout是在LinearLayou上加了一些材料设计的概念，它可以让你定制当某个可滚动View的滚动手势发生变化时，其内部的子View实现何种动作。
+
+**请注意**：上面提到的某个可滚动View，可以理解为某个ScrollView。怎么理解上面的话呢？就是说，当某个ScrollView发生滚动时，你可以定制你的“顶部栏”应该执行哪些动作（如跟着一起滚动、保持不动等等）。那某个可移动的View到底是哪个可移动的View呢？这是由你自己指定的！如何指定，我们后面说。
+
+```xml
+<com.google.android.material.appbar.AppBarLayout
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content">
+
+    <com.google.android.material.appbar.MaterialToolbar
+        android:id="@+id/tb_main"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:background="@color/design_default_color_primary_dark" />
+</com.google.android.material.appbar.AppBarLayout>
+```
+
+
+内部的子View通过在布局中加app:layout_scrollFlags设置执行的动作，那么app:layout_scrollFlags可以设置哪些动作呢？分别如下:  
+| Scroll Flag          |                             作用                             |
+| -------------------- | :----------------------------------------------------------: |
+| scroll               | 子View如果设置layout_scrollFlags属性的值为scroll，这个View会随着Scrolling View一起滚动，当向上滚动的时候，Toolbar会滚出屏幕外，如果不设置，那么Toolbar会固定不动。 |
+| enterAlways          | 使用这个flag，当Scrolling View 向下滑动时，子View  将直接向下滑动，而不管Scrolling View 是否在滑动。注意：要与scroll  搭配使用，否则是不能滑动的。(上图演示的效果，正是scroll和enterAlways两个flag同时使用产生的效果，即向上滚动,Toolbar滚出屏幕，向下滚动，Toolbar重新进入屏幕)。 |
+| enterAlwaysCollapsed | enterAlwaysCollapsed 是对enterAlways  的补充，当Scrolling View 向下滑动的时候，滑动View（也就是设置了enterAlwaysCollapsed  的View）下滑至折叠的高度，当Scrolling View  到达滑动范围的结束值的时候，滑动View剩下的部分开始滑动。这个折叠的高度是通过View的minimum height  （最小高度）指定的。（要配合scroll｜enterAlways 一起使用） |
+| exitUntilCollapsed   | 当Scrolling View 滑出屏幕时（也就时向上滑动时），滑动View先响应滑动事件，滑动至折叠高度，也就是通过minimum height 设置的最小高度后，就固定不动了，再把滑动事件交给 Scrolling view 继续滑动。 |
+| snap                 | 在滚动结束后，如果view只是部分可见，它将滑动到最近的边界。比如，如果view的底部只有25%可见，它将滚动离开屏幕，而如果底部有75%可见，它将滚动到完全显示。 |
+
+
+
+AppBarLayout本身想提供一个AppBar的概念，所以严格地讲它本身与Toolbar没有直接的关系。AppBarLayout内部的子View不一定非要是Toolbar,它可以是任何View，比如，你可以放置进去一张图片、一个列表、一个ViewPager等等。我们知道，Android的历史中，大概有TitleBar、ActionBar、Toolbar的进化，这是Android设计语言的改良过程。而后来随着Material Design设计的出现,它又提供了AppBar的概念，而AppBarLayout则是AppBar在Android中的代码实现。  
+AppBarLayout虽然和Toolbar没有直接联系，但是当Toolbar内置在AppbarLayout中的时候，Toolbar的效果增强了，这使得开发者非常愿意用AppBarLayout与Toolbar配合使用，这比单独使用Toolbar炫丽的多。所以，基本上有AppBarLayout的地方就有Toolbar。
+
+
+
+## CoordinatorLayout&AppbarLayout
+
+当我们运用support design中的组件时，我们应该拥有下面几个最基本的意识:   
+
+1. CoordinatorLayout是这个库的组织容器，一切基于support design扩展出来的特性都应该发生在CoordinatorLayout及它的子View体系中。它的一切效果都建立在CoordinatorLayout这个父类容器之上，AppBarLayout要想正常发挥它的所有特性，那么它必须作为CoordinatorLayout的直接子类，否则它与普通的LinearLayout无异。
+2. 为了让AppBarLayout能够知道何时滚动其子View，我们还应该在CoordinatorLayout布局中提供一个可滚动View，我们称之为Scrolling View。Scrolling View和AppBarLayout之间的关联，通过将 Scrolling View的Behavior设为AppBarLayout.ScrollingViewBehavior来建立。  
+    AppBarLayout本身有默认的Behavior,这使得它能够响应依赖对象的位置变化或者是CoordinatorLayout中产生的嵌套滑动事件，这从它的源码中可以看出来：
+
+```java
+public class AppBarLayout extends LinearLayout implements CoordinatorLayout.AttachedBehavior {
+```
+
+AppBarLayout对象实现了一个Behavior。而正是这个Behavior，它会响应外部的嵌套滑动事件，然后根据特定的规则去伸缩和滑动内部的子View。
+
+
+
+下面分别加入AppbarLayout和NestedScrollView作子view，给NestedScrollView加上behavior,就可以让AppbarLayout跟随NestedScrollView的Behavior联动。Android已经自带了app:layout_behavior="@string/appbar_scrolling_view_behavior"，只要滚动发生，就会给自己的子view（if
+ instance of Appbarlayout）添加滚动事件。
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/coordinator_appbar_collapsing.webp?raw=true)
+
+
+```xml
+<android.support.design.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:fitsSystemWindows="true">
+
+    <android.support.design.widget.AppBarLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:theme="@style/ThemeOverlay.AppCompat.Dark.ActionBar">
+        <android.support.v7.widget.Toolbar
+            android:id="@+id/toolbar"
+            android:layout_width="match_parent"
+            android:layout_height="?android:attr/actionBarSize"
+            android:background="@color/colorPrimary"
+            app:layout_scrollFlags="scroll|enterAlways"
+            app:popupTheme="@style/ThemeOverlay.AppCompat.Light"
+            app:theme="@style/ThemeOverlay.AppCompat.ActionBar" />
+
+    </android.support.design.widget.AppBarLayout>
+    <android.support.v4.widget.NestedScrollView
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        app:layout_behavior="@string/appbar_scrolling_view_behavior">
+    </android.support.v4.widget.NestedScrollView>
+
+</android.support.design.widget.CoordinatorLayout>
+```
+
+这里同样需要设置这两个属性：
+ `app:layout_scrollFlags="scroll|enterAlways"`
+ `app:layout_behavior="@string/appbar_scrolling_view_behavior"`
+
diff --git "a/Jetpack/ui/material/6.CollapsingToolbarLayout\347\256\200\344\273\213.md" "b/Jetpack/ui/material/6.CollapsingToolbarLayout\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..f6d418e6
--- /dev/null
+++ "b/Jetpack/ui/material/6.CollapsingToolbarLayout\347\256\200\344\273\213.md"
@@ -0,0 +1,234 @@
+# 6.CollapsingToolbarLayout
+
+```java
+public class CollapsingToolbarLayout
+extends FrameLayout
+java.lang.Object
+   ↳ 	android.view.View
+  	   ↳ 	android.view.ViewGroup
+  	  	   ↳ 	android.widget.FrameLayout
+  	  	  	   ↳ 	com.google.android.material.appbar.CollapsingToolbarLayout 
+```
+
+CollapsingToolbarLayout is a wrapper for Toolbar which implements a  collapsing app bar. It is designed to be used as a direct child of a  AppBarLayout.
+
+可折叠式标题栏，CollapsingToolbarLayout是一个作用于Toolbar基础之上的布局，它也是由Design Support库提供的。CollapsingToolbarLayout可以让Toolbar的效果变得更加丰富，不仅仅是展示一个标题栏，而是能够实现非常华丽的效果。它继承自FrameLayout，通常用来在布局中包裹一个Toolbar，以实现一个可以折叠的Toolbar。它需要是AppBarLayout的直接子View，这样才能发挥出效果。
+
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/CollapsingToolbarLayout.gif?raw=true)        
+
+可以看到有这样几个效果：
+
+1、背景图片渐渐消失变为主题颜色 
+ 2、FloatingActionButton在滑到顶部的时候消失了 
+ 3、左上角的箭头保持不动 
+ 4、title在滑到顶部的时候自动调整位置和大小
+
+这个高级版的标题栏将是由普通的标题栏加上图片组合而成的。
+
+CollapsingToolbarLayout包含以下特性：
+
+- Collasping title（可折叠标题）
+
+    当布局完全可见时，这个标题比较大；当折叠起来时，标题也会变小。标题的外观可以通过expandedTextAppearance和collapsedTextAppearance属性来调整。
+
+- contentScrim
+
+    设置当CollapsingToolbarLayout完全折叠后的背景颜色，即Toolbar的颜色
+
+- expandedTitleMarginStart
+
+    设置扩张时title与左边的距离
+
+- Status bar scrim（状态栏纱布）
+
+    也是根据是否滚动到临界点，来决定是否显示。可以通过setStatusBarScrim(Drawable)方法来设置。这个特性只有在Android 5.0及其以上版本，我们设置fitSystemWindows为ture时才能生效。
+
+- Parallax scrolling children（视差滚动子 View）
+
+    子View可以选择以“视差”的方式来进行滚动。（视觉效果上就是子 View 滚动的比其他 View 稍微慢些）
+
+- Pinned position children
+
+    子View可以选择固定在某一位置上。
+
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.coordinatorlayout.widget.CoordinatorLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:fitsSystemWindows="true"
+    tools:context=".activity.PersonInfoActivity">
+
+    <com.google.android.material.appbar.AppBarLayout
+        android:id="@+id/app_bar"
+        android:layout_width="match_parent"
+        android:layout_height="@dimen/app_bar_height"
+        android:fitsSystemWindows="true"
+        android:theme="@style/Theme.JetpackSample.AppBarOverlay">
+
+        <com.google.android.material.appbar.CollapsingToolbarLayout
+            android:layout_width="match_parent"
+            android:layout_height="match_parent"
+            app:contentScrim="?attr/colorPrimary"
+            android:id="@+id/toolbar_layout"
+            android:fitsSystemWindows="true"
+            app:layout_scrollFlags="scroll|exitUntilCollapsed|snap"
+            app:statusBarScrim="@android:color/transparent">
+            <ImageView
+                android:layout_width="match_parent"
+                android:layout_height="match_parent"
+                android:fitsSystemWindows="true"
+                android:scaleType="centerCrop"
+                android:src="@mipmap/ic_launcher"
+                app:layout_collapseMode="parallax"
+                app:layout_collapseParallaxMultiplier="0.6"/>
+            <androidx.appcompat.widget.Toolbar
+                android:id="@+id/toolbar"
+                android:layout_width="match_parent"
+                android:layout_height="?attr/actionBarSize"
+                app:layout_collapseMode="pin"
+                app:popupTheme="@style/Theme.JetpackSample.PopupOverlay"
+                app:title=""/>
+        </com.google.android.material.appbar.CollapsingToolbarLayout>
+    </com.google.android.material.appbar.AppBarLayout>
+
+    <androidx.core.widget.NestedScrollView
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        app:layout_behavior="@string/appbar_scrolling_view_behavior">
+
+        <TextView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_margin="@dimen/text_margin"
+            android:text="@string/large_text" />
+
+    </androidx.core.widget.NestedScrollView>
+
+    <com.google.android.material.floatingactionbutton.FloatingActionButton
+        android:id="@+id/fab"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_marginEnd="@dimen/fab_margin"
+        app:layout_anchor="@id/app_bar"
+        app:layout_anchorGravity="bottom|end"
+        app:srcCompat="@android:drawable/ic_dialog_email" />
+
+</androidx.coordinatorlayout.widget.CoordinatorLayout>
+```
+
+我们在 XML 文件中为 CollapsingToolBarLayout 的 layout_scrollFlags 指定为 scroll|exitUntilCollapsed|snap，这样便实现了向上滚动的折叠效果。
+
+app:layout_scrollFlags属性：
+
+1. scroll:将此布局和滚动时间关联。这个标识要设置在其他标识之前，没有这个标识则布局不会滚动且其他标识设置无效。
+2. enterAlways:任何向下滚动操作都会使此布局可见。这个标识通常被称为“快速返回”模式。
+3. enterAlwaysCollapsed：假设你定义了一个最小高度（minHeight）同时enterAlways也定义了，那么view将在到达这个最小高度的时候开始显示，并且从这个时候开始慢慢展开，当滚动到顶部的时候展开完。
+4. exitUntilCollapsed：当你定义了一个minHeight，此布局将在滚动到达这个最小高度的时候折叠。
+5. snap:当一个滚动事件结束，如果视图是部分可见的，那么它将被滚动到收缩或展开。例如，如果视图只有底部25%显示，它将折叠。相反，如果它的底部75%可见，那么它将完全展开。
+
+
+
+CollapsingToolbarLayout 本质上同样是一个 FrameLayout。这里定义的大多数属性我们都是见过的，就不再解释了，只有一个app:layout_collapseMode比较陌生。它用于指定当前控件在CollapsingToolbarLayout折叠过程中的折叠模式，其中Toolbar指定成pin，表示在折叠的过程中位置始终保持不变，ImageView指定成parallax，表示会在折叠的过程中产生一定的错位偏移，这种模式的视觉效果会非常好。
+
+上面ImageView设置了app:layout_collapseMode="parallax"，该属性是控制滚出屏幕范围的效果的，具体取值如下:  
+
+- pin
+
+    确保Toolbar在View折叠的时候仍然被固定在屏幕的顶部。
+
+- parallax
+
+    在内容滚动时，CollapsingToolbarLayout中的View(例如上面的ImageView)也可以同时滚动，实现视差滚动效果，通常和layout_collapseParallaxMultiplier(设置视差因子，值为0~1)搭配使用。layout_collapseParallaxMultiplier设置的值越大可以让滚动的效果更加明显。
+
+#### FloatingActionButton的设置
+
+在FloatingActionButton中主要设置了两个属性: 
+
+- app:layout_anchor
+    设置这个属性可以让FloatingActionButton以某一个控件为基准调整位置，我们这里设置这个控件就是appbar
+
+- app:layout_anchorGravity
+    设置基于appbar控件的位置，我们这里设置了end|bottom|right
+
+FloatingActionButton这个控件通过app:layout_anchor这个设置锚定在了AppBarLayout下方。FloatingActionButton源码中有一个Behavior方法，当AppBarLayout收缩时，FloatingActionButton就会跟着做出相应变化。
+
+### fitsSystemWindows 介绍
+
+上面用到了设置fitsSystemWindows属性，这里简单介绍一下。
+
+根据官方文档，如果某个View 的fitsSystemWindows 设为true，那么该View的padding属性将由系统设置，用户在布局文件中设置的
+ padding会被忽略。系统会为该View设置一个paddingTop，值为statusbar的高度。fitsSystemWindows默认为false。
+
+重要说明：
+
+1. 只有将statusbar设为透明，或者界面设为全屏显示（设置View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN flag)时，fitsSystemWindows才会起作用。不然statusbar的空间轮不到用户处理，这时会由ContentView的父控件处理，如果用HierarchyView 工具查看，将会看到，ContentView的父控件的paddingTop将会被设置。
+2. 如果多个view同时设置了fitsSystemWindows，只有第一个会起作用。这是一般情况，后面会介绍特殊情况。
+
+### fitsSystemWindows属性的个性化
+
+第一次接触fitsSystemWindows是在CoordinatorLayout控件。发现有很多诡异的地方。
+
+1. fitsSystemWindows的表现和官方文档描述的不一样。
+2. 有时CoordinatorLayout的子控件也会设置fitsSystemWindows属性，而且子控件的fitsSystemWindows也会有作用。
+
+这些令我很困惑，查了些资料之后找到了原因：设置paddingTop只是fitsSystemWindows属性的默认行为，View可以对fitsSystemWindows
+ 进行个性化。fuccccccccccccccck!!!!!!!!!
+
+CoordinatorLayout对fitsSystemWindows的个性化。API 21 以上可以通过调用View的setOnApplyWindowInsetsListener(OnApplyWindowInsetsListener)函数，改变fitsSystemWindows的默认行为。在OnApplyWindowInsetsListener的onApplyWindowInsets函数，可以决定如何处理statusbar的空间。
+ 重要说明：
+
+1. 在API 21以前，好像也可以重写View的某个函数达到类似效果。
+2. 必须将statusbar设为透明，或者界面设为全屏显示setOnApplyWindowInsetsListener才会起作用。这点很容易理解，你都没有statusbar空间，你个性化个屁啊。
+
+CoordinatorLayout对fitsSystemWindows的个性化，关键代码：
+
+```java
+if (ViewCompat.getFitsSystemWindows(view)) {
+            // First apply the insets listener
+            ViewCompat.setOnApplyWindowInsetsListener(view, insetsListener);
+            // Now set the sys ui flags to enable us to lay out in the window insets
+            view.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_STABLE
+                    | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN);
+        }   
+        
+final class ApplyInsetsListener implements android.support.v4.view.OnApplyWindowInsetsListener {
+        @Override
+        public WindowInsetsCompat onApplyWindowInsets(View v, WindowInsetsCompat insets) {
+            setWindowInsets(insets);
+            return insets.consumeSystemWindowInsets();
+        }
+    }
+```
+
+
+
+总结：CoordinatorLayout对fitsSystemWindows主要做了以下处理。
+
+1. 将界面设为全屏。view.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_STABLE| View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN);
+2. 自己绘制statusbar背景。setStatusBarBackground函数可以设置statusbar背景。或者在布局文件中通过app:statusBarBackground设置。
+3. 如果CoordinatorLayout的子View没有设置fitsSystemWindows，在layout时将子Viwe向下偏移statusbar的高度，用来显示CoordinatorLayout绘制的statusbar。如果子view设置了fitsSystemWindows，子View会覆盖CoordinatorLayout的statusbar。setStatusBarBackground设置的状态栏
+     将被覆盖，不再起作用。具体逻辑可参考CoordinatorLayout的layoutChild 函数。
+4. 调用dispatchApplyWindowInsets，让子view的behavior或子view接着处理fitsSystemWindows属性。CoordinatorLayout的很多常用的子view如AppBarLayout也对fitsSystemWindows进行了个性化处理。
+
+
+
+Android 4.1 开始，可以将 app 的内容绘制在状态栏的下一层 (behind the status bar)，并且 app 的内容区域的大小不会随着状态栏的出现和消失而自动。使用 [SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN](https://developer.android.com/reference/android/view/View.html#SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN) 即可实现这种效果。
+将 app 的内容绘制在状态栏的下一层时，app 自己负责保证 UI 中的重要内容不被状态栏遮挡(例如，地图应用中的控件不应被状态档遮挡)。否则可能导致应用不可用。大部分时候通过在 XML 文件中添加 `android:fitsSystemWindows=true` 可以解决这个被遮挡导致不可用的问题。这个属性用于告知父节点要为 system windows 保留一些 padding。通过截图说明一下使用 `fitsSystemWindows=true` 和使用 `fitsSystemWindows=false` 的区别。
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/fitssystemwindow.png?raw=true)
+
+
+
+Material 包中的很多类，比如 `DrawerLayout`、`CoordinatorLayout`及`AppBarLayout`等等，并不是仅仅将 `fitsSystemWindows` 用于控制是否让父节点要为 system windows 保留一些 padding，还用来控制是否修改状态栏背景！
+
+记住这几点：
+
+- `fitsSystemWindows` 是深度优先的。顺序很重要，it’s the first View that consumes the insets that makes a difference
+- Insets are always relative to the full window - 布局前就添加了 inset，所以在为父节点添加 padding 时其实并不知道 view 的位置
+- padding 会被 `fitsSystemWindows=true` 覆盖 - 同一个 view 上使用 `fitsSystemWindows=true` 后 padding 相关的属性无效
\ No newline at end of file
diff --git "a/Jetpack/ui/material/7.Snackbar\347\256\200\344\273\213.md" "b/Jetpack/ui/material/7.Snackbar\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..bf6e3956
--- /dev/null
+++ "b/Jetpack/ui/material/7.Snackbar\347\256\200\344\273\213.md"
@@ -0,0 +1,36 @@
+# 7.Snackbar简介
+
+Snackbar显示在所有屏幕其它元素之上(屏幕最顶层)，同一时间只能显示一个snackbar。Snackbar的基本使用很简单，与Toast类似。
+
+```java
+Snackbar.make(view, message_text, duration)
+   .setAction(action_text, click_listener)
+   .show();
+```
+
+make()方法是生成Snackbar的。Snackbar需要一个控件容器view用来容纳，官方推荐使用CoordinatorLayout来确保Snackbar和其他组件的交互，比如滑动取消Snackbar、Snackbar出现时FloatingActionButton上移。显示时间duration有三种类型LENGTH_SHORT、LENGTH_LONG和LENGTH_INDEFINITE。
+
+setAction()方法可设置Snackbar右侧按钮，增加进行交互事件。如果不使用setAction()则只显示左侧message。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/Jetpack/ui/material/8.TabLayout\347\256\200\344\273\213.md" "b/Jetpack/ui/material/8.TabLayout\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..eca3c700
--- /dev/null
+++ "b/Jetpack/ui/material/8.TabLayout\347\256\200\344\273\213.md"
@@ -0,0 +1,39 @@
+```
+public class TabLayout extends HorizontalScrollView {
+```
+
+所有的 Tab 选项卡实例化都是通过 TabLayout.Tab 完成的。你可以通过 TabLayout.newTab()来创建 Tab 对象。你可以通过更改Tab 的setText()、setIcon()分别设置选项卡的文字和 Icon。要显示选项卡 Tab,你必须通过一个方法 addTab(tab)方法将其添加到布局。例如：
+
+如果你的 ViewPager 和这个布局用在一起，你可以调用 setupWithVIewPager(ViewPager)两个链接在一起，这种布局将会自动填充 PagerAdapter 的页面标题
+
+你也可以把这种用法当成 ViewPager 的装饰，并且可以这样写布局资源直接添加到 ViewPager 当中：
+
+```xml
+<android.support.v4.view.ViewPager
+ android:layout_width="match_parent"
+ android:layout_height="match_parent">
+
+  <android.support.design.widget.TabLayout
+      android:layout_width="match_parent"
+      android:layout_height="wrap_content"
+      android:layout_gravity="top" />
+
+</android.support.v4.view.ViewPager>
+```
+
+
+
+- app:tabSelectedTextColor：选中字体的颜色
+- app:tabTextColor：未选中字体的颜色
+- app:tabIndicatorColor：指示器下标的颜色
+- app:tabIndicatorHeight：指示器下标的高度
+- app:tabGravity：tab中布局位置，有两种模式center和fill
+- app:tabTextAppearance：字体大小
+- app:tabBackground：设置背景
+- app:tabMode：设置tablayout的排列模式，有两种scrollable和fixed；默认是fixed。fixed是固定的，适用于标签较少，scrollable是可滚动的，适用于标签较多的情况下
+    
+
+作者：Anonymous___
+链接：https://www.jianshu.com/p/fece7cdf53a5
+来源：简书
+著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
\ No newline at end of file
diff --git "a/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md" "b/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
index 17884439..975e2b90 100644
--- "a/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
+++ "b/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
@@ -529,43 +529,74 @@ public static Instance getInstance() {
 
 具体可以看: [Kotlin Object Declarations Are Initialized in Static Block](https://hanru-yeh.medium.com/kotlin-object-declarations-are-initialized-in-static-block-5e1c2e1c3401)
 
-
 ### 委托(代理)
 
+委托，也就是委托模式，它是23中经典设计模式中的一种，又名代理模式，在委托模式中，有2个对象参与同一个请求的处理，接受请求的对象将请求委托给另一个对象来处理。
+
+委托模式中，有三个角色： 
+
+- 约束
+
+    约束是接口或抽象类，它定义了通用的业务类型，也就是需要被代理的业务
+
+- 委托对象
+
+    将约束定义的业务委托给别人
+
+- 被委托对象
+
+    具体的业务逻辑执行者
+
 ##### 类委托
 
-委托模式是最常用的设计模式的一种，在委托模式中，有两个对象参与处理同一个请求，接受请求的对象将请求委托给另一个对象来处理。
+在委托模式中，有两个对象参与处理同一个请求，接受请求的对象将请求委托给另一个对象来处理。
 `kotlin`中的委托可以算是对委托模式的官方支持。    
 `Kotlin`直接支持委托模式，更加优雅，简洁。`Kotlin`通过关键字`by`实现委托。
 
-```kotlin
-interface Base{
-    fun print()
-}
+我们经常会打游戏进行升级，但是有时候因为我们的水平不行，没法升到很高的级别，这就出现了很多的游戏代练，他们帮我们代打，这就是一个委托模式： 
+
+1. 定义约束类，定义具体需要委托的业务，这里的业务: 
 
-class BaseImpl(val x : Int) : Base{
-    override fun print() {
-        Log.d(JTAG, "BaseImpl -> ${x.string()}")
+    ```kotlin
+    interface IGamePlayer {
+        fun upgrade()
     }
-}
+    ```
 
-class Printer(b : Base) : Base by b
+2. 定义被委托对象，也就是游戏代练: 
 
-fun test(){
-    val b = BaseImpl(5)
-    Printer(b).print()
-}
+    ```kotlin
+    class RealGamePlayer(private val name: String): IGamePlayer {
+        override fun upgrade() {
+            println("$name up up up")
+        }
+    }
+    ```
 
-// 输出
-BaseImpl -> 5
-```
+3. 定义委托对象
 
-可以看到`Printer`类没有实现接口`Base`的方法`print()`，而是通过关键字`by`将实现委托给了`b`，而输出也和预想的一样。
+    ```kotlin
+    // 注意这里不用再去实现IGamePlayer接口的upgrade方法，而是通过关键字by将实现委托给了player
+    class DelegateGamePlayer(private val player: IGamePlayer): IGamePlayer by player
+    ```
 
+    定义了一个委托类DelegateGamePlayer, 现在游戏代练有很多，水平有高有低，如果发现水平不行，我们可以随时换，因此，我们把被委托对象作为委托对象的属性，通过构造方法传进去。
 
+    ```kotlin
+    fun main() {
+        val realGamePlayer = RealGamePlayer("real 1")
+        val delegateGamePlayer = DelegateGamePlayer(realGamePlayer)
+        delegateGamePlayer.upgrade()
+    }
+    // real 1 up up up
+    ```
+
+    
 
 ##### 属性委托
 
+在Kotlin中，有一些常见的属性类型，虽然我们可以在每次需要的时候手动实现他们，但是很麻烦，为了解决这些问题，Kotlin标准提供了委托属性。
+
 语法是`val/var <属性名>: <类型> by <表达式>`。在`by`后面的表达式是该委托，因为属性对应的`get()`和`set()`会被委托给它的`getValue()`
 和`setValue()`方法。 属性的委托不必实现任何的接口，但是需要提供一个`getValue()`函数（和`setValue()`——对于`var`属性）。
 
@@ -576,7 +607,7 @@ class Example {
 
 class DelegateProperty {
     var temp = "old"
-
+	// getValue和setValue方法的参数是固定的
     operator fun getValue(ref: Any?, p: KProperty<*>): String {
         return "DelegateProperty --> ${p.name} --> $temp"
     }
@@ -605,6 +636,103 @@ DelegateProperty --> property --> new
 - `getValue`方法的返回类型必须是与委托属性相同或是其子类
 - `getValue`方法和`setValue`方法必须要用关键字`operator`标记
 
+在上面类委托的示例中，有一个约束，里面定义了代理的业务逻辑。而委托属性呢？ 其实就是上面的简化，被代理的逻辑就是这个属性的get/set方法。get/set会委托给被委托对象的getValue/setValue方法，因此被委托类需要提供getValue/setValue这两个方法。如果是val属性，只需提供getValue。如果是var属性，则getValue/setValue都需要提供。
+
+属性委托，必须要提供getValue/setValue方法，但是这里有一个问题，就是这么复杂的参数，还要每次手写，太麻烦了。为了解决这个问题，Kotlin标准库中声明了2个包含所需operator方法的ReadOnlyProperty/ReadWriteProperty接口。 
+
+```kotlin
+
+/**
+ * Base interface that can be used for implementing property delegates of read-only properties.
+ *
+ * This is provided only for convenience; you don't have to extend this interface
+ * as long as your property delegate has methods with the same signatures.
+ *
+ * @param T the type of object which owns the delegated property.
+ * @param V the type of the property value.
+ */
+public fun interface ReadOnlyProperty<in T, out V> {
+    /**
+     * Returns the value of the property for the given object.
+     * @param thisRef the object for which the value is requested.
+     * @param property the metadata for the property.
+     * @return the property value.
+     */
+    public operator fun getValue(thisRef: T, property: KProperty<*>): V
+}
+
+/**
+ * Base interface that can be used for implementing property delegates of read-write properties.
+ *
+ * This is provided only for convenience; you don't have to extend this interface
+ * as long as your property delegate has methods with the same signatures.
+ *
+ * @param T the type of object which owns the delegated property.
+ * @param V the type of the property value.
+ */
+public interface ReadWriteProperty<in T, V> : ReadOnlyProperty<T, V> {
+    /**
+     * Returns the value of the property for the given object.
+     * @param thisRef the object for which the value is requested.
+     * @param property the metadata for the property.
+     * @return the property value.
+     */
+    public override operator fun getValue(thisRef: T, property: KProperty<*>): V
+
+    /**
+     * Sets the value of the property for the given object.
+     * @param thisRef the object for which the value is requested.
+     * @param property the metadata for the property.
+     * @param value the value to set.
+     */
+    public operator fun setValue(thisRef: T, property: KProperty<*>, value: V)
+}
+```
+
+被委托类实现这两个接口其中之一就可以了，val属性实现ReadOnlyProperty，var属性实现ReadOnlyProperty。
+
+```kotlin
+import kotlin.properties.ReadOnlyProperty
+import kotlin.reflect.KProperty
+import kotlin.properties.ReadWriteProperty
+
+// val 属性委托实现
+class Delegate1: ReadOnlyProperty<Any,String>{
+    public override operator fun getValue(thisRef: Any, property: KProperty<*>): String {
+        return "通过实现ReadOnlyProperty实现，name:${property.name}"
+    }
+}
+// var 属性委托实现
+class Delegate2: ReadWriteProperty<Any,Int>{
+    override operator fun getValue(thisRef: Any, property: KProperty<*>): Int {
+        return  20
+    }
+
+    override operator fun setValue(thisRef: Any, property: KProperty<*>, value: Int) {
+       println("委托属性为： ${property.name} 委托值为： $value")
+    }
+
+}
+
+class Test {
+    val d1: String by Delegate1()
+    var d2: Int by Delegate2()
+}
+
+fun main() {
+   val test = Test()
+    println(test.d1)
+    println(test.d2)
+    test.d2 = 100
+    
+    // 通过实现ReadOnlyProperty实现，name:d1
+    // 20
+    // 委托属性为： d2 委托值为： 100
+}
+```
+
+
+
 
 `Kotlin`通过属性委托的方式，为我们实现了一些常用的功能，包括:   
 
@@ -612,7 +740,7 @@ DelegateProperty --> property --> new
 - 可观察属性`observable properties`
 - `map`映射
 
-##### 延迟属性    
+##### 延迟属性
 
 延迟属性我们应该不陌生，也就是通常说的懒汉，在定义的时候不进行初始化，把初始化的工作延迟到第一次调用的时候。`kotlin`中实现延迟属性很简单，
 来看一下。
@@ -651,12 +779,36 @@ void test(){
 }
 ```
 
+`lazy`延迟初始化是可以接受参数的，提供了如下三个参数: 
+
+- `LazyThreadSafetyMode.SYNCHRONIZED`: 添加同步锁，使`lazy`延迟初始化线程安全
+- `LazyThreadSafetyMode. PUBLICATION`： 初始化的`lambda`表达式可以在同一时间被多次调用，但是只有第一个返回的值作为初始化的值。
+- `LazyThreadSafetyMode. NONE`：没有同步锁，多线程访问时候，初始化的值是未知的，非线程安全，一般情况下，不推荐使用这种方式，除非你能保证初始化和属性始终在同一个线程
+
+如果你指定的参数为`LazyThreadSafetyMode.SYNCHRONIZED`,则可以省略，因为`lazy`默认就是使用的`LazyThreadSafetyMode.SYNCHRONIZED`。
+
 ##### 可观察属性
 
+如果你要观察一个属性的变化过程，那么可以将属性委托给`Delegates.observable`, `observable`函数原型如下：
+
+```kotlin
+    public inline fun <T> observable(initialValue: T, crossinline onChange: (property: KProperty<*>, oldValue: T, newValue: T) -> Unit):
+            ReadWriteProperty<Any?, T> =
+        object : ObservableProperty<T>(initialValue) {
+            override fun afterChange(property: KProperty<*>, oldValue: T, newValue: T) = onChange(property, oldValue, newValue)
+        }
+```
+
+接受2个参数：
+
+- `initialValue`： 初始值
+- `onChange`： 属性值被修改时的回调处理器，回调有三个参数`property`,`oldValue`,`newValue`,分别为： 被赋值的属性、旧值与新值。
+
 可观察属性对应的是我们常用的观察者模式，机制类似于我们给`View`增加`Listener`。同样的`kotlin`给了我们很方便的实现:
 
 ```kotlin
 class User {
+    // 默认值为0
     var name: Int by Delegates.observable(0) {
         prop, old, new -> Log.d(JTAG, "$old -> $new")
     }
@@ -685,6 +837,12 @@ fun test(){
 在上面的例子中，我们看到在第一次赋值`user.gender = 2`时，由于`2>0`，所以`old<new`判断成立，所以执行了`set`方法，`gender`为2,
 第二次赋值`user.gender = 1`则没有通过判断，所以`gender`依然为2。   
 
+`vetoable` 与 `observable`一样，可以观察属性值的变化，不同的是，`vetoable`可以通过`处理器函数来决定属性值是否生效`。
+
+如声明一个Int类型的属性`vetoableProp`，如果新的值比旧值大，则生效，否则不生效。
+
+
+
 
 ##### map映射
 
@@ -710,6 +868,10 @@ class MutableUser(val map: MutableMap<String, Any?>) {
 }
 ```
 
+委托在kotlin中占有举足轻重的地位，特别是属性委托，lazy延迟初始化使用非常多，还有其他一些场景，比如在我们安卓开发中，使用属性委托来封装`SharePreference`，大大简化了`SharePreference`的存储和访问。在我们软件开发中，始终提倡的是高内聚，低耦合。而委托，就是内聚，可以降低耦合。另一方面，委托的使用，也能减少很多重复的样板代码。
+
+
+
 
 - [上一篇:4.Kotlin_表达式&关键字](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/4.Kotlin_%E8%A1%A8%E8%BE%BE%E5%BC%8F%26%E5%85%B3%E9%94%AE%E5%AD%97.md)       
 - [下一篇:6.Kotlin_多继承问题](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/6.Kotlin_%E5%A4%9A%E7%BB%A7%E6%89%BF%E9%97%AE%E9%A2%98.md)
diff --git a/README.md b/README.md
index 39604e78..a2391422 100644
--- a/README.md
+++ b/README.md
@@ -197,7 +197,6 @@ Android学习笔记
     - [Crash及ANR分析][80]
     - [Library项目中资源id使用case时报错][81]
     - [Mac下配置adb及Android命令][82]
-    - [MaterialDesign使用][83]
     - [RecyclerView专题][84]
     - [ConstraintLaayout简介][194]
     - [Android WorkManager][208]
@@ -395,7 +394,6 @@ Android学习笔记
 
 [81]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/Library%E9%A1%B9%E7%9B%AE%E4%B8%AD%E8%B5%84%E6%BA%90id%E4%BD%BF%E7%94%A8case%E6%97%B6%E6%8A%A5%E9%94%99.md   "Library项目中资源id使用case时报错"
 [82]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/Mac%E4%B8%8B%E9%85%8D%E7%BD%AEadb%E5%8F%8AAndroid%E5%91%BD%E4%BB%A4.md   "Mac下配置adb及Android命令"
-[83]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/MaterialDesign%E4%BD%BF%E7%94%A8.md   "MaterialDesign使用"
 [84]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/RecyclerView%E4%B8%93%E9%A2%98.md   "RecyclerView专题"
 [85]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E5%B8%B8%E7%94%A8%E5%91%BD%E4%BB%A4%E8%A1%8C%E5%A4%A7%E5%85%A8.md   "常用命令行大全"
 [86]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E5%8D%95%E4%BE%8B%E7%9A%84%E6%9C%80%E4%BD%B3%E5%AE%9E%E7%8E%B0%E6%96%B9%E5%BC%8F.md   "单例的最佳实现方式"

From 35b34b96ea466ef6bed1d7c57d003239079f364d Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 17 May 2021 11:45:34 +0800
Subject: [PATCH 068/213] update Jetpack part

---
 .../13.Jetpack MVVM\347\256\200\344\273\213.md"  |  2 +-
 .../3.Lifecycle\347\256\200\344\273\213.md"      |  2 +-
 .../4.ViewModel\347\256\200\344\273\213.md"      |  2 +-
 .../5.LiveData\347\256\200\344\273\213.md"       |  2 +-
 .../7.Room\347\256\200\344\273\213.md"           |  2 +-
 .../8.PagingLibrary\347\256\200\344\273\213.md"  |  2 +-
 "Jetpack/behavior/1.\347\256\200\344\273\213.md" | 14 ++++++++++++++
 .../foundation/1.\347\256\200\344\273\213.md"    | 16 ++++++++++++++++
 ...singToolbarLayout\347\256\200\344\273\213.md" |  2 +-
 .../8.TabLayout\347\256\200\344\273\213.md"      |  4 +++-
 10 files changed, 40 insertions(+), 8 deletions(-)
 rename Jetpack/architecture/13.Jetpack MVVM.md => "Jetpack/architecture/13.Jetpack MVVM\347\256\200\344\273\213.md" (99%)
 rename Jetpack/architecture/3.Lifecycle.md => "Jetpack/architecture/3.Lifecycle\347\256\200\344\273\213.md" (99%)
 rename Jetpack/architecture/4.ViewModel.md => "Jetpack/architecture/4.ViewModel\347\256\200\344\273\213.md" (99%)
 rename Jetpack/architecture/5.LiveData.md => "Jetpack/architecture/5.LiveData\347\256\200\344\273\213.md" (99%)
 rename Jetpack/architecture/7.Room.md => "Jetpack/architecture/7.Room\347\256\200\344\273\213.md" (99%)
 rename Jetpack/architecture/8.PagingLibrary.md => "Jetpack/architecture/8.PagingLibrary\347\256\200\344\273\213.md" (74%)
 create mode 100644 "Jetpack/behavior/1.\347\256\200\344\273\213.md"
 create mode 100644 "Jetpack/foundation/1.\347\256\200\344\273\213.md"

diff --git a/Jetpack/architecture/13.Jetpack MVVM.md "b/Jetpack/architecture/13.Jetpack MVVM\347\256\200\344\273\213.md"
similarity index 99%
rename from Jetpack/architecture/13.Jetpack MVVM.md
rename to "Jetpack/architecture/13.Jetpack MVVM\347\256\200\344\273\213.md"
index 0ed02013..1b51c673 100644
--- a/Jetpack/architecture/13.Jetpack MVVM.md	
+++ "b/Jetpack/architecture/13.Jetpack MVVM\347\256\200\344\273\213.md"	
@@ -1,4 +1,4 @@
-# 13.Jetpack MVVM
+# 13.Jetpack MVVM简介
 
 项目地址:[android-architecture](https://github.com/googlesamples/android-architecture)
 `Google`将该项目命名为`Android`的架构蓝图，我想从名字上已可以看穿一切。
diff --git a/Jetpack/architecture/3.Lifecycle.md "b/Jetpack/architecture/3.Lifecycle\347\256\200\344\273\213.md"
similarity index 99%
rename from Jetpack/architecture/3.Lifecycle.md
rename to "Jetpack/architecture/3.Lifecycle\347\256\200\344\273\213.md"
index 21232ce6..f4e6400c 100644
--- a/Jetpack/architecture/3.Lifecycle.md
+++ "b/Jetpack/architecture/3.Lifecycle\347\256\200\344\273\213.md"
@@ -1,4 +1,4 @@
-3.Lifecycle
+3.Lifecycle简介
 ===
 
 ## 背景
diff --git a/Jetpack/architecture/4.ViewModel.md "b/Jetpack/architecture/4.ViewModel\347\256\200\344\273\213.md"
similarity index 99%
rename from Jetpack/architecture/4.ViewModel.md
rename to "Jetpack/architecture/4.ViewModel\347\256\200\344\273\213.md"
index 9c6c9f47..423a6ef2 100644
--- a/Jetpack/architecture/4.ViewModel.md
+++ "b/Jetpack/architecture/4.ViewModel\347\256\200\344\273\213.md"
@@ -1,4 +1,4 @@
-4.ViewModel
+4.ViewModel简介
 ===
 
 `Android`系统提供控件，比如`Activity`和`Fragment`，这些控件都是具有生命周期方法，这些生命周期方法被系统调用。
diff --git a/Jetpack/architecture/5.LiveData.md "b/Jetpack/architecture/5.LiveData\347\256\200\344\273\213.md"
similarity index 99%
rename from Jetpack/architecture/5.LiveData.md
rename to "Jetpack/architecture/5.LiveData\347\256\200\344\273\213.md"
index 5c4e4c44..f23505a3 100644
--- a/Jetpack/architecture/5.LiveData.md
+++ "b/Jetpack/architecture/5.LiveData\347\256\200\344\273\213.md"
@@ -1,4 +1,4 @@
-5.LiveData
+5.LiveData简介
 ===
 
 ViewModel的主要作用是存放页面所需要的各种数据。我们在示例代码中定义了接口，当数据发生变化时，采用接口的方式实现对页面的通知。对此前面已经做了相关说明，通过接口的方式对页面进行通知是可行的，但如果要观察的数据很多，则需要定义大量的接口，代码会显得十分冗余。为此，Jetpack提供了LiveData组件。
diff --git a/Jetpack/architecture/7.Room.md "b/Jetpack/architecture/7.Room\347\256\200\344\273\213.md"
similarity index 99%
rename from Jetpack/architecture/7.Room.md
rename to "Jetpack/architecture/7.Room\347\256\200\344\273\213.md"
index 04d06a56..fe1e25c0 100644
--- a/Jetpack/architecture/7.Room.md
+++ "b/Jetpack/architecture/7.Room\347\256\200\344\273\213.md"
@@ -1,4 +1,4 @@
-7.Room
+7.Room简介
 ===
 
 `Room`是一个持久化工具，和`ormlite`、`greenDao`类似，都是`ORM`工具。在开发中我们可以利用`Room`来操作`sqlite`数据库。
diff --git a/Jetpack/architecture/8.PagingLibrary.md "b/Jetpack/architecture/8.PagingLibrary\347\256\200\344\273\213.md"
similarity index 74%
rename from Jetpack/architecture/8.PagingLibrary.md
rename to "Jetpack/architecture/8.PagingLibrary\347\256\200\344\273\213.md"
index 24e9810b..2cbc952e 100644
--- a/Jetpack/architecture/8.PagingLibrary.md
+++ "b/Jetpack/architecture/8.PagingLibrary\347\256\200\344\273\213.md"
@@ -1,4 +1,4 @@
-8.PagingLibrary
+8.PagingLibrary简介
 ===
 
 
diff --git "a/Jetpack/behavior/1.\347\256\200\344\273\213.md" "b/Jetpack/behavior/1.\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..0bbf536c
--- /dev/null
+++ "b/Jetpack/behavior/1.\347\256\200\344\273\213.md"
@@ -0,0 +1,14 @@
+# 1.简介
+
+
+### Behavior(行为组件)
+行为组件可帮助开发者的应用与标准Android服务（如通知、权限、分享和Google助理）相集成。它包含如下组件库: 
+- CameraX：帮助开发者简化相机应用的开发工作。它提供一致且易于使用的 API 界面，适用于大多数 Android 设备，并可向后兼容至 Android 5.0（API 级别 21）。
+- DownloadManager下载管理器:可处理长时间运行的HTTP下载，并在出现故障或在连接更改和系统重新启动后重试下载。
+- Media & playback(媒体&播放)：用于媒体播放和路由（包括 Google Cast）的向后兼容 API。
+- Notifications(通知)：提供向后兼容的通知 API，支持 Wear 和 Auto。
+- Permissions(权限)：用于检查和请求应用权限的兼容性 API。
+- Preferences(偏好设置)：提供了用户能够改变应用的功能和行为能力。
+- Sharing(共享)：提供适合应用操作栏的共享操作。
+- Slices(切片)：创建可在应用外部显示应用数据的灵活界面元素。
+
diff --git "a/Jetpack/foundation/1.\347\256\200\344\273\213.md" "b/Jetpack/foundation/1.\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..50007c92
--- /dev/null
+++ "b/Jetpack/foundation/1.\347\256\200\344\273\213.md"
@@ -0,0 +1,16 @@
+# 1.简介
+
+
+### Foundation(基础组件)：
+基础组件提供了横向功能，例如向后兼容性、测试以及Kotlin语言的支持。它包含如下组件库: 
+- Android KTX：Android KTX 是一组 Kotlin 扩展程序，它优化了供Kotlin使用的Jetpack和Android平台的API。以更简洁、更愉悦、更惯用的方式使用Kotlin进行Android开发。
+- AppCompat：提供了一系列以AppCompat开头的API，以便兼容低版本的Android开发。Jetpack基础中的AppCompat库包含v7库中的所有组件([支持库软件包](https://developer.android.com/topic/libraries/support-library/packages#v7-appcompat))。 其中包括AppCompat，Cardview，GridLayout，MediaRouter，Palette，RecyclerView，Renderscript，Preferences，Leanback，Vector Drawable，Design，Custom选项卡等。此外，该库为材质设计用户界面提供了实现支持，这使得AppCompat对 开发人员。 以下是android应用程序的一些关键领域，这些领域很难构建，但是可以使用AppCompat库轻松进行设计： 一般都是为了兼容 Android L以下版本，来提供Material Design的效果: 
+    - Toolbar
+    - ContextCompat
+    - AppCompatDialog
+- annotation:注解，提升代码可读性，内置了Android中常用的注解
+- Multidex(多Dex处理)：为方法数超过 64K 的应用启用多 dex 文件。Security(安全)：按照安全最佳做法读写加密文件和共享偏好设置。
+- Test(测试)：用于单元和运行时界面测试的 Android 测试框架。
+
+
+
diff --git "a/Jetpack/ui/material/6.CollapsingToolbarLayout\347\256\200\344\273\213.md" "b/Jetpack/ui/material/6.CollapsingToolbarLayout\347\256\200\344\273\213.md"
index f6d418e6..6d1a953b 100644
--- "a/Jetpack/ui/material/6.CollapsingToolbarLayout\347\256\200\344\273\213.md"
+++ "b/Jetpack/ui/material/6.CollapsingToolbarLayout\347\256\200\344\273\213.md"
@@ -1,4 +1,4 @@
-# 6.CollapsingToolbarLayout
+# 6.CollapsingToolbarLayout简介
 
 ```java
 public class CollapsingToolbarLayout
diff --git "a/Jetpack/ui/material/8.TabLayout\347\256\200\344\273\213.md" "b/Jetpack/ui/material/8.TabLayout\347\256\200\344\273\213.md"
index eca3c700..08dc7eaf 100644
--- "a/Jetpack/ui/material/8.TabLayout\347\256\200\344\273\213.md"
+++ "b/Jetpack/ui/material/8.TabLayout\347\256\200\344\273\213.md"
@@ -1,3 +1,5 @@
+# 8.TabLayout简介
+
 ```
 public class TabLayout extends HorizontalScrollView {
 ```
@@ -31,7 +33,7 @@ public class TabLayout extends HorizontalScrollView {
 - app:tabTextAppearance：字体大小
 - app:tabBackground：设置背景
 - app:tabMode：设置tablayout的排列模式，有两种scrollable和fixed；默认是fixed。fixed是固定的，适用于标签较少，scrollable是可滚动的，适用于标签较多的情况下
-    
+  
 
 作者：Anonymous___
 链接：https://www.jianshu.com/p/fece7cdf53a5

From 95bfc550220dec81ca11ce7a2b021e7ac359805d Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 17 May 2021 13:06:51 +0800
Subject: [PATCH 069/213] update README

---
 README.md | 65 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 65 insertions(+)

diff --git a/README.md b/README.md
index a2391422..6ef0cb7a 100644
--- a/README.md
+++ b/README.md
@@ -118,6 +118,39 @@ Android学习笔记
 - [架构设计][272]
     - [1.架构简介][273]
 
+- [Jetpack][287]
+    - [Jetpack简介][288]
+    - [architecture][289]
+        - [1.简介][293]
+        - [2.ViewBinding简介][294]
+        - [3.Lifecycle简介][295]
+        - [4.ViewModel简介][296]
+        - [5.LiveData简介][297]
+        - [6.DataBinding简介][298]
+        - [7.Room简介][299]
+        - [8.PagingLibrary简介][300]
+        - [9.App Startup简介][301]
+        - [10.DataStore简介][302]
+        - [11.Hilt简介][303]
+        - [12.Navigation简介][304]
+        - [13.Jetpack MVVM简介][305]
+        - [14.findViewById的过去及未来][306]
+    - [ui][290]
+        - [Jetpack Compose简介][307]
+        - [material][308]
+            - [1.MaterialToolbar简介][309]
+            - [2.NavigationView简介][310]
+            - [3.NestedScrollView简介][311]
+            - [4.CoordinatorLayout简介][312]
+            - [5.AppBarLayout简介][313]
+            - [6.CollapsingToolbarLayout简介][314]
+            - [7.Snackbar简介][315]
+            - [8.TabLayout简介][316]
+    - [foundation][291]
+        - [1.简介][317]
+    - [behavior][292]
+        - [1.简介][318]
+
 -  [图片加载][45]
     - [Glide简介(上)][25]
     - [Glide简介(下)][26]
@@ -605,6 +638,38 @@ Android学习笔记
 [ 284 ]: https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/LeakCanary%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90.md. "LeakCanary源码分析"
 [285]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/Java%E5%86%85%E5%AD%98%E6%A8%A1%E5%9E%8B.md "Java内存模型"
 [286]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/JVM%E6%9E%B6%E6%9E%84.md "JVM架构"
+[287]: https://github.com/CharonChui/AndroidNote/tree/master/Jetpack "Jetpack"
+[288]: https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/Jetpack%E7%AE%80%E4%BB%8B.md  "Jetpack简介"
+[289]: https://github.com/CharonChui/AndroidNote/tree/master/Jetpack/architecture "architecture"
+[290]: https://github.com/CharonChui/AndroidNote/tree/master/Jetpack/ui  "ui"
+[291]: https://github.com/CharonChui/AndroidNote/tree/master/Jetpack/foundation  "foundation"
+[292]: https://github.com/CharonChui/AndroidNote/tree/master/Jetpack/behavior "behavior"
+[293]: https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/1.%E7%AE%80%E4%BB%8B.md "1.简介"
+[294]: https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/2.ViewBinding%E7%AE%80%E4%BB%8B.md "2.ViewBinding简介"
+[295]: https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/3.Lifecycle%E7%AE%80%E4%BB%8B.md "3.Lifecycle简介"
+[296]: https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/4.ViewModel%E7%AE%80%E4%BB%8B.md "4.ViewModel简介"
+[297]: https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/5.LiveData%E7%AE%80%E4%BB%8B.md "5.LiveData简介"
+[298]: https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/6.DataBinding%E7%AE%80%E4%BB%8B.md "6.DataBinding简介"
+[299]: https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/7.Room%E7%AE%80%E4%BB%8B.md "7.Room简介"
+[300]: https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/8.PagingLibrary%E7%AE%80%E4%BB%8B.md "8.PagingLibrary简介"
+[301]: https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/9.App%20Startup%E7%AE%80%E4%BB%8B.md "9.App Startup简介"
+[302]: https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/10.DataStore%E7%AE%80%E4%BB%8B.md "10.DataStore简介"
+[303]: https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/11.Hilt%E7%AE%80%E4%BB%8B.md "11.Hilt简介"
+[304]: https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/12.Navigation%E7%AE%80%E4%BB%8B.md "12.Navigation简介"
+[305]: https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/13.Jetpack%20MVVM%E7%AE%80%E4%BB%8B.md "13.Jetpack MVVM简介"
+[306]: https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/14.findViewById%E7%9A%84%E8%BF%87%E5%8E%BB%E5%8F%8A%E6%9C%AA%E6%9D%A5.md "14.findViewById的过去及未来"
+[307]: https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/ui/Jetpack%20Compose%E7%AE%80%E4%BB%8B.md "Jetpack Compose简介"
+[308]: https://github.com/CharonChui/AndroidNote/tree/master/Jetpack/ui/material "material"
+[309]: https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/ui/material/1.MaterialToolbar%E7%AE%80%E4%BB%8B.md "1.MaterialToolbar简介"
+[310]: https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/ui/material/2.NavigationView%E7%AE%80%E4%BB%8B.md "2.NavigationView简介"
+[311]: https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/ui/material/3.NestedScrollView%E7%AE%80%E4%BB%8B.md "3.NestedScrollView简介"
+[312]: https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/ui/material/4.CoordinatorLayout%E7%AE%80%E4%BB%8B.md "4.CoordinatorLayout简介"
+[313]: https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/ui/material/5.AppBarLayout%E7%AE%80%E4%BB%8B.md "5.AppBarLayout简介"
+[314]: https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/ui/material/6.CollapsingToolbarLayout%E7%AE%80%E4%BB%8B.md "6.CollapsingToolbarLayout简介"
+[315]: https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/ui/material/7.Snackbar%E7%AE%80%E4%BB%8B.md "7.Snackbar简介"
+[316]: https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/ui/material/8.TabLayout%E7%AE%80%E4%BB%8B.md "8.TabLayout简介"
+[317]: https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/foundation/1.%E7%AE%80%E4%BB%8B.md "1.简介"
+[318]: https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/behavior/1.%E7%AE%80%E4%BB%8B.md "1.简介"
 
 
 Developed By

From 2bd856415d57f96385b53d080f5f9488c2292e9b Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 17 May 2021 16:18:10 +0800
Subject: [PATCH 070/213] update Jetpack part

---
 "Jetpack/architecture/1.\347\256\200\344\273\213.md"   |  3 ++-
 .../10.DataStore\347\256\200\344\273\213.md"           |  2 ++
 .../architecture/11.Hilt\347\256\200\344\273\213.md"   |  2 ++
 .../12.Navigation\347\256\200\344\273\213.md"          |  2 ++
 .../13.Jetpack MVVM\347\256\200\344\273\213.md"        |  3 +++
 ...345\216\273\345\217\212\346\234\252\346\235\245.md" |  8 +++++++-
 .../2.ViewBinding\347\256\200\344\273\213.md"          |  5 +++++
 .../3.Lifecycle\347\256\200\344\273\213.md"            |  4 ++--
 .../4.ViewModel\347\256\200\344\273\213.md"            |  4 ++--
 .../5.LiveData\347\256\200\344\273\213.md"             |  4 ++--
 .../6.DataBinding\347\256\200\344\273\213.md"          |  3 ++-
 .../architecture/7.Room\347\256\200\344\273\213.md"    |  4 ++--
 .../8.PagingLibrary\347\256\200\344\273\213.md"        |  3 +++
 .../9.App Startup\347\256\200\344\273\213.md"          |  3 +++
 .../1.MaterialToolbar\347\256\200\344\273\213.md"      |  3 +++
 .../2.NavigationView\347\256\200\344\273\213.md"       | 10 +++++++++-
 .../3.NestedScrollView\347\256\200\344\273\213.md"     |  3 ++-
 .../4.CoordinatorLayout\347\256\200\344\273\213.md"    |  6 ++++++
 .../5.AppBarLayout\347\256\200\344\273\213.md"         |  5 +++++
 ...CollapsingToolbarLayout\347\256\200\344\273\213.md" |  8 +++++++-
 .../ui/material/7.Snackbar\347\256\200\344\273\213.md" |  3 ++-
 .../material/8.TabLayout\347\256\200\344\273\213.md"   |  7 +------
 22 files changed, 74 insertions(+), 21 deletions(-)

diff --git "a/Jetpack/architecture/1.\347\256\200\344\273\213.md" "b/Jetpack/architecture/1.\347\256\200\344\273\213.md"
index 5345872d..f64448a8 100644
--- "a/Jetpack/architecture/1.\347\256\200\344\273\213.md"
+++ "b/Jetpack/architecture/1.\347\256\200\344\273\213.md"
@@ -127,7 +127,8 @@ override fun onDestroy() {
     包含本地的数据库等，网络`api`等，这些基本上和现有的一些`MVVM`，以及`Clean`架构的组合比较相似
 
 
-[下一篇: 2.集成(二)](https://github.com/CharonChui/AndroidNote/blob/master/ArchitectureComponents/2.%E9%9B%86%E6%88%90(%E4%BA%8C).md)
+     
+- [下一篇:2.ViewBinding简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/2.ViewBinding%E7%AE%80%E4%BB%8B.md)
 
 ---
 
diff --git "a/Jetpack/architecture/10.DataStore\347\256\200\344\273\213.md" "b/Jetpack/architecture/10.DataStore\347\256\200\344\273\213.md"
index 2b6cdb21..52988774 100644
--- "a/Jetpack/architecture/10.DataStore\347\256\200\344\273\213.md"
+++ "b/Jetpack/architecture/10.DataStore\347\256\200\344\273\213.md"
@@ -198,6 +198,8 @@ https://blog.csdn.net/weixin_42324979/article/details/112650189?utm_medium=distr
 - 使用PB进行序列化时需要额外定义IDL，这会产生一定工作量
   
 
+- [上一篇:9.App Startup简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/9.App%20Startup%E7%AE%80%E4%BB%8B.md)         
+- [下一篇:11.Hilt简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/11.Hilt%E7%AE%80%E4%BB%8B.md)
 
 ---
 
diff --git "a/Jetpack/architecture/11.Hilt\347\256\200\344\273\213.md" "b/Jetpack/architecture/11.Hilt\347\256\200\344\273\213.md"
index 38ba0a7e..9bcd46b4 100644
--- "a/Jetpack/architecture/11.Hilt\347\256\200\344\273\213.md"
+++ "b/Jetpack/architecture/11.Hilt\347\256\200\344\273\213.md"
@@ -8,6 +8,8 @@ https://zhuanlan.zhihu.com/p/335631378
 
 
 
+- [上一篇:10.DataStore简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/10.DataStore%E7%AE%80%E4%BB%8B.md)         
+- [下一篇:12.Navigation简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/12.Navigation%E7%AE%80%E4%BB%8B.md)
 
 
 ---
diff --git "a/Jetpack/architecture/12.Navigation\347\256\200\344\273\213.md" "b/Jetpack/architecture/12.Navigation\347\256\200\344\273\213.md"
index 18a39661..dac4d75d 100644
--- "a/Jetpack/architecture/12.Navigation\347\256\200\344\273\213.md"
+++ "b/Jetpack/architecture/12.Navigation\347\256\200\344\273\213.md"
@@ -479,6 +479,8 @@ override fun onCreate(savedInstanceState: Bundle?) {
 
 
 
+- [上一篇:11.Hilt简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/11.Hilt%E7%AE%80%E4%BB%8B.md)         
+- [下一篇:13.Jetpack MVVM简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/13.Jetpack%20MVVM%E7%AE%80%E4%BB%8B.md)
 
 
 ---
diff --git "a/Jetpack/architecture/13.Jetpack MVVM\347\256\200\344\273\213.md" "b/Jetpack/architecture/13.Jetpack MVVM\347\256\200\344\273\213.md"
index 1b51c673..50a25fa1 100644
--- "a/Jetpack/architecture/13.Jetpack MVVM\347\256\200\344\273\213.md"	
+++ "b/Jetpack/architecture/13.Jetpack MVVM\347\256\200\344\273\213.md"	
@@ -40,6 +40,9 @@ ViewModel层 用于持有和UI元素相关的数据，以保证这些数据在
 - [“终于懂了“系列：Jetpack AAC完整解析（四）MVVM - Android架构探索！](https://juejin.cn/post/6921321173661777933)
 
 
+- [上一篇:12.Navigation简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/12.Navigation%E7%AE%80%E4%BB%8B.md)         
+- [下一篇:14.findViewById的过去及未来](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/14.findViewById%E7%9A%84%E8%BF%87%E5%8E%BB%E5%8F%8A%E6%9C%AA%E6%9D%A5.md)
+
 
 ---
 
diff --git "a/Jetpack/architecture/14.findViewById\347\232\204\350\277\207\345\216\273\345\217\212\346\234\252\346\235\245.md" "b/Jetpack/architecture/14.findViewById\347\232\204\350\277\207\345\216\273\345\217\212\346\234\252\346\235\245.md"
index 0fc2bd0b..fe29ca19 100644
--- "a/Jetpack/architecture/14.findViewById\347\232\204\350\277\207\345\216\273\345\217\212\346\234\252\346\235\245.md"
+++ "b/Jetpack/architecture/14.findViewById\347\232\204\350\277\207\345\216\273\345\217\212\346\234\252\346\235\245.md"
@@ -19,4 +19,10 @@ https://medium.com/mobile-app-development-publication/how-android-access-view-it
 
 ## 参考
 - [Kotlin 插件的落幕，ViewBinding 的崛起](https://juejin.cn/post/6905942568467759111)
-- [How Android Access View Item: The Past to the Future](https://medium.com/mobile-app-development-publication/how-android-access-view-item-the-past-to-the-future-bb003ae84527)
\ No newline at end of file
+- [How Android Access View Item: The Past to the Future](https://medium.com/mobile-app-development-publication/how-android-access-view-item-the-past-to-the-future-bb003ae84527)
+
+
+
+- [上一篇:13.Jetpack MVVM简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/13.Jetpack%20MVVM%E7%AE%80%E4%BB%8B.md)
+
+
diff --git "a/Jetpack/architecture/2.ViewBinding\347\256\200\344\273\213.md" "b/Jetpack/architecture/2.ViewBinding\347\256\200\344\273\213.md"
index 43f23558..32985a8a 100644
--- "a/Jetpack/architecture/2.ViewBinding\347\256\200\344\273\213.md"
+++ "b/Jetpack/architecture/2.ViewBinding\347\256\200\344\273\213.md"
@@ -394,6 +394,11 @@ ViewBinding与DataBinding均会生成可用于直接引用视图的绑定类。
 - [Make Android View Binding great with Kotlin](https://proandroiddev.com/make-android-view-binding-great-with-kotlin-b71dd9c87719)
 - [How to Simplify your Android View Binding Delegation](https://medium.com/easyread/how-to-simplify-your-android-view-binding-delegation-d07812b2a616)
 
+
+
+- [上一篇:1.简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/1.%E7%AE%80%E4%BB%8B.md)         
+- [下一篇:3.Lifecycle简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/3.Lifecycle%E7%AE%80%E4%BB%8B.md)
+
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
diff --git "a/Jetpack/architecture/3.Lifecycle\347\256\200\344\273\213.md" "b/Jetpack/architecture/3.Lifecycle\347\256\200\344\273\213.md"
index f4e6400c..40ab61cf 100644
--- "a/Jetpack/architecture/3.Lifecycle\347\256\200\344\273\213.md"
+++ "b/Jetpack/architecture/3.Lifecycle\347\256\200\344\273\213.md"
@@ -948,8 +948,8 @@ private static void invokeMethodsForEvent(List<MethodReference> handlers,
 
 
 
-[上一篇: 2.集成(二)](https://github.com/CharonChui/AndroidNote/blob/master/ArchitectureComponents/2.%E9%9B%86%E6%88%90(%E4%BA%8C).md)
-[下一篇: 4.LiveData(四)](https://github.com/CharonChui/AndroidNote/blob/master/ArchitectureComponents/4.LiveData(%E5%9B%9B).md)
+- [上一篇: 2.ViewBinding简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/2.ViewBinding%E7%AE%80%E4%BB%8B.md)
+- [下一篇: 4.ViewModel简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/4.ViewModel%E7%AE%80%E4%BB%8B.md)
 
 
 ---
diff --git "a/Jetpack/architecture/4.ViewModel\347\256\200\344\273\213.md" "b/Jetpack/architecture/4.ViewModel\347\256\200\344\273\213.md"
index 423a6ef2..7c8a3198 100644
--- "a/Jetpack/architecture/4.ViewModel\347\256\200\344\273\213.md"
+++ "b/Jetpack/architecture/4.ViewModel\347\256\200\344\273\213.md"
@@ -339,8 +339,8 @@ public class ViewModelStore {
 
 
 
-[上一篇: 4.LiveData(四)](https://github.com/CharonChui/AndroidNote/blob/master/ArchitectureComponents/4.LiveData(%E5%9B%9B).md)
-[下一篇: 6.Room(六)](https://github.com/CharonChui/AndroidNote/blob/master/ArchitectureComponents/6.Room(%E5%85%AD).md)
+- [上一篇: 3.Lifecycle简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/3.Lifecycle%E7%AE%80%E4%BB%8B.md)
+- [下一篇: 5.LiveData简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/5.LiveData%E7%AE%80%E4%BB%8B.md)
 
 
 ---
diff --git "a/Jetpack/architecture/5.LiveData\347\256\200\344\273\213.md" "b/Jetpack/architecture/5.LiveData\347\256\200\344\273\213.md"
index f23505a3..45363359 100644
--- "a/Jetpack/architecture/5.LiveData\347\256\200\344\273\213.md"
+++ "b/Jetpack/architecture/5.LiveData\347\256\200\344\273\213.md"
@@ -418,8 +418,8 @@ class MyViewModel(private val repository: PostalCodeRepository) : ViewModel() {
 
 
 
-[上一篇: 3.Lifecycle(三)](https://github.com/CharonChui/AndroidNote/blob/master/ArchitectureComponents/3.Lifecycle(%E4%B8%89).md)
-[下一篇: 5.ViewModel(五)](https://github.com/CharonChui/AndroidNote/blob/master/ArchitectureComponents/5.ViewModel(%E4%BA%94).md)
+- [上一篇: 4.ViewModel简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/4.ViewModel%E7%AE%80%E4%BB%8B.md)
+- [下一篇: 6.DataBinding简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/6.DataBinding%E7%AE%80%E4%BB%8B.md)
 
 
 
diff --git "a/Jetpack/architecture/6.DataBinding\347\256\200\344\273\213.md" "b/Jetpack/architecture/6.DataBinding\347\256\200\344\273\213.md"
index 1d68094e..e093432c 100644
--- "a/Jetpack/architecture/6.DataBinding\347\256\200\344\273\213.md"
+++ "b/Jetpack/architecture/6.DataBinding\347\256\200\344\273\213.md"
@@ -11,7 +11,8 @@ https://developer.android.com/topic/libraries/data-binding
 
 
 
-
+- [上一篇:5.LiveData简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/5.LiveData%E7%AE%80%E4%BB%8B.md)         
+- [下一篇:7.Room简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/7.Room%E7%AE%80%E4%BB%8B.md)
 
 
 
diff --git "a/Jetpack/architecture/7.Room\347\256\200\344\273\213.md" "b/Jetpack/architecture/7.Room\347\256\200\344\273\213.md"
index fe1e25c0..c5d92b14 100644
--- "a/Jetpack/architecture/7.Room\347\256\200\344\273\213.md"
+++ "b/Jetpack/architecture/7.Room\347\256\200\344\273\213.md"
@@ -507,8 +507,8 @@ static final Migration MIGRATION_2_3 = new Migration(2, 3) {
 ```
 
 
-[上一篇: 5.ViewModel(五)](https://github.com/CharonChui/AndroidNote/blob/master/ArchitectureComponents/5.ViewModel(%E4%BA%94).md)
-[下一篇: 7.PagingLibrary(七)](https://github.com/CharonChui/AndroidNote/blob/master/ArchitectureComponents/7.PagingLibrary(%E4%B8%83).md)
+- [上一篇:6.DataBinding简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/6.DataBinding%E7%AE%80%E4%BB%8B.md)         
+- [下一篇:8.PagingLibrary简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/8.PagingLibrary%E7%AE%80%E4%BB%8B.md)
 
 
 ---
diff --git "a/Jetpack/architecture/8.PagingLibrary\347\256\200\344\273\213.md" "b/Jetpack/architecture/8.PagingLibrary\347\256\200\344\273\213.md"
index 2cbc952e..e6c0f804 100644
--- "a/Jetpack/architecture/8.PagingLibrary\347\256\200\344\273\213.md"
+++ "b/Jetpack/architecture/8.PagingLibrary\347\256\200\344\273\213.md"
@@ -5,6 +5,9 @@
 
 
 
+- [上一篇:7.Room简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/7.Room%E7%AE%80%E4%BB%8B.md)         
+- [下一篇:9.App Startup简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/9.App%20Startup%E7%AE%80%E4%BB%8B.md)
+
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
diff --git "a/Jetpack/architecture/9.App Startup\347\256\200\344\273\213.md" "b/Jetpack/architecture/9.App Startup\347\256\200\344\273\213.md"
index 57deef76..bd7e22b7 100644
--- "a/Jetpack/architecture/9.App Startup\347\256\200\344\273\213.md"	
+++ "b/Jetpack/architecture/9.App Startup\347\256\200\344\273\213.md"	
@@ -601,6 +601,9 @@ public final class AppInitializer {
 
 
 
+- [上一篇:8.PagingLibrary简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/8.PagingLibrary%E7%AE%80%E4%BB%8B.md)         
+- [下一篇:10.DataStore简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/10.DataStore%E7%AE%80%E4%BB%8B.md)
+
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
diff --git "a/Jetpack/ui/material/1.MaterialToolbar\347\256\200\344\273\213.md" "b/Jetpack/ui/material/1.MaterialToolbar\347\256\200\344\273\213.md"
index ea27c991..fde025c5 100644
--- "a/Jetpack/ui/material/1.MaterialToolbar\347\256\200\344\273\213.md"
+++ "b/Jetpack/ui/material/1.MaterialToolbar\347\256\200\344\273\213.md"
@@ -279,3 +279,6 @@ class MainActivity : BaseActivity() {
 - Drawer拉出、隐藏，带有android.R.id.home动画效果。
 - 监听Drawer拉出、隐藏；
 
+
+      
+- [下一篇:2.NavigationView简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/ui/material/2.NavigationView%E7%AE%80%E4%BB%8B.md)
diff --git "a/Jetpack/ui/material/2.NavigationView\347\256\200\344\273\213.md" "b/Jetpack/ui/material/2.NavigationView\347\256\200\344\273\213.md"
index 546e04da..be8958c4 100644
--- "a/Jetpack/ui/material/2.NavigationView\347\256\200\344\273\213.md"
+++ "b/Jetpack/ui/material/2.NavigationView\347\256\200\344\273\213.md"
@@ -189,4 +189,12 @@ menu_navigation.xml如下:
 
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/navigation_drawer.png)
 
-[Navigation Drawer](https://material.io/components/navigation-drawer/android)
\ No newline at end of file
+[Navigation Drawer](https://material.io/components/navigation-drawer/android)
+
+
+
+
+
+
+- [上一篇:1.MaterialToolbar简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/ui/material/1.MaterialToolbar%E7%AE%80%E4%BB%8B.md)         
+- [下一篇:3.NestedScrollView简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/ui/material/3.NestedScrollView%E7%AE%80%E4%BB%8B.md)
diff --git "a/Jetpack/ui/material/3.NestedScrollView\347\256\200\344\273\213.md" "b/Jetpack/ui/material/3.NestedScrollView\347\256\200\344\273\213.md"
index ba852382..19416b74 100644
--- "a/Jetpack/ui/material/3.NestedScrollView\347\256\200\344\273\213.md"
+++ "b/Jetpack/ui/material/3.NestedScrollView\347\256\200\344\273\213.md"
@@ -981,7 +981,8 @@ case MotionEvent.ACTION_UP:
 
 
 
-
+- [上一篇:2.NavigationView简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/ui/material/2.NavigationView%E7%AE%80%E4%BB%8B.md)         
+- [下一篇:4.CoordinatorLayout简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/ui/material/4.CoordinatorLayout%E7%AE%80%E4%BB%8B.md)
 
 
 
diff --git "a/Jetpack/ui/material/4.CoordinatorLayout\347\256\200\344\273\213.md" "b/Jetpack/ui/material/4.CoordinatorLayout\347\256\200\344\273\213.md"
index 1f60e739..761af93d 100644
--- "a/Jetpack/ui/material/4.CoordinatorLayout\347\256\200\344\273\213.md"
+++ "b/Jetpack/ui/material/4.CoordinatorLayout\347\256\200\344\273\213.md"
@@ -152,3 +152,9 @@ CoordinatorLayout可以监听其所有子控件的各种事件，然后自动帮
 
 其实道理很简单，我们在Snackbar的make()方法中传入的参数就是用来指定Snackbar是基于哪个View来触发的，如果我们传入的是FloatingActionButton本身，而FloatingActionButton是CoordinatorLayout中的子控件，因此这个事件就理所应当能被监听到了。
 
+
+
+
+- [上一篇:3.NestedScrollView简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/ui/material/3.NestedScrollView%E7%AE%80%E4%BB%8B.md)         
+- [下一篇:5.AppBarLayout简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/ui/material/5.AppBarLayout%E7%AE%80%E4%BB%8B.md)
+
diff --git "a/Jetpack/ui/material/5.AppBarLayout\347\256\200\344\273\213.md" "b/Jetpack/ui/material/5.AppBarLayout\347\256\200\344\273\213.md"
index 7611f0b1..ac881419 100644
--- "a/Jetpack/ui/material/5.AppBarLayout\347\256\200\344\273\213.md"
+++ "b/Jetpack/ui/material/5.AppBarLayout\347\256\200\344\273\213.md"
@@ -92,3 +92,8 @@ AppBarLayout对象实现了一个Behavior。而正是这个Behavior，它会响
  `app:layout_scrollFlags="scroll|enterAlways"`
  `app:layout_behavior="@string/appbar_scrolling_view_behavior"`
 
+
+
+
+- [上一篇:4.CoordinatorLayout简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/ui/material/4.CoordinatorLayout%E7%AE%80%E4%BB%8B.md)         
+- [下一篇:6.CollapsingToolbarLayout简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/ui/material/6.CollapsingToolbarLayout%E7%AE%80%E4%BB%8B.md)
diff --git "a/Jetpack/ui/material/6.CollapsingToolbarLayout\347\256\200\344\273\213.md" "b/Jetpack/ui/material/6.CollapsingToolbarLayout\347\256\200\344\273\213.md"
index 6d1a953b..4b5657bf 100644
--- "a/Jetpack/ui/material/6.CollapsingToolbarLayout\347\256\200\344\273\213.md"
+++ "b/Jetpack/ui/material/6.CollapsingToolbarLayout\347\256\200\344\273\213.md"
@@ -231,4 +231,10 @@ Material 包中的很多类，比如 `DrawerLayout`、`CoordinatorLayout`及`App
 
 - `fitsSystemWindows` 是深度优先的。顺序很重要，it’s the first View that consumes the insets that makes a difference
 - Insets are always relative to the full window - 布局前就添加了 inset，所以在为父节点添加 padding 时其实并不知道 view 的位置
-- padding 会被 `fitsSystemWindows=true` 覆盖 - 同一个 view 上使用 `fitsSystemWindows=true` 后 padding 相关的属性无效
\ No newline at end of file
+- padding 会被 `fitsSystemWindows=true` 覆盖 - 同一个 view 上使用 `fitsSystemWindows=true` 后 padding 相关的属性无效
+
+
+
+
+- [上一篇:5.AppBarLayout简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/ui/material/5.AppBarLayout%E7%AE%80%E4%BB%8B.md)         
+- [下一篇:7.Snackbar简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/ui/material/7.Snackbar%E7%AE%80%E4%BB%8B.md)
diff --git "a/Jetpack/ui/material/7.Snackbar\347\256\200\344\273\213.md" "b/Jetpack/ui/material/7.Snackbar\347\256\200\344\273\213.md"
index bf6e3956..d495396d 100644
--- "a/Jetpack/ui/material/7.Snackbar\347\256\200\344\273\213.md"
+++ "b/Jetpack/ui/material/7.Snackbar\347\256\200\344\273\213.md"
@@ -33,4 +33,5 @@ setAction()方法可设置Snackbar右侧按钮，增加进行交互事件。如
 
 
 
-
+- [上一篇:6.CollapsingToolbarLayout简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/ui/material/6.CollapsingToolbarLayout%E7%AE%80%E4%BB%8B.md)         
+- [下一篇:8.TabLayout简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/ui/material/8.TabLayout%E7%AE%80%E4%BB%8B.md)
diff --git "a/Jetpack/ui/material/8.TabLayout\347\256\200\344\273\213.md" "b/Jetpack/ui/material/8.TabLayout\347\256\200\344\273\213.md"
index 08dc7eaf..73d14e83 100644
--- "a/Jetpack/ui/material/8.TabLayout\347\256\200\344\273\213.md"
+++ "b/Jetpack/ui/material/8.TabLayout\347\256\200\344\273\213.md"
@@ -23,8 +23,6 @@ public class TabLayout extends HorizontalScrollView {
 </android.support.v4.view.ViewPager>
 ```
 
-
-
 - app:tabSelectedTextColor：选中字体的颜色
 - app:tabTextColor：未选中字体的颜色
 - app:tabIndicatorColor：指示器下标的颜色
@@ -35,7 +33,4 @@ public class TabLayout extends HorizontalScrollView {
 - app:tabMode：设置tablayout的排列模式，有两种scrollable和fixed；默认是fixed。fixed是固定的，适用于标签较少，scrollable是可滚动的，适用于标签较多的情况下
   
 
-作者：Anonymous___
-链接：https://www.jianshu.com/p/fece7cdf53a5
-来源：简书
-著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
\ No newline at end of file
+- [上一篇:7.Snackbar简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/ui/material/7.Snackbar%E7%AE%80%E4%BB%8B.md)
\ No newline at end of file

From 3b455f7ea97d31cc377dcbcf7a1e2202ab41d238 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Fri, 28 May 2021 21:41:53 +0800
Subject: [PATCH 071/213] add notes

---
 ...mposing builds\347\256\200\344\273\213.md" |  346 +++++
 .../Gradle\344\270\223\351\242\230.md"        | 1150 ++++++++++++++++-
 .../Coil\347\256\200\344\273\213.md"          |   62 +
 .../10.DataStore\347\256\200\344\273\213.md"  |  237 +++-
 .../11.Hilt\347\256\200\344\273\213.md"       |  313 ++++-
 ...5\345\260\204&\346\211\251\345\261\225.md" |  145 +++
 .../8.Kotlin_\345\215\217\347\250\213.md"     |   59 +-
 7 files changed, 2242 insertions(+), 70 deletions(-)
 create mode 100644 "Gradle&Maven/Composing builds\347\256\200\344\273\213.md"
 create mode 100644 "ImageLoaderLibrary/Coil\347\256\200\344\273\213.md"

diff --git "a/Gradle&Maven/Composing builds\347\256\200\344\273\213.md" "b/Gradle&Maven/Composing builds\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..8a137ce3
--- /dev/null
+++ "b/Gradle&Maven/Composing builds\347\256\200\344\273\213.md"	
@@ -0,0 +1,346 @@
+Composing builds简介
+===
+
+在Android Studio项目中，经常会引用多个Module，而且会有多人同时参与项目开发，在这种背景下，会时常遇到版本冲突问题，出现不同的compileSdkVersion或者出现同一个库的多个不同版本等，导致我们的包体变大，项目运行时间变长，所以将依赖版本统一是一个项目优化的必经之路。
+
+到目前为止Google为管理Gradle依赖提供了4种不同方法:  
+
+- 手动管理
+
+    在每个module中定义插件依赖库，每次升级依赖库时都需要手动更改（不建议使用）。
+
+- ext的方式管理
+
+    这是Google推荐管理依赖的方法 [Android官方文档](https://developer.android.com/studio/build/gradle-tips#configure-project-wide-properties)。但是无法跟踪依赖关系，可读性差，不便维护。
+
+- Kotlin + buildSrc
+
+    支持自动补全和单击跳转，依赖更新时将重新构建整个项目。
+
+- Composing builds
+
+    自动补全和单击跳转，依赖更新时不会重新构建整个项目。
+
+    
+
+## Groovy ext扩展函数的替代方式
+
+我们在使用Groovy语言构建项目的时候，抽取config.gradle作为全局的变量控制，使用ext扩展函数来统一配置依赖，如下：
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/config_gradle.png?raw=true)
+
+```groovy
+ext {
+    android = [
+            compileSdkVersion: 29,
+            buildToolsVersion: "29",
+            minSdkVersion    : 17,
+            targetSdkVersion : 26,
+            versionCode      : 102,
+            versionName      : "1.0.2"
+    ]
+
+    version = [
+            appcompatVersion       : "1.1.0",
+            coreKtxVersion         : "1.2.0",
+            supportLibraryVersion  : "28.0.0",
+            androidTestVersion     : "3.0.1",
+            junitVersion           : "4.12",
+            glideVersion           : "4.11.0",
+            okhttpVersion          : "3.11.0",
+            retrofitVersion        : "2.3.0",
+            constraintLayoutVersion: "1.1.3",
+            gsonVersion            : "2.7",
+            rxjavaVersion          : "2.2.2",
+            rxandroidVersion       : "2.1.0",
+            ..........省略...........
+    ]
+
+    dependencies = [
+            //base
+            "constraintLayout"      : "androidx.constraintlayout:constraintlayout:${version["constraintLayoutVersion"]}",
+            "appcompat"             : "androidx.appcompat:appcompat:${version["appcompatVersion"]}",
+            "coreKtx"               : "androidx.core:core-ktx:${version["coreKtxVersion"]}",
+            "material"              : "com.google.android.material:material:1.2.1",
+
+            //multidex
+            "multidex"              : "com.android.support:multidex:${version["multidexVersion"]}",
+
+            //okhttp
+            "okhttp"                : "com.squareup.okhttp3:okhttp:${version["okhttpVersion"]}",
+            "logging-interceptor"   : "com.squareup.okhttp3:logging-interceptor:${version["okhttpVersion"]}",
+
+            //retrofit
+            "retrofit"              : "com.squareup.retrofit2:retrofit:${version["retrofitVersion"]}",
+            "converter-gson"        : "com.squareup.retrofit2:converter-gson:${version["retrofitVersion"]}",
+            "adapter-rxjava2"       : "com.squareup.retrofit2:adapter-rxjava2:${version["retrofitVersion"]}",
+            "converter-scalars"     : "com.squareup.retrofit2:converter-scalars:${version["retrofitVersion"]}",
+			..........省略...........
+    ]
+}
+```
+
+依赖写完之后，在root路径下的build.gradle添加以下代码:   
+
+```groovy
+apply from: "config.gradle"
+```
+
+然后在需要依赖的module下的build.gradle中: 
+
+```groovy
+dependencies {
+	...
+    // Retrofit + okhttp 相关的依赖包
+    api rootProject.ext.dependencies["retrofit"]
+    ...
+}
+```
+
+以上就是Groovy ext扩展函数的依赖管理方式，此方式可以做到版本依赖，但是最大的缺点就是无法跟踪代码，想要找到上面示例代码中的rootProject.ext.dependencies["retrofit"]这个依赖，需要手动切到config.gradle去搜索查找，可读性很差。
+
+
+
+## buildSrc+kotlin
+
+Android Gradle插件4.0支持在Gradle构建配置中使用Kotlin脚本 (KTS)，用于替代Groovy（过去在Gradle配置文件中使用的编程语言）。
+
+将来，KTS会比Groovy更适合用于编写Gradle脚本，因为采用Kotlin编写的代码可读性更高，并且Kotlin提供了更好的编译时检查和IDE支持。
+
+虽然与Groovy相比，KTS当前能更好地在Android Studio的代码编辑器中集成，但采用KTS的构建速度往往比采用Groovy慢，因此在迁移到KTS时应考虑构建性能。
+
+KTS:是指Kotlin脚本，这是Gradle在构建配置文件中使用的一种[Kotlin语言形式](https://kotlinlang.org/docs/tutorials/command-line.html#run-scripts)。Kotlin脚本是[可从命令行运行](https://kotlinlang.org/docs/tutorials/command-line.html#using-the-command-line-to-run-scripts)的Kotlin代码。
+
+Kotlin DSL:主要是指[Android Gradle插件Kotlin DSL](https://developer.android.com/reference/tools/gradle-api)，有时也指[底层Gradle Kotlin DSL](https://guides.gradle.org/migrating-build-logic-from-groovy-to-kotlin/)。
+
+
+
+摘自 [Gradle 文档](https://docs.gradle.org/current/userguide/organizing_gradle_projects.html#sec:build_sources)：当运行Gradle时会检查根项目中是否存在一个名为buildSrc的目录，该目录包含了项目build相关的逻辑。然后Gradle会自动编译并测试这段代码，并将其放入构建脚本的类路径中, 对于多项目构建，只能有一个buildSrc目录，该目录必须位于根项目目录中,buildSrc是Gradle项目根目录下的一个目录，它可以包含我们的构建逻辑，与脚本插件相比，buildSrc应该是首选，因为它更易于维护、重构和测试代码。
+
+buildSrc的方式，是最近几年特别流行的版本依赖管理方式。它有以下几个优点：
+
+- 支持双向跟踪
+- buildSrc是Android默认插件，全局只有这一个地方可以修改
+- 支持Android Studio的代码补全
+
+使用方式可参考：[Kotlin + buildSrc for Better Gradle Dependency Management](https://handstandsam.com/2018/02/11/kotlin-buildsrc-for-better-gradle-dependency-management/)
+
+- 在项目根目录下新建一个名为buildSrc的文件夹( 名字必须是buildSrc，因为运行Gradle时会检查项目中是否存在一个名为buildSrc的目录 )
+- 在buildSrc文件夹里创建名为build.gradle.kts的文件，添加以下内容： 
+
+```kotlin
+plugins {
+    `kotlin-dsl`
+}
+repositories{
+    jcenter
+}    
+```
+
+- 在buildSrc/src/main/java/包名/目录下新建Deps.kt文件，添加以下内容: 
+
+```groovy
+object Versions {
+    val appcompat = "1.1.0"
+}
+
+object Deps {
+    val appcompat =  "androidx.appcompat:appcompat:${Versions.appcompat}"
+}
+```
+
+- 重启Android Studio，项目里就会多出一个名为buildSrc的module。 
+
+
+
+
+缺点: 
+
+- buildSrc 依赖更新将重新构建整个项目，项目越大，重新构建的时间就越长，造成不必要的时间浪费。
+
+
+
+### 脚本文件命名
+
+- 用Groovy编写的Gradle build文件使用.gradle文件扩展名。
+- 用Kotlin编写的Gradle build文件使用.gradle.kts文件扩展名。
+
+### 常见误区
+
+**用于定义字符串的双引号**。Groovy允许使用单引号来定义字符串，而Kotlin则要求使用双引号。
+
+**基于句点表达式的字符串插值。**在Groovy中，您可以使用`$`前缀来表示基于句点表达式的字符串插值，例如以下代码段中的$project.rootDir：
+
+```
+myRootDirectory = "$project.rootDir/tools/proguard-rules-debug.pro"
+```
+
+但在Kotlin中，上述代码将对 `project`（而非 `project.rootDir`）调用 `toString()`。如需获取根目录的值，请使用大括号括住整个变量：
+
+- `myRootDirectory = "${project.rootDir}/tools/proguard-rules-debug.pro"`
+- **变量分配**。一些在Groovy中适用的分配方式现在会被视作setter（或者，对于列表、集合等，则适用“addX”)，因为属性在Kotlin中是只读的。
+
+### 显式和隐式buildTypes
+
+在Kotlin DSL中，某些buildTypes（如debug和release）是隐式提供的。但是，其他buildTypes则必须手动创建。
+
+例如，在Groovy中，您可能有debug、release和staging` `buildTypes：
+
+**Groovy**
+
+```groovy
+buildTypes debug {  ... } release {  ... } staging {  ... }
+```
+
+在KTS中，仅debug和release` `buildTypes是隐式提供的，而staging则必须由您手动创建：
+
+**KTS**
+
+```
+buildTypes getByName("debug") {  ... } getByName("release") {  ... } create("staging") {  ... }
+```
+
+### 使用plugins代码块
+
+如果您在build文件中使用plugins代码块，IDE将能够获知相关上下文信息，即使在构建失败时也是如此。IDE可使用这些信息执行代码补全并提供其他实用建议，从而帮助您解决KTS文件中存在的问题。
+
+在您的代码中，将命令式apply plugin替换为声明式plugins代码块。Groovy中的以下代码:  
+
+```groovy
+apply plugin: 'com.android.application'
+apply plugin: 'kotlin-android'
+apply plugin: 'kotlin-kapt'
+apply plugin: 'androidx.navigation.safeargs.kotlin'
+```
+
+…在 KTS 中变为以下代码：
+
+```kotlin
+plugins {  
+    id("com.android.application")  
+    id("kotlin-android")  
+    id("kotlin-kapt")  
+    id("androidx.navigation.safeargs.kotlin") 
+}
+```
+
+如需详细了解plugins代码块，请参阅 [Gradle 的迁移指南](https://docs.gradle.org/nightly/userguide/migrating_from_groovy_to_kotlin_dsl.html#applying_plugins)。
+
+
+
+
+
+## Composing builds
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/composite_build.jpeg?raw=true)
+
+
+
+Composing builds：A composite build is simply a build that includes other builds. In many ways a composite build is similar to a Gradle multi-project build, except that instead of including single projects, complete builds are included.
+复合构建只是包含其他构建的构建. 在许多方面，复合构建类似于Gradle多项目构建，不同之处在于，它包括完整的builds，而不是包含单个projects: 
+
+- 组合通常独立开发的构建，例如，在应用程序使用的库中尝试错误修复时
+- 将大型的多项目构建分解为更小，更孤立的块，可以根据需要独立或一起工作
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/buildsrc_composingbuild.png?raw=true)
+
+**使用方式**
+ 1.新建module，名为versionPlugin（自起）
+ 2.在该module下的build.gradle文件中，添加如下代码：
+
+```groovy
+buildscript {
+    repositories {
+        jcenter()
+    }
+    dependencies {
+        // 因为使用的 Kotlin 需要需要添加 Kotlin 插件
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.4.10"
+    }
+}
+
+apply plugin: 'kotlin'
+apply plugin: 'java-gradle-plugin'
+
+repositories {
+    // 需要添加 jcenter 否则会提示找不到 gradlePlugin
+    jcenter()
+    google()
+}
+
+
+compileKotlin {
+    kotlinOptions {
+        jvmTarget = "1.8"
+    }
+}
+compileTestKotlin {
+    kotlinOptions {
+        jvmTarget = "1.8"
+    }
+}
+
+gradlePlugin {
+    plugins {
+        version {
+            // 在app模块需要通过id引用这个插件
+            id = 'com.hi.dhl.plugin'
+            // 实现这个插件的类的路径
+            implementationClass = 'com.hi.dhl.plugin.Deps'
+        }
+    }
+}
+```
+
+3.在versionPlugin/src/main/java/包名/目录下新建Deps.kt文件，添加你的依赖配置，如：
+
+```groovy
+package com.hi.dhl.plugin
+
+class Deps : Plugin<Project> {
+    override fun apply(project: Project) {
+        // Possibly common dependencies or can stay empty
+    }
+
+    companion object {
+        val appcompat = "androidx.appcompat:appcompat:1.1.0"
+    }
+}
+```
+
+5.在settings.gradle文件内添加includeBuild(“versionPlugin”)，注意是includeBuild哦~，Rebuild项目
+6.后面就可以在需要使用的gradle文件中使用了，如app下的build.gradle，在首行添加以下内容：
+
+```groovy
+plugins {
+    // 这个id就是在versionPlugin文件夹下build.gradle文件内定义的id
+    id "com.hi.dhl.plugin"
+}
+```
+
+注意: plugins{}需要放在app模块build.gradle文件内的首行位置
+
+使用如下:  
+
+```groovy
+android {
+    implementation Deps.appcompat
+}
+```
+
+
+
+
+
+# 参考
+
+- [Kotlin + buildSrc for Better Gradle Dependency Management](https://handstandsam.com/2018/02/11/kotlin-buildsrc-for-better-gradle-dependency-management/)
+- [How to use Composite builds as a replacement of buildSrc in Gradle](https://medium.com/bumble-tech/how-to-use-composite-builds-as-a-replacement-of-buildsrc-in-gradle-64ff99344b58)
+- [Stop using Gradle buildSrc. Use composite builds instead](https://proandroiddev.com/stop-using-gradle-buildsrc-use-composite-builds-instead-3c38ac7a2ab3)
+- [再见吧 buildSrc, 拥抱 Composing builds 提升 Android 编译速度](https://juejin.cn/post/6844904176250519565)
+- [composite_builds](https://docs.gradle.org/current/userguide/composite_builds.html)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/Gradle&Maven/Gradle\344\270\223\351\242\230.md" "b/Gradle&Maven/Gradle\344\270\223\351\242\230.md"
index 9be34a2a..9ac175bc 100644
--- "a/Gradle&Maven/Gradle\344\270\223\351\242\230.md"
+++ "b/Gradle&Maven/Gradle\344\270\223\351\242\230.md"
@@ -9,18 +9,72 @@ Gradle专题
 简介
 ---
 
-`Gradle`是以`Groovy`语言为基础，面向`Java`应用为主。基于`DSL(Domain Specific Language)`语法的自动化构建工具。
+[Gradle](https://gradle.org/releases/)是以`Groovy`语言为基础，面向`Java`应用为主。基于`DSL(Domain Specific Language)`语法的自动化构建工具。
 
 `Gradle`集合了`Ant`的灵活性和强大功能，同时也集合了`Maven`的依赖管理和约定，从而创造了一个更有效的构建方式。凭借`Groovy`的`DSL`和创新打包方式，`Gradle`提供了一个可声明的方式，并在合理默认值的基础上描述所有类型的构建。 `Gradle`目前已被选作许多开源项目的构建系统。
 
+[Groovy](http://www.groovy-lang.org/api.html)基于Java并拓展了Java。  Java程序员可以无缝切换到使用Groovy开发程序。Groovy说白了就是把写Java程序变得像写脚本一样简单。写完就可以执行，Groovy内部会将其编译成Javaclass然后启动虚拟机来执行。当然，这些底层的渣活不需要你管。*实际上，由于Groovy Code在真正执行的时候已经变成了Java字节码，所以JVM根本不知道自己运行的是Groovy代码*。
+
 因为`Gradle`是基于`DSL`语法的，如果想看到`build.gradle`文件中全部可以选项的配置，可以看这里
 [DSL Reference](http://google.github.io/android-gradle-dsl/current/)
 
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_build_process.png?raw=true)
+
+
+
 基本的项目设置
 ---
 
 一个`Gradle`项目通过一个在项目根目录中的`build.gradle`文件来描述它的构建。
 
+# Gradle Java 构建入门
+
+## Java 插件
+
+如你所见，Gradle 是一个通用工具。它可以通过脚本构建任何你想要实现的东西，真正实现开箱即用。但前提是你需要在脚本中编写好代码才行。
+
+大部分 Java 项目基本流程都是相似的：编译源文件，进行单元测试，创建 jar 包。使用 Gradle  做这些工作不必为每个工程都编写代码。Gradle 已经提供了完美的插件来解决这些问题。插件就是 Gradle  的扩展，简而言之就是为你添加一些非常有用的默认配置。Gradle 自带了很多插件，并且你也可以很容易的编写和分享自己的插件。Java  plugin 作为其中之一，为你提供了诸如编译，测试，打包等一些功能。
+
+Java  插件为工程定义了许多默认值，如Java源文件位置。如果你遵循这些默认规则，那么你无需在你的脚本文件中书写太多代码。当然，Gradle  也允许你自定义项目中的一些规则，实际上，由于对 Java 工程的构建是基于插件的，那么你也可以完全不用插件自己编写代码来进行构建。
+
+后面的章节我们通过许多深入的例子介绍了如何使用 Java 插件来进行以来管理和多项目构建等。但在这个章节我们需要先了解 Java 插件的基本用法。
+
+### 一个基本 Java 项目
+
+来看一下下面这个小例子，想用 Java 插件，只需增加如下代码到你的脚本里。
+
+### 采用 Java 插件
+
+```
+build.gradle
+apply plugin: 'java'
+```
+
+备注:示例代码可以在 Gralde 发行包中的 samples/java/quickstart 下找到。
+
+定义一个 Java 项目只需如此而已。这将会为你添加 Java 插件及其一些内置任务。
+
+> 添加了哪些任务?
+>
+> 你可以运行 gradle tasks 列出任务列表。这样便可以看到 Java 插件为你添加了哪些任务。
+
+标准目录结构如下:
+
+```
+project  
+    +build  
+    +src/main/java  
+    +src/main/resources  
+    +src/test/java  
+    +src/test/resources  
+```
+
+Gradle 默认会从 `src/main/java` 搜寻打包源码，在 `src/test/java` 下搜寻测试源码。并且 `src/main/resources` 下的所有文件按都会被打包，所有 `src/test/resources` 下的文件 都会被添加到类路径用以执行测试。所有文件都输出到 build 下，打包的文件输出到 build/libs 下。
+
+
+
 ### 简单的`Build`文件
 
 最简单的`Android`应用中的`build.gradle`都会包含以下几个配置：   
@@ -40,7 +94,7 @@ buildscript {
 }
 ```
 `Module`中的`build.gradle`:    
-   
+
 ```
 apply plugin: 'com.android.application'
 
@@ -56,9 +110,8 @@ android {
 - `apply plugin : com.android.application`，声明使用`com.androdi.application`插件。这是构建`Android`应用所需要的插件。
 - `android{...}`配置了所有`Android`构建时的参数。默认情况下，只有编译的目标版本以及编译工具的版本是需要的。
 
-重要: 这里只能使用`com.android.application`插件。如果使用`java`插件将会报错。
+重要: 这里只能使用`com.android.application`插件。如果使用`java`插件将会报错。目录结构
 
-### 目录结构
 `module/src/main`下的目录结构，因为有时候很多人把`so`放到`libs`目录就会报错:    
 
 - java/
@@ -93,6 +146,16 @@ android {
 就像有些人就是要把`so`放到`libs`目录中(这类人有点犟)，那就需要这样进行修改。    
 注意:因为在旧的项目结构中所有的源文件(`Java`,`AIDL`和`RenderScript`)都放到同一个目录中，我们需要将`sourceSet`中的这些新部件都设置给`src`目录。
 
+
+
+projects 和 tasks是 Gradle 中最重要的两个概念。
+
+任何一个 Gradle 构建都是由一个或多个 projects 组成。每个 project 包括许多可构建组成部分。  这完全取决于你要构建些什么。举个例子，每个 project 或许是一个 jar 包或者一个 web 应用，它也可以是一个由许多其他项目中产生的  jar 构成的 zip 压缩包。一个 project  不必描述它只能进行构建操作。它也可以部署你的应用或搭建你的环境。不要担心它像听上去的那样庞大。 Gradle 的  build-by-convention 可以让您来具体定义一个 project        到底该做什么。
+
+每个 project 都由多个 tasks 组成。每个 task 都代表了构建执行过程中的一个原子性操作。如编译，打包，生成 javadoc，发布到某个仓库等操作。
+
+到目前为止，可以发现我们可以在一个 project 中定义一些简单任务，后续章节将会阐述多项目构建和多项目多任务的内容。
+
 Build Tasks
 ---
 
@@ -108,6 +171,7 @@ Build Tasks
     - `assembleDebug`
     - `assembleRelease`  
     
+
 提示:`Gradle`支持通过命令行执行任务首字母缩写的方式。例如:      
 在没有其他任务符合`aR`的前提下，`gradle aR`与`gradle assembleRelease`是相同的。
 
@@ -123,7 +187,7 @@ Build Tasks
 ### 基本的`Build`定制
 
 `Android`插件提供了一些列的`DSL`来让直接从构建系统中做大部分的定制。
- 
+
 ##### `Manifest`整体部分
 `DSL`提供了很多重要的配置`manifest`文件的参数，例如:     
 
@@ -185,9 +249,9 @@ android {
     - 设置了它的`applicationId`。这样`debug`模式就能与`release`模式的`apk`同时安装在同一手机上。
 - 创建了一个新的`jnidebug`的`Build Type`，并且把它设置为`debug`的拷贝。
 - 通过允许`JNI`组件的`debug`和增加一个新的包名后缀来继续定制该`Build Type`。  
- 
+
 不管使用`initWith()`还是使用其他的代码块，创建一个新的`Build Types`都是非常简单的在`buildTypes`代码块中创建一个新的元素就可以了。
- 
+
 ##### 签名配置
 
 为应用签名需要使用如下几个部分:      
@@ -290,7 +354,188 @@ dependencies {
 }
 ```
 
-##### 多项目设置      
+
+
+Gradle支持三种不同的仓库，分别是：Maven和Ivy以及文件夹。依赖包会在你执行build构建的时候从这些远程仓库下载，当然Gradle会为你在本地保留缓存，所以一个特定版本的依赖包只需要下载一次。
+
+一个依赖需要定义三个元素：group，name和version。group意味着创建该library的组织名，通常这会是包名，name是该library的唯一标示。version是该library的版本号，我们来看看如何申明依赖：
+
+```
+dependencies {
+       compile 'com.google.code.gson:gson:2.3'
+       compile 'com.squareup.retrofit:retrofit:1.9.0'
+}
+```
+
+上述的代码是基于groovy语法的，所以其完整的表述应该是这样的：
+
+```
+dependencies {
+      compile group: 'com.google.code.gson', name: 'gson', version:'2.3'
+      compile group: 'com.squareup.retrofit', name: 'retrofit'
+           version: '1.9.0'
+     }
+     
+```
+
+### 为你的仓库预定义
+
+为了方便，Gradle会默认预定义三个maven仓库：Jcenter和mavenCentral以及本地maven仓库。你可以同时申明它们：
+
+```
+repositories {
+       mavenCentral()
+       jcenter()
+       mavenLocal()
+   }
+   
+```
+
+Maven和Jcenter仓库是很出名的两大仓库。我们没必要同时使用他们，在这里我建议你们使用jcenter，jcenter是maven中心库的一个分支，这样你可以任意去切换这两个仓库。当然jcenter也支持了https，而maven仓库并没有。
+
+本地maven库是你曾使用过的所有依赖包的集合，当然你也可以添加自己的依赖包。默认情况下，你可以在你的home文件下找到.m2的文件夹。除了这些仓库外，你还可以使用其他的公有的甚至是私有仓库。
+
+
+
+### 远程仓库
+
+有些组织，创建了一些有意思的插件或者library,他们更愿意把这些放在自己的maven库，而不是maven中心库或jcenter。那么当你需要是要这些仓库的时候，你只需要在maven方法中加入url地址就好：
+
+```
+repositories {
+       maven {
+           url "http://repo.acmecorp.com/maven2"
+       }
+}
+```
+
+同样的，Ivy仓库也可以这么做。Apache Ivy在ant世界里是一个很出名的依赖管理工具。如果你的公司有自己的仓库，如果他们需要权限才能访问，你可以这么编写：
+
+```
+repositories {
+       maven {
+           url "http://repo.acmecorp.com/maven2"
+           credentials {
+               username 'user'
+               password 'secretpassword'
+           }
+        } 
+   }
+```
+
+> 注意：这不是一个好主意，最好的方式是把这些验证放在Gradle properties文件里，这些我们已经介绍过在第二章。
+
+## 本地依赖
+
+可能有些情况，你需要手动下载jar包，或者你想创建自己的library，这样你就可以复用在不同的项目，而不必将该library  publish到公有或者私有库。在上述情况下，可能你不需要网络资源，接下来我将介绍如何是使用这些jar依赖，以及如何导入so包，如何为你的项目添加依赖项目。
+
+### 文件依赖
+
+如果你想为你的工程添加jar文件作为依赖，你可以这样：
+
+```
+dependencies {
+       compile files('libs/domoarigato.jar')
+}
+```
+
+如果你这么做，那会很愚蠢，因为当你有很多这样的jar包时，你可以改写为：
+
+```
+dependencies {
+       compile fileTree('libs')
+ }
+ 
+```
+
+默认情况下，新建的Android项目会有一个lib文件夹，并且会在依赖中这么定义（即添加所有在libs文件夹中的jar）：
+
+```
+dependencies {
+       compile fileTree(dir: 'libs', include: ['*.jar'])
+}
+```
+
+这也意味着，在任何一个Android项目中，你都可以把一个jar文件放在到libs文件夹下，其会自动的将其添加到编译路径以及最后的APK文件。
+
+### native包（so包）
+
+用c或者c++写的library会被叫做so包，Android插件默认情况下支持native包，你需要把.so文件放在对应的文件夹中：
+
+```
+app
+   ├── AndroidManifest.xml
+   └── jniLibs
+       ├── armeabi
+       │   └── nativelib.so
+       ├── armeabi-v7a
+       │   └── nativelib.so
+       ├── mips
+       │   └── nativelib.so
+       └── x86
+           └── nativelib.so
+           
+```
+
+## aar文件
+
+如果你想分享一个library,该依赖包使用了Android api，或者包含了Android 资源文件，那么aar文件适合你。依赖库和应用工程是一样的，你可以使用相同的tasks来构建和[测试](http://lib.csdn.net/base/softwaretest)你的依赖工程，当然他们也可以有不同的构建版本。应用工程和依赖工程的区别在于输出文件，应用工程会生成APK文件，并且其可以安装在Android设备上，而依赖工程会生成.aar文件。该文件可以被Android应用工程当做依赖来使用。
+
+### 创建和使用依赖工程模块
+
+不同的是，你需要加不同的插件：
+
+```
+ apply plugin: 'com.android.library'
+ 
+```
+
+我们有两种方式去使用一个依赖工程。一个就是在你的工程里面，直接将其作为一个模块，另外一个就是创建一个aar文件，这样其他的应用也就可以复用了。
+
+如果你把其作为模块，那你需要在settings.gradle文件中添加其为模块：
+
+```
+   include ':app', ':library'
+   
+```
+
+在这里，我们就把它叫做library吧，如果你想使用该模块，你需要在你的依赖里面添加它，就像这样:
+
+```
+   dependencies {
+       compile project(':library')
+  }
+```
+
+### 使用aar文件
+
+如果你想复用你的library，那么你就可以创建一个aar文件，并将其作为你的工程依赖。当你构建你的library项目，aar文件将会在  build/output/aar/下生成。把该文件作为你的依赖包，你需要创建一个文件夹来放置它，我们就叫它aars文件夹吧，然后把它拷贝到该文件夹里面，然后添加该文件夹作为依赖库：
+
+```
+repositories {
+    flatDir {
+        dirs 'aars' 
+    }
+}
+```
+
+这样你就可以把该文件夹下的所有aar文件作为依赖，同时你可以这么干：
+
+```
+ dependencies {
+       compile(name:'libraryname', ext:'aar')
+}
+```
+
+这个会告诉Gradle，在aars文件夹下，添加一个叫做libraryname的文件，且其后缀是aar的作为依赖。
+
+
+
+
+
+
+
+##### 多项目设置
 
 `Gradle`项目通常使用多项目设置来依赖其他的`gradle`项目。例如:      
 
@@ -300,6 +545,7 @@ dependencies {
         - lib1/           
         - lib2/     
         
+
 `Gradle`会通过下面的名字来引用他们：     
 `:app`       
 `:libraries:lib1`          
@@ -317,7 +563,7 @@ dependencies {
             - build.gradle      
         + lib2/      
            - build.gradle      
-       
+    
 
 `setting.gradle`文件中的内容非常简单。它指定了哪个目录是`Gralde`项目:     
 ```
@@ -366,7 +612,7 @@ android {
 `Library`项目的主要输出我`.aar`包。它结合了代码(例如`jar`包或者本地`.so`文件)和资源(`manifest`,`res`,`assets`)。每个`library`也可以单独设置`Build Type`等来指定生成不同版本的`aar`。
 
 ### `Lint Support`
- 
+
 你可以通过指定对应的变量来设置`lint`的运行。可以通过添加`lintOptions`来进行配置:      
 
 ```
@@ -461,7 +707,7 @@ android {
     - `minSdkVersion`: 14       
     - `versionCode`: 10       
     
-   
+
 通常，`Build Type`配置会覆盖其他的配置。例如，`Build Type`的`applicationIdSuffix`会添加到`Product Flavor`的`applicationId`上。
 
 
@@ -518,7 +764,7 @@ android {
     }
 }
 ```
- 
+
 ### `Tasks`控制     
 
 基本的`Java`项目有一系列的`tasks`一起制作输出文件。     
@@ -553,7 +799,7 @@ android {
 ### `Resource Shrinking`    
 
 `Gradle`构建系统支持资源清理：对构建的应用会自动移除无用的资源。不仅会移除项目中未使用的资源，而且还会移除项目所以来的类库中的资源。注意，资源清理只能在与代码清理结合使用(例如`ProGuad`)。这就是为什么它能移除所依赖类库的无用资源。通常，类库中的所有资源都是使用的，只有类库中无用代码被移除后这些资源才会变成没有代码引用的无用资源。    
- 
+
 ```
 android {
     ...
@@ -568,9 +814,883 @@ android {
 }
 ```
 
-[1]: https://github.com/CharonChui/AndroidNote/blob/master/AndroidStudioCourse/AndroidStudio%E4%BD%BF%E7%94%A8%E6%95%99%E7%A8%8B(%E7%AC%AC%E4%B8%83%E5%BC%B9).md       "AndroidStudio使用教程(第七弹)"
 
-		
+
+## Task
+
+在Gradle中有一个原子性的操作叫做task，简单理解为task是Gradle脚本中最小可执行单元。
+
+在build.gradle里可以通过task关键字来创建Task。
+
+例如，可以在build.gradle中创建2个task:   
+
+```groovy
+task helloWorld {
+    println "Hello World"
+}
+task myTask2 {
+    println "configure task2"
+}
+```
+
+在命令行里执行命令: gradle helloWorld： 
+
+```
+Hello World
+configure task2
+```
+
+我们会发现当我们执行helloWorld时，task2的代码也被执行了。括号内部的代码我们称之为配置代码，在gradle脚本的配置阶段都会执行，也就是说不管执行脚本里的哪个任务，所有task里的配置代码都会执行。
+
+这与我们期望的不一致，通常我们写程序时调用一个方法，这个方法里的代码才会执行，那么我们执行一个task时，这个task里的代码才会被执行才对。显然Gradle里的不一样，这个问题就设计到Task Action的概念。 
+
+
+
+## Task Action
+
+一个Task由一系列Action组成，当运行一个Task的时候，这个Task里的Action序列会按顺序依次执行。
+
+前面例子中括号里的代码只是配置代码，它们并不是Action，Task里的Action只会在该Task真正运行时执行，Gradle里通过doFirst、doLast来为Task增加Action。
+
+- doFirst: task执行时最先执行的操作
+- doLast: task执行时最后执行的操作
+
+```
+task myTask1 {
+    println "configure task1"
+}
+task myTask2 {
+    println "configure task2"
+}
+myTask1.doFirst {
+    println "task1 doFirst"
+}
+myTask1.doLast {
+    println "task1 doLast"
+}
+myTask2.doLast {
+    println "task2 doLast"
+}
+```
+
+同样运行gradle myTask1，来执行myTask1，这次的结果如下:  
+
+```
+configure task1
+configure task2
+
+task1 doFirst
+task1 doLast
+```
+
+可以看到所有Task的配置代码都会运行，而Task Action则只有该Task运行时才会执行。 
+
+doLast有一种等价操作叫做leftShift，leftShift可以缩写为<<，下面几种写法效果是一模一样的:   
+
+```
+myTask1.doLast {
+    println "task1 doLast"
+}
+myTask1 << {
+    println "task1 doLast <<"
+}
+myTask1.leftShift {
+    println "task1 doLast leftShift"
+}
+```
+
+<<操作符只是一种Gradle里的语法糖
+
+## Extension
+
+先来看一段Android应用的Gradle配置代码:  
+
+```groovy
+android {
+    compileSdkVersion 26
+    defaultConfig {
+        applicationId "xxx"
+        minSdkVersion 19
+        targetSdkVersion 26
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+}
+```
+
+上面这个android打包配置就是Gradle的Extension，翻译成中文的意思就是扩展。它的作用就是通过实现自定义的Extension，可以在Gradle脚本中增加类似android这样命名空间的配置，Gradle可以识别这种配置，并读取里面的配置内容。 
+
+每个Extension实际上都会与某个类相关联，在build.gradle中通过DSL来定义，Gradle会识别解析并生成一个对象实例，通过该类可以获取我们所配置的信息。
+
+```groovy
+outer {
+    outerName "outer"
+    msg "this is a outer message."
+
+    inner {
+        innerName "inner"
+        msg "This is a inner message."
+    }
+}
+```
+
+形式上就是外面的Extension里面定义了另一个Extension，这种叫做nested Extension，也就是嵌套的 Extension。
+
+## Project详解
+
+每一个build.gradle脚本文件被Gradle加载解析后，都会生成一个对应的Project对象，在脚本中的配置方法其实都对应着Project中的API，如果想详细了解这些脚本的配置含义，有必要对Project类进行深入的了解。 
+
+
+
+### Project类图
+
+当构建进程启动后，Gradle基于build.gradle中的配置实例化org.gradle.api.Project类:  
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/build_gradle_project.png?raw=true)
+
+#### 构建脚本配置
+
+##### buildscript
+
+配置该Project的构建脚本的classpath，在Android Studio中的root project中可以看到:  
+
+```groovy
+buildscript {
+    repositories {
+        google()
+        jcenter()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:3.0.1'
+    }
+}
+```
+
+
+
+##### apply
+
+```groovy
+apply(options: Map<String, ?>)
+```
+
+我们通过该方法使用插件或者是其他脚本，options里主要选项有：
+
+- from： 使用其他脚本，值可以为Project.uri(Object) 支持的路径
+- plugin：使用其他插件，值可以为插件id或者是插件的具体实现类
+
+例如：
+
+```groovy
+//使用插件，com.android.application 就是插件id
+apply plugin: 'com.android.application'
+//使用插件，MyPluginImpl 就是一个Plugin接口的实现类
+apply plugin: MyPluginImpl
+
+//引用其他gradle脚本，push.gradle就是另外一个gradle脚本文件
+apply from: './push.gradle'
+```
+
+### Gradle属性
+
+
+
+在与build.gradle文件同级目录下，定义一个名为gradle.properties的文件，里面定义的键值对，可以在Project中直接访问:  
+
+```groovy
+// gradle.properties
+username="xxx"
+password="yyy"
+```
+
+在build.gradle文件里可以直接访问:  
+
+```groovy
+println "username = ${username}"
+println "password = ${password}"
+```
+
+### 扩展属性
+
+
+
+在一个build.gradle里，可以通过变量定义来实现相关字符串的替换，比如：
+
+    apply plugin: 'com.android.application'
+     
+    def mCompileSdkVersion = 28
+    def libAndroidAppcompat = 'com.android.support:appcompat-v7:28.0.0'
+    android {
+        compileSdkVersion mCompileSdkVersion
+    }
+     
+    dependencies {
+        implementation libAndroidAppcompat
+    }
+
+gradle支持扩展属性，通过扩展属性也可以达到上述的目的：
+
+    apply plugin: 'com.android.application'
+     
+    // 扩展属性
+    ext {
+        compileSdkVersion = 28
+        libAndroidAppcompat = 'com.android.support:appcompat-v7:28.0.0'
+    }
+     
+    android {
+        compileSdkVersion this.compileSdkVersion
+    }
+     
+    dependencies {
+        implementation this.libAndroidAppcompat
+    }
+
+为每个子工程配置扩展属性，在根build.gradle中添加如下代码，子工程相关配置删除。
+
+    subprojects {
+        ext {
+            compileSdkVersion = 28
+            libAndroidAppcompat = 'com.android.support:appcompat-v7:28.0.0'
+        }
+    }
+
+上述方法相当于每个子project定义了扩展属性，如果想定义一份，需要把根build.gradle改成如下：
+
+    ext {
+        compileSdkVersion = 28
+        libAndroidAppcompat = 'com.android.support:appcompat-v7:28.0.0'
+    }
+
+子工程build.gradle改成如下：
+
+    apply plugin: 'com.android.application'
+     
+    android {
+        compileSdkVersion this.rootProject.compileSdkVersion
+    }
+     
+    dependencies {
+        implementation this.rootProject.libAndroidAppcompat
+    }
+
+如果把rootProject去掉，也是可以的
+
+    apply plugin: 'com.android.application'
+     
+    android {
+        compileSdkVersion this.compileSdkVersion
+    }
+     
+    dependencies {
+        implementation this.libAndroidAppcompat
+    }
+
+gradle规定，父project所有的属性都会被根project继承，所以可以直接在子project使用父project的属性。
+可以把所有的扩展属性定义到一个独立的gradle文件中，在需要使用的build.gradle文件中使用apply from进行引入。
+
+```
+apply from : file('common.gradle')
+```
+
+修改根目录build.gradle文件如下:  
+
+```groovy
+println "-----root file config-----"
+
+//配置 app 项目
+project(":app") {
+    ext {
+        appParam = "test app"
+    }
+}
+
+//配置所有的项目
+allprojects {
+    ext {
+        allParam = "test all project"
+    }   
+}
+
+//配置子项目
+subprojects {
+    ext {
+        subParam = "test sub project"
+    }
+}
+
+println "allParam = ${allParam}"
+```
+
+
+
+
+
+还可以通过ext命名空间来定义属性，我们称之为扩展属性。 
+
+```groovy
+ext {
+  username = "hjy"
+  age = 30
+}
+
+println username
+println ext.age
+println project.username
+println project.ext.age
+```
+
+必须注意，默认的扩展属性，只能定义在 ext 命名空间下面。对扩展属性的访问方式，以上几种都支持。
+
+
+
+如果你有新建一个kotlin项目的经历，那么你将看到Google推荐的方案
+
+```
+buildscript {
+    ext.kotlin_version = '1.1.51'
+    repositories {
+        google()
+        jcenter()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:3.0.0'
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+```
+
+在rootProject的build.gradle中使用**ext**来定义版本号全局变量。这样我们就可以在module的build.gradle中直接引用这些定义的变量。引用方式如下：
+
+```
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation"org.jetbrains.kotlin:kotlin-stdlib-jre7:$kotlin_version"
+}
+```
+
+你可以将这些变量理解为java的静态变量。通过这种方式能够达到不同module中的配置统一，但局限性是，一但配置项过多，所有的配置都将写到rootProject项目的build.gradle中，导致build.gradle臃肿。这不符合我们的所提倡的模块开发，所以应该想办法将ext的配置单独分离出来。
+
+这个时候我就要用到之前的文章[Android Gradle系列-原理篇](https://mp.weixin.qq.com/s?__biz=MzIzNTc5NDY4Nw==&mid=2247483834&idx=1&sn=55264aaad1f018b55280beec93ed4cac&chksm=e8e0f82adf97713c5a43c67b67fbabd659578328a22a406c5a01bd69ccf550e88bf645b15457&token=330677494&lang=zh_CN#rd)中所介绍的apply函数。之前的文章我们只使用了apply三种情况之一的plugin(应用一个插件，通过id或者class名)，只使用在子项目的build.gradle中。
+
+```
+apply plugin: 'com.android.application'
+```
+
+这次我们需要使用它的**from**，它主要是的作用是**应用一个脚本文件**。作用接下来我们需要做的是将ext配置单独放到一个gradle脚本文件中。
+
+首先我们在rootProject目录下创建一个gradle脚本文件，我这里取名为version.gradle。
+
+然后我们在version.gradle文件中使用ext来定义变量。例如之前的kotlin版本号就可以使用如下方式实现
+
+```
+ext.deps = [:]
+ 
+def versions = [:]
+versions.support = "26.1.0"
+versions.kotlin = "1.2.51"
+versions.gradle = '3.2.1'
+ 
+def support = [:]
+support.app_compat = "com.android.support:appcompat-v7:$versions.support"
+support.recyclerview = "com.android.support:recyclerview-v7:$versions.support"
+deps.support = support
+ 
+def kotlin = [:]
+kotlin.kotlin_stdlib = "org.jetbrains.kotlin:kotlin-stdlib-jre7:$versions.kotlin"
+kotlin.plugin = "org.jetbrains.kotlin:kotlin-gradle-plugin:$versions.kotlin"
+deps.kotlin = kotlin
+ 
+deps.gradle_plugin = "com.android.tools.build:gradle:$versions.gradle"
+ 
+ext.deps = deps
+ 
+def build_versions = [:]
+build_versions.target_sdk = 26
+build_versions.min_sdk = 16
+build_versions.build_tools = "28.0.3"
+ext.build_versions = build_versions
+ 
+def addRepos(RepositoryHandler handler) {
+    handler.google()
+    handler.jcenter()
+    handler.maven { url 'https://oss.sonatype.org/content/repositories/snapshots' }
+}
+ext.addRepos = this.&addRepos
+```
+
+> 因为gradle使用的是groovy语言，所以以上都是groovy语法
+
+例如kotlin版本控制，上面代码的意思就是将有个kotlin相关的版本依赖放到deps的kotlin变量中，同时deps放到了ext中。其它的亦是如此。
+
+既然定义好了，现在我们开始引入到项目中，为了让所有的子项目都能够访问到，我们使用**apply from**将其引入到rootProject的build.gradle中
+
+```
+buildscript {
+    apply from: 'versions.gradle'
+    addRepos(repositories)
+    dependencies {
+        classpath deps.gradle_plugin
+        classpath deps.kotlin.plugin
+    }
+}
+```
+
+这时build.gradle中就默认有了ext所声明的变量，使用方式就如dependencies中的引用一样。
+
+我们再看上面的addRepos方法，在关于Gradle原理的文章中已经分析了repositories会通过RepositoryHandler来执行，所以这里我们直接定义一个方法来统一调用RepositoryHandler。这样我们在build.gradle中就无需使用如下方式，直接调用addRepos方法即可
+
+```
+    //之前调用
+    repositories {
+        google()
+        jcenter()
+    }
+    //现在调用
+    addRepos(repositories)
+```
+
+另一方面，如果有多个module，例如有module1，现在就可以直接在module1中的build.gradle中使用定义好的配置
+
+```
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    // support
+    implementation deps.support.app_compat
+    //kotlin
+    implementation deps.kotlin.kotlin_stdlib
+}
+```
+
+上面我们还定义了sdk与tools版本，所以也可以一起统一使用，效果如下
+
+```
+android {
+    compileSdkVersion build_versions.target_sdk
+    buildToolsVersion build_versions.build_tools
+    defaultConfig {
+        applicationId "com.idisfkj.androidapianalysis"
+        minSdkVersion build_versions.min_sdk
+        targetSdkVersion build_versions.target_sdk
+        versionCode 1
+        versionName "1.0"
+        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
+    }
+    ...
+}
+```
+
+一旦实现了统一配置，那么之后我们要修改相关的版本就只需在我们定义的version.gradle中修改即可。无需再对所用的module进行逐一修改与统一配置。
+
+
+
+扩展属性也可以定义在gradle.properties中，在这个文件中只能定义key-value形式的扩展属性，而不能使用类似Map方式的定义，在使用上有一定的限制。
+下面通过在gradle.properties定义开关控制一个模块是否引入项目中，在gradle.properties中定义：
+
+isLoadTest = false
+
+setting.gradle：
+
+    include ':app', ':module1', ':module2'
+    if(hasProperty('isLoadTest') ? isLoadTest.toBoolean() : false) {
+        include 'test'
+    }
+
+所以gradle.properties也可以定义扩展属性，在使用的时候转换成对应的类型。
+例如在gradle.properties定义：
+
+mCompileSdkVersion = 28
+
+使用的时候：
+
+compileSdkVersion mCompileSdkVersion.toInteger()
+
+在gradle.properties定义的属性不能和build.gradle已经存在的方法同名，否则编译的时候不报错，但是在使用时会提示属性找不到。
+
+
+
+### 多模块构建的结构
+
+通常情况下，一个工程包含多模块，这些模块会在一个父目录文件夹下。为了告诉gradle，该项目的结构以及哪一个子文件夹包含模块，你需要提供一个settings.gradle文件。每个模块可以提供其独立的build.gradle文件。我们已经学习了关于setting.gradle和build.gradle如何正常工作，现在我们只需要学习如何使用它们。
+
+这是多模块项目的结构图：
+
+```
+ project
+   ├─── setting.gradle
+   ├─── build.gradle
+   ├─── app
+   │    └─── build.gradle
+   └─── library
+        └─── build.gradle
+        
+```
+
+这是最简单最直接的方式来创建你的多模块项目了。setting.gradle文件申明了该项目下的所有模块，它应该是这样：
+
+```
+include ':app', ':library'
+```
+
+这保证了app和library模块都会包含在构建配置中。你需要做的仅仅只是为你的模块添加子文件夹。
+
+为了在你的app模块中添加library模块做为其依赖包，你需要在app的build.gradle文件中添加以下内容：
+
+```
+dependencies {
+      compile project(':library') 
+}
+```
+
+为了给app添加一个模块作为依赖，你需要使用project()方法，该方法的参数为模块路径。
+
+如果在你的模块中还包含了子模块，gradle可以满足你得要求。举个栗子，你可以把你的目录结构定义为这样：
+
+```
+project
+├─── setting.gradle
+├─── build.grade
+├─── app
+│    └─── build.gradle
+└─── libraries
+     ├─── library1
+     │    └─── build.gradle
+     └─── library2
+          └─── build.gradle
+          
+```
+
+该app模块依然位于根目录，但是现在项目有2个不同的依赖包。这些依赖模块不位于项目的根目录，而是在特定的依赖文件夹内。根据这一结构，你需要在settings.xml中这么定义：
+
+```
+include ':app', ':libraries:library1', ':libraries:library2'
+```
+
+你会注意到在子目录下申明模块也非常的容易。所有的路径都是围绕着根目录，即当你添加一个位于子文件夹下的模块作为另外一个模块的依赖包得实惠，你应该将路径定为根目录。这意味着如果在上例中app模块想要依赖library1,build.gradle文件需要这么申明：
+
+```
+dependencies {
+       compile project(':libraries:library1')
+}
+```
+
+如果你在子目录下申明了依赖，所有的路径都应该与根目录相关。这是因为gradle是根据你的项目的根目录来定义你的依赖包的。
+
+
+
+## 构建的三个构建阶段
+
+1. Initialization：配置构建环境以及有哪些Project会参与构建（解析settings.build）
+2. Configuration：生成参与构建的Task的有向无环图以及执行属于配置阶段的代码（解析build.gradle）
+3. Execution：按序执行所有Task
+
+在第一步骤中，即初始化阶段，gradle会寻找到settings.grade文件。如果该文件不存在，那么gradle就会假定你只有一个单独的构建模块。如果你有多个模块，settings.gradle文件定义了这些模块的位置。如果这些子目录包含了其自己的build.gradle文件，gradle将会运行它们，并且将他们合并到构建任务中。这就解释了为什么你需要申明在一个模块中申明的依赖是相对于根目录。
+
+一旦你理解了构建任务是如何将所有的模块聚合在一起的时候，那关于几种不同的构建多模块策略就会变得简单易懂。你可以配置所有的模块在根目录下的build.gradle。这让你能够简单的浏览到整个项目的配置，但是这将会变得一团乱麻，特别是当你的模块需要不同的插件的时候。另外一种方式是将每个模块的配置分隔开，这一策略保证了每个模块之间的互不干扰。这也让你跟踪构建的改变变得容易，因为你不需要指出哪个改变导致了哪个模块出现错误等。
+
+
+
+#### 为你的项目添加模块
+
+
+
+#### 添加Java依赖库
+
+当你新建了一个Java模块，build.grade文件会是这样：
+
+```
+apply plugin: 'java'
+   dependencies {
+       compile fileTree(dir: 'libs', include: ['*.jar'])
+}
+    
+```
+
+Java模块使用了Java插件，这意味着很多Android特性在这儿不能使用，因为你不需要。
+
+build文件也有基本的库管理，你可以添加jar文件在libs文件夹下。你可以添加更多的依赖库，根据第三章的内容。
+
+给你的app模块添加Java模块，这很简单，不是吗？
+
+```
+dependencies {
+       compile project(':javalib')
+}
+```
+
+这告诉了gradle去引入一个叫做javelin的模块吧，如果你为你的app模块添加了这个依赖，那么javalib模块将会总是在你的app模块构建之前构建。
+
+#### 添加Android依赖库
+
+同样的，我们利用Android studio的图形化界面创建Android模块，然后其构建文件如下：
+
+```
+apply plugin: 'com.android.library'
+```
+
+记住：Android依赖库不仅仅包含了Java代码，同样也会包含Android资源，像manifest和strings,layout文件，在你引入该模块后，你可以使用该模块的所有类和资源文件。
+
+
+
+
+
+## Groovy
+
+在Java中，打印一天String应该是这样的：
+
+```
+System.out.println("Hello, world!");
+```
+
+在Groovy中，你可以这么写：
+
+```
+println 'Hello, world!'
+```
+
+你应该主要到几点不同之处：
+
+- 没有了System.out
+- 没有了方括号
+- 列结尾没有了；
+
+这个例子同样使用了单引号，你可以使用双引号或者单引号，但是他们有不同的用法。双引号可以包含插入语句。插入是计算一个字符串包含placeholders的过程，并将placeholders的值替换，这些placeholder可以是变量甚至是方法。Placeholders必须包含一个方法或者变量，并且其被{}包围，且其前面有$修饰。如果其只有一个单一的变量，可以只需要$。下面是一些基本的用法：
+
+```
+def name = 'Andy'
+def greeting = "Hello, $name!"
+def name_size "Your name is ${name.size()} characters long."
+```
+
+greeting应该是“ Hello，Andy”，并且 name_size 为 Your name is 4 characters long.string的插入可以让你更好的动态执行代码。比如
+
+```
+ def method = 'toString'
+ new Date()."$method"()
+```
+
+这在Java中看起来很奇怪，但是这在groovy里是合法的。
+
+
+
+Groovy里面创建类和Java类似，举个例子：
+
+```
+class MyGroovyClass {
+       String greeting
+       String getGreeting() {
+           return 'Hello!'
+        } 
+}
+```
+
+注意到不论是类名还是成员变量都没有修饰符。其默认的修饰符是类和方法为public，成员变量为private。
+
+当你想使用MyGroovyClass，你可以这样实例化：
+
+```
+def instance = new MyGroovyClass()
+instance.setGreeting 'Hello, Groovy!'
+instance.getGreeting()   
+```
+
+你可以利用def去创建变量，一旦你为你的类创建了实例，你就可以操作其成员变量了。get/set方法groovy默认为你添加 。你甚至可以覆写它。
+
+如果你想直接使用一个成员变量，你可以这么干：
+
+```
+ println instance.getGreeting()
+ println instance.greeting
+ 
+```
+
+而这二种方式都是可行的。
+
+### 方法
+
+和变量一样，你不必定义为你的方法定义返回类型。举个例子，先看java：
+
+```
+public int square(int num) {
+       return num * num;
+} 
+square(2);
+```
+
+你需要将该方法定义为public，需要定义返回类型，以及入参，最后你需要返回值。
+
+我们再看下Groovy的写法：
+
+```
+ def square(def num) {
+       num * num
+ }
+ square 4
+ 
+```
+
+没有了返回类型，没有了入参的定义。def代替了修饰符，方法体内没有了return关键字。然而我还是建议你使用return关键字。当你调用该方法时，你不需要括号和分号。
+
+我们设置可以写的更简单点：
+
+```
+def square = { num ->
+       num * num
+}
+square 8
+```
+
+下面我将通过code的形式，列出几点
+
+- 当调用的方法有参数时，可以不用()，看下面的例子
+
+
+
+
+
+```
+ 1def printAge(String name, int age) {
+ 2    print("$name is $age years old")
+ 3}
+ 4
+ 5def printEmptyLine() {
+ 6    println()
+ 7}
+ 8
+ 9def callClosure(Closure closure) {
+10    closure()
+11}
+12
+13printAge "John", 24 //输出John is 24 years old
+14printEmptyLine() //输出空行
+15callClosure { println("From closure") } //输出From closure
+```
+
+
+
+- 如果最后的参数是闭包，可以将它写在括号的外面
+
+
+
+```
+1def callWithParam(String param, Closure<String> closure) {
+2    closure(param)
+3}
+4
+5callWithParam("param", { println it }) //输出param
+6callWithParam("param") { println it } //输出param
+7callWithParam "param", { println it } //输出param
+```
+
+
+
+- 调用方法时可以指定参数名进行传参，有指定的会转化到Map对象中，没有的将按正常传参
+
+
+
+```
+ 1def printPersonInfo(Map<String, Object> person) {
+ 2    println("${person.name} is ${person.age} years old")
+ 3}
+ 4
+ 5def printJobInfo(Map<String, Object> job, String employeeName) {
+ 6    println("${employeeName} works as ${job.name} at ${job.company}")
+ 7}
+ 8
+ 9printPersonInfo name: "Jake", age: 29
+10printJobInfo "Payne", name: "Android Engineer", company: "Google"
+```
+
+你会发现他们的调用都不需要括号，同时printJobInfo的调用参数的顺序不受影响。
+
+
+
+
+
+### 闭包
+
+闭包是一段匿名的方法体，其可以接受参数和返回值。它们可以定义变量或者可以将参数传给方法。
+
+你可以简单的使用方括号来定义闭包，如果你想详细点，你也可以这么定义：
+
+```
+Closure square = {
+       it * it
+}
+square 16
+```
+
+添加了Closure，让其更加清晰。注意，当你没有显式的为闭包添加一个参数，groovy会默认为你添加一个叫做it。你可以在所有的闭包中使用it，如果调用者没有定义任何参数，那么it将会是null，这会使得你的代码更加简洁。
+
+在grade中，我们经常使用闭包，例如Android代码体和dependencies也是。
+
+### Collections
+
+在groovy中，有二个重要的容器分别是lists和maps。
+
+创建一个list很容易，我们不必初始化：
+
+```
+List list = [1, 2, 3, 4, 5]
+```
+
+为list迭代也很简单，你可以使用each方法：
+
+```
+list.each() { element ->
+       println element
+}
+```
+
+你甚至可以使得你的代码更加简洁，使用it:
+
+```
+list.each() {
+       println it
+}
+```
+
+map和list差不多：
+
+```
+Map pizzaPrices = [margherita:10, pepperoni:12]
+```
+
+如果你想取出map中的元素，可以使用get方法：
+
+```
+pizzaPrices.get('pepperoni')
+pizzaPrices['pepperoni']
+```
+
+同样的groovy有更简单的方式：
+
+```
+pizzaPrices.pepperoni
+```
+
+
+
+[1]: https://github.com/CharonChui/AndroidNote/blob/master/AndroidStudioCourse/AndroidStudio%E4%BD%BF%E7%94%A8%E6%95%99%E7%A8%8B(%E7%AC%AC%E4%B8%83%E5%BC%B9).md       "AndroidStudio使用教程(第七弹)"
+
+
+
+
+
+
+
+
+
+
+
+
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
diff --git "a/ImageLoaderLibrary/Coil\347\256\200\344\273\213.md" "b/ImageLoaderLibrary/Coil\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..940d93b0
--- /dev/null
+++ "b/ImageLoaderLibrary/Coil\347\256\200\344\273\213.md"
@@ -0,0 +1,62 @@
+# Coil简介
+
+Coil作为图片加载库的新秀，和Glide、Picasso这些老牌图片库相比，它们的优缺点是什么以及Coil未来的展望？先来了解一下什么是Coil。
+
+Coil是基于Kotlin开发的首个图片加载库，来自Instacart团队，来看看官网对它的最新的介绍。
+
+- R8:Coil下完全兼容R8，所以不需要添加任何与Coil相关的混淆器规则。
+- Fast:Coil进行了许多优化，包括内存和磁盘缓存，对内存中的图片进行采样，重新使用位图，自动暂停/取消请求等等。
+- Lightweight:Coil为你的APK增加了2000个方法(对于已经使用了OkHttp和协程的应用程序)，这与Picasso相当，明显少于Glide和Fresco。
+- Easy to use:Coil利用了Kotlin的语言特性减少了样版代码。
+- Modern:使用了大量的高级特性，例如协程、OkHttp、和androidX lifecycle跟踪生命周期状态的，Coil是目前唯一支持androidX lifecycle的库。
+
+Coil作为图片库的新秀，越来越受欢迎了，但是为什么会引起这么多人的关注？在当今主流的图片加载库环境中Coil是一股清流，它是轻量级的，因为它使用了许多Android开发者已经在他们的项目中包含的其他库（协程、Okhttp）。
+
+当我第一次看到这个库时，我认为这些都是很好的改进，但是我很想知道和其他主流的图片加载库相比，这个库能带来哪些好处，这篇文章的主要目的是分析一下Coil的性能，接下来我们来对比一下Coil、Glide和Picasso。
+
+作者从以下场景对Coil、Glide、Picasso做了全面的测试。
+
+- 当缓存为空时，从网络中下载图片的平均时间。
+
+    - 从网络中下载图片所用的时间。
+
+    结果:Glide最快Picasso和Coil几乎相同。
+
+    - 加载完整的图片列表所用的时间，以及平均时间。
+
+    结果:Glide是最快的，其次是Picasso，Coil是最慢的。
+
+- 当缓存不为空时，从缓存中加载图片的平均时间。
+
+    - 从缓存中加载图片所用的时间。
+
+    结果:Glide最快，Coil其次，Picasso最慢。
+
+    - 加载完整的图片列表所用的时间，以及平均时间。
+
+    结果:Glide和Coil几乎相同，Picasso是最慢的。
+
+图片加载库的选择是我们应用程序中最重要的部分之一，根据以上结果，如果你的应用程序中没有大量使用图片的时候，我认为使用Coil更好，原因有以下几点：
+
+- 与Glide和Fresco类似，Coil支持位图池，位图池是一种重新使用不再使用的位图对象的技术，这可以显著提高内存性能(特别是在oreo之前的设备上)，但是它会造成一些API限制。
+- Coil是基于Kotlin开发的，为Kotlin使用而设计的，所以代码通常更简洁更干净。
+- Kotlin作为Android首选语言，Coil是为Kotlin而设计的，Coil在未来肯定会大方光彩。
+- 从Glide、Picasso迁移到Coil是非常的容易，API非常的相似。
+- Coil支持androidX lifecycle跟踪生命周期状态，也是是目前唯一支持androidX lifecycle的网络图片加载库。
+- Coil支持动态图片采样，假设本地有一个500x500的图片，当从磁盘读取500x500的映像时，我们将使用100x100的映像作为占位符。
+
+如果你的是图片类型的应用，应用程序中包含了大量的图片，图片加载的速度是整个应用的核心指标之一，那么现在还不适合使用Coil。
+
+Coil涵盖了Glide、Picasso等等图片加载库所支持的功能，除此之外Coil还有一个功能动态图片采样。
+
+### 动态图片采样
+
+更多关于图片采样信息可以访问[Coil](https://coil-kt.github.io/coil/getting_started/) ，这里简单的说明一下，假设本地有一个500x500的图片，当从磁盘读取500x500的图片时，将使用100x100的映像作为占位符，等待加载完成之后才会完全显示。
+
+
+
+
+
+# 参考: 
+
+- [Coil vs Picasso vs Glide: Get Ready… Go!](https://proandroiddev.com/coil-vs-picasso-vs-glide-get-ready-go-774add8cfd40)
diff --git "a/Jetpack/architecture/10.DataStore\347\256\200\344\273\213.md" "b/Jetpack/architecture/10.DataStore\347\256\200\344\273\213.md"
index 52988774..f465ab8b 100644
--- "a/Jetpack/architecture/10.DataStore\347\256\200\344\273\213.md"
+++ "b/Jetpack/architecture/10.DataStore\347\256\200\344\273\213.md"
@@ -1,21 +1,83 @@
 # 10.DataStore简介
 
-Jetpack DataStore 是一种数据存储解决方案，允许您使用[协议缓冲区](https://developers.google.com/protocol-buffers)存储键值对或类型化对象。DataStore 使用 Kotlin 协程和 Flow 以异步、一致的事务方式存储数据。
+Jetpack DataStore是一种数据存储解决方案，允许您使用[协议缓冲区](https://developers.google.com/protocol-buffers)存储键值对或类型化对象。DataStore使用Kotlin协程和Flow以异步、一致的事务方式存储数据。
 
-如果您当前在使用 [`SharedPreferences`](https://developer.android.com/reference/kotlin/android/content/SharedPreferences) 存储数据，请考虑迁移到 DataStore。
+如果您当前在使用 [`SharedPreferences`](https://developer.android.com/reference/kotlin/android/content/SharedPreferences) 存储数据，请考虑迁移到DataStore。
 
-**注意**：如果您需要支持大型或复杂数据集、部分更新或参照完整性，请考虑使用 [Room](https://developer.android.com/training/data-storage/room)，而不是 DataStore。DataStore 非常适合简单的小型数据集，不支持部分更新或参照完整性。
+**注意**：如果您需要支持大型或复杂数据集、部分更新或参照完整性，请考虑使用 [Room](https://developer.android.com/training/data-storage/room)，而不是 DataStore。DataStore非常适合简单的小型数据集，不支持部分更新或参照完整性。
 
-## Preferences DataStore 和 Proto DataStore
+## Preferences DataStore和Proto DataStore
 
-DataStore 提供两种不同的实现：Preferences DataStore 和 Proto DataStore。
+DataStore提供两种不同的实现:Preferences DataStore和Proto DataStore。
 
-- **Preferences DataStore** 像SharedPreferences一样，以键值对的形式进行基本类型的数据存储。DataStore 基于 Flow 实现异步存储，避免因为阻塞主线程带来的ANR问题
-- **Proto DataStore** 基于Protobuf实现任意自定义类型的数据存储，需要定义Protobuf的IDL，但是可以保证类型安全的访问
+- **Preferences DataStore**像SharedPreferences一样，以键值对的形式进行基本类型的数据存储。DataStore基于Flow实现异步存储，避免因为阻塞主线程带来的ANR问题
+- **Proto DataStore**基于Protobuf实现任意自定义类型的数据存储，需要定义Protobuf的IDL，但是可以保证类型安全的访问。存储类的对象（typed objects ），通过protocol buffers将对象序列化存储在本地，protocol buffers现在已经应用的非常广泛，无论是微信还是阿里等等大厂都在使用。
 
 
 
-如需在您的应用中使用 Jetpack DataStore，请根据您要使用的实现向 Gradle 文件添加以下内容：
+## SharedPreferences的缺点
+
+SharedPreference是一个轻量级的数据存储方式，使用起来也非常方便，以键值对的形式存储在本地，初始化SharedPreference的时候，会将整个文件内容加载内存中，因此会带来以下问题：
+
+- 通过`getXXX()`方法获取数据，可能会导致主线程阻塞
+
+    所有getXXX()方法都是同步的，在主线程调用get方法，必须等待SharedPreference加载完毕，会导致主线程堵塞。
+
+- SharedPreference不能保证类型安全
+
+    调用getXXX()方法的时候，可能会出现ClassCastException异常，因为使用相同的key进行操作的时候，putXXX()方法可以使用不同类型的数据覆盖相同的key。
+
+- SharedPreference 加载的数据会一直留在内存中，浪费内存
+
+    通过getSharedPreferences()方法加载的数据，最后会将数据存储在静态的成员变量中。
+
+- `apply()`方法虽然是异步的，但是可能会发生ANR，在8.0之前和8.0之后实现各不相同
+    `apply()`方法是异步的，本身是不会有任何问题，但是当生命周期处于`handleStopService()`、`handlePauseActivity()`、`handleStopActivity()`的时候会一直等待`apply()`方法将数据保存成功，否则会一直等待，从而阻塞主线程造成ANR。
+
+- `apply()`方法无法获取到操作成功或者失败的结果
+
+    `apply()`方法无法获取到操作成功或者失败的结果，而`commit()`方法是可以接收MemoryCommitResult里面的一个boolean参数作为结果
+
+- SP不能用于跨进程通信
+
+    我们在创建SP实例的时候，需要传入一个`mode`，如下所示：
+
+    ```
+    val sp = getSharedPreferences("ByteCode", Context.MODE_PRIVATE) 
+    ```
+
+    Context内部还有一个`mode`是`MODE_MULTI_PROCESS`，我们来看一下这个`mode`做了什么
+
+    ```
+    public SharedPreferences getSharedPreferences(File file, int mode) {
+        if ((mode & Context.MODE_MULTI_PROCESS) != 0 ||
+            getApplicationInfo().targetSdkVersion < android.os.Build.VERSION_CODES.HONEYCOMB) {
+            // 重新读取 SP 文件内容
+            sp.startReloadIfChangedUnexpectedly();
+        }
+        return sp;
+    }
+    ```
+
+    在这里就做了一件事，当遇到`MODE_MULTI_PROCESS`的时候，会重新读取SP文件内容，并不能用SP来做跨进程通信。
+
+
+
+## DataStore的优点
+
+Preferences DataStore主要用来替换SharedPreferences，Preferences DataStore解决了SharedPreferences带来的所有问题
+
+**Preferences DataStore相比于SharedPreferences优点: **
+
+- DataStore是基于Flow实现的，所以保证了在主线程的安全性
+- 以事务方式处理更新数据，事务有四大特性（原子性、一致性、 隔离性、持久性）
+- 没有`apply()`和`commit()`等等数据持久的方法
+- 自动完成SharedPreferences迁移到DataStore，保证数据一致性，不会造成数据损坏
+- 可以监听到操作成功或者失败结果
+
+
+
+如需在您的应用中使用Jetpack DataStore，请根据您要使用的实现向Gradle文件添加以下内容：
 
 ```groovy
 // Preferences DataStore (SharedPreferences like APIs)
@@ -34,72 +96,144 @@ dependencies {
 }
 ```
 
+**注意**：如果您需要支持大型或复杂数据集、部分更新或参照完整性，请考虑使用 [Room](https://developer.android.com/training/data-storage/room)，而不是DataStore。DataStore非常适合简单的小型数据集，不支持部分更新或参照完整性。
 
 
 
 
-Jetpack DataStore 是一种数据存储解决方案，允许您使用[协议缓冲区](https://developers.google.com/protocol-buffers)存储键值对或类型化对象。DataStore 使用 Kotlin 协程和 Flow 以异步、一致的事务方式存储数据。
 
-如果您当前在使用 [`SharedPreferences`](https://developer.android.com/reference/kotlin/android/content/SharedPreferences) 存储数据，请考虑迁移到 DataStore。
+## 使用Preferences DataStore存储键值对
 
-**注意**：如果您需要支持大型或复杂数据集、部分更新或参照完整性，请考虑使用 [Room](https://developer.android.com/training/data-storage/room)，而不是 DataStore。DataStore 非常适合简单的小型数据集，不支持部分更新或参照完整性。
+Preferences DataStore实现使用[DataStore](https://developer.android.com/reference/kotlin/androidx/datastore/core/DataStore)和[Preferences](https://developer.android.com/reference/kotlin/androidx/datastore/preferences/core/Preferences) 类将简单的键值对保留在磁盘上。
 
-## Preferences DataStore 和 Proto DataStore
+### 创建Preferences DataStore
 
-DataStore 提供两种不同的实现：Preferences DataStore 和 Proto DataStore。
+使用由[preferencesDataStore](https://developer.android.com/reference/kotlin/androidx/datastore/preferences/package-summary#dataStore) 创建的属性委托来创建Datastore<Preferences>实例。在您的Kotlin文件顶层调用该实例一次，便可在应用的所有其余部分通过此属性访问该实例。这样可以更轻松地将DataStore保留为单例。
+
+```
+// At the top level of your kotlin file
+val Context.dataStore: DataStore<Preferences> by preferencesDataStore(name = "settings")
+```
 
-- **Preferences DataStore** 使用键存储和访问数据。此实现不需要预定义的架构，也不确保类型安全。
-- **Proto DataStore** 将数据作为自定义数据类型的实例进行存储。此实现要求您使用[协议缓冲区](https://developers.google.com/protocol-buffers)来定义架构，但可以确保类型安全。
+### 从Preferences DataStore读取内容
+
+由于Preferences DataStore不使用预定义的架构，因此您必须使用相应的键类型函数为需要存储在DataStore<Preferences>实例中的每个值定义一个键。例如，如需为int 值定义一个键，请使用intPreferencesKey()](https://developer.android.com/reference/kotlin/androidx/datastore/preferences/core/package-summary#intPreferencesKey(kotlin.String))。然后，使用[DataStore.data](https://developer.android.com/reference/kotlin/androidx/datastore/core/DataStore#data) 属性，通过Flow 提供适当的存储值。
+
+[Kotlin](https://developer.android.com/topic/libraries/architecture/datastore#kotlin)[Java](https://developer.android.com/topic/libraries/architecture/datastore#java)
+
+```kotlin
+val EXAMPLE_COUNTER = intPreferencesKey("example_counter")val exampleCounterFlow: Flow<Int> = context.dataStore.data .map { preferences ->  // No type safety.  preferences[EXAMPLE_COUNTER] ?: 0}
+```
 
-## 设置
+### 将内容写入Preferences DataStore
 
-如需在您的应用中使用 Jetpack DataStore，请根据您要使用的实现向 Gradle 文件添加以下内容：
+Preferences DataStore提供了一个[edit()](https://developer.android.com/reference/kotlin/androidx/datastore/preferences/core/package-summary#edit) 函数，用于以事务方式更新DataStore中的数据。该函数的transform参数接受代码块，您可以在其中根据需要更新值。转换块中的所有代码均被视为单个事务。
 
-[类型化](https://developer.android.com/topic/libraries/architecture/datastore#类型化-datastore)[偏好设置](https://developer.android.com/topic/libraries/architecture/datastore#偏好设置-datastore)
+[Kotlin](https://developer.android.com/topic/libraries/architecture/datastore#kotlin)[Java](https://developer.android.com/topic/libraries/architecture/datastore#java)
 
 ```
-// Typed DataStore (Typed API surface, such as Proto)dependencies { implementation "androidx.datastore:datastore:1.0.0-beta01" // optional - RxJava2 support implementation "androidx.datastore:datastore-rxjava2:1.0.0-beta01" // optional - RxJava3 support implementation "androidx.datastore:datastore-rxjava3:1.0.0-beta01"}// Alternatively - use the following artifact without an Android dependency.dependencies { implementation "androidx.datastore:datastore-core:1.0.0-beta01"}
+suspend fun incrementCounter() { context.dataStore.edit { settings ->  val currentCounterValue = settings[EXAMPLE_COUNTER] ?: 0  settings[EXAMPLE_COUNTER] = currentCounterValue + 1 }}
 ```
 
-**注意**：如果您将 `datastore-preferences-core` 工件与 Proguard 搭配使用，就必须手动将 Proguard 规则添加到 `proguard-rules.pro` 文件中，以免您的字段遭到删除。您可以点击[此处](https://cs.android.com/androidx/platform/frameworks/support/+/androidx-main:datastore/datastore-preferences/proguard-rules.pro)查找必要的规则。
+## 使用Proto DataStore存储类型化的对象
 
-## 使用 Preferences DataStore 存储键值对
+既生Preference DataStore何生Proto DataStore，它们之间有什么区别？
 
-Preferences DataStore 实现使用 [`DataStore`](https://developer.android.com/reference/kotlin/androidx/datastore/core/DataStore) 和 [`Preferences`](https://developer.android.com/reference/kotlin/androidx/datastore/preferences/core/Preferences) 类将简单的键值对保留在磁盘上。
+- Preference DataStore主要是为了解决SharedPreferences所带来的性能问题
+- Proto DataStore比Preference DataStore 更加灵活，支持更多的类型
+    - Preference DataStore支持Int、Long、Boolean、Float、String
+    - protocol buffers支持的类型，Proto DataStore都支持
+- Preference DataStore以XML的形式存储key-value数据，可读性很好
+- Proto DataStore使用了二进制编码压缩，体积更小，速度比XML更快
 
-### 创建 Preferences DataStore
 
-使用由 [`preferencesDataStore`](https://developer.android.com/reference/kotlin/androidx/datastore/preferences/package-summary#dataStore) 创建的属性委托来创建 `Datastore<Preferences>` 实例。在您的 Kotlin 文件顶层调用该实例一次，便可在应用的所有其余部分通过此属性访问该实例。这样可以更轻松地将 `DataStore` 保留为单例。此外，如果您使用的是 RxJava，请使用 [`RxPreferenceDataStoreBuilder`](https://developer.android.com/reference/kotlin/androidx/datastore/rxjava2/RxDataStoreBuilder)。必需的 `name` 参数是 Preferences DataStore 的名称。
 
-[Kotlin](https://developer.android.com/topic/libraries/architecture/datastore#kotlin)[Java](https://developer.android.com/topic/libraries/architecture/datastore#java)
+## 序列化
 
-```
-// At the top level of your kotlin file:val Context.dataStore: DataStore<Preferences> by preferencesDataStore(name = "settings")
-```
+序列化：将一个对象转换成可存储或可传输的状态，数据可能存储在本地或者在蓝牙、网络间进行传输。序列化大概分为对象序列化、数据序列化。
 
-### 从 Preferences DataStore 读取内容
+### 对象的序列化
 
-由于 Preferences DataStore 不使用预定义的架构，因此您必须使用相应的键类型函数为需要存储在 `DataStore<Preferences>` 实例中的每个值定义一个键。例如，如需为 int 值定义一个键，请使用 [`intPreferencesKey()`](https://developer.android.com/reference/kotlin/androidx/datastore/preferences/core/package-summary#intPreferencesKey(kotlin.String))。然后，使用 [`DataStore.data`](https://developer.android.com/reference/kotlin/androidx/datastore/core/DataStore#data) 属性，通过 `Flow` 提供适当的存储值。
+**Java对象序列化** 将一个存储在内存中的对象转化为可传输的字节序列，便于在蓝牙、网络间进行传输或者存储在本地。把字节序列还原为存储在内存中的Java对象的过程称为**反序列化**。
 
-[Kotlin](https://developer.android.com/topic/libraries/architecture/datastore#kotlin)[Java](https://developer.android.com/topic/libraries/architecture/datastore#java)
+在Android中可以通过Serializable和Parcelable两种方式实现对象序列化。
+
+**Serializable**
+
+Serializable是Java原生序列化的方式，主要通过ObjectInputStream和ObjectOutputStream来实现对象序列化和反序列化，但是在整个过程中用到了大量的反射和临时变量，会频繁的触发GC，序列化的性能会非常差，但是实现方式非常简单，来看一下ObjectInputStream和ObjectOutputStream源码里有很多反射的地方。
 
 ```
-val EXAMPLE_COUNTER = intPreferencesKey("example_counter")val exampleCounterFlow: Flow<Int> = context.dataStore.data .map { preferences ->  // No type safety.  preferences[EXAMPLE_COUNTER] ?: 0}
+ObjectOutputStream.java
+private void writeObject0(Object obj, boolean unshared)
+        throws IOException{
+        ......
+        Class<?> cl = obj.getClass();
+        ......
+}
+
+ObjectInputStream.java
+void readFields() throws IOException {
+    ......
+    ObjectStreamField[] fields = desc.getFields(false);
+    for (int i = 0; i < objVals.length; i++) {
+        objVals[i] =
+            readObject0(fields[numPrimFields + i].isUnshared());
+        objHandles[i] = passHandle;
+    }
+    ......
+}
+复制代码
 ```
 
-### 将内容写入 Preferences DataStore
+在Android中存在大量跨进程通信，由于Serializable性能差的原因，所以Android需要更加轻量且高效的对象序列化和反序列化机制，因此Parcelable出现了。
 
-Preferences DataStore 提供了一个 [`edit()`](https://developer.android.com/reference/kotlin/androidx/datastore/preferences/core/package-summary#edit) 函数，用于以事务方式更新 `DataStore` 中的数据。该函数的 `transform` 参数接受代码块，您可以在其中根据需要更新值。转换块中的所有代码均被视为单个事务。
+**Parcelable**
 
-[Kotlin](https://developer.android.com/topic/libraries/architecture/datastore#kotlin)[Java](https://developer.android.com/topic/libraries/architecture/datastore#java)
+Parcelable的出现解决了Android中跨进程通信性能差的问题，而且Parcelable比Serializable要快很多，因为写入和读取的时候都是采用自定义序列化存储的方式，通过writeToParcel()方法和describeContents()方法来实现，不需要使用反射来推断它，因此性能得到提升，但是使用起来比Serializable要复杂很多。
 
-```
-suspend fun incrementCounter() { context.dataStore.edit { settings ->  val currentCounterValue = settings[EXAMPLE_COUNTER] ?: 0  settings[EXAMPLE_COUNTER] = currentCounterValue + 1 }}
-```
+为了解决复杂性问题， AndroidStudio也有对应插件简化使用过程，如果是Java语言可以使用`android parcelable code generator` 插件， 如果Kotlin语言的话可以使用 @Parcelize注解，快速的实现Parcelable序列化。
+
+用一张表格汇总一下Serializable和Parcelable的区别:  
+
+![img](https:////p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/e273a80bbe564bd684b3a68f39b114cf~tplv-k3u1fbpfcp-zoom-1.image)
+
+### 数据序列化
+
+对象序列化记录了很多信息，包括Class信息、继承关系信息、变量信息等等，但是数据序列化相比于对象序列化就没有这么多沉余信息，数据序列化常用的方式有JSON、Protocol Buffers、FlatBuffers。
+
+- JSON:是一种轻量级的数据交互格式，支持跨平台、跨语言，被广泛用在网络间传输，JSON的可读性很强，但是序列化和反序列化性能却是最差的，解析过程中，要产生大量的临时变量，会频繁的触发GC，为了保证可读性，并没有进行二进制压缩，当数据量很大的时候，性能上会差一点。
+
+- Protocol Buffers:它是Google开源的跨语言编码协议，可以应用到C++、C#、Dart 、Go 、Java、Python等等语言，Google内部几乎所有RPC都在使用这个协议，使用了二进制编码压缩，体积更小，速度比JSON更快，但是缺点是牺牲了可读性
+
+    RPC指的是跨进程远程调用，即一个进程调用另外一个进程的方法。
+
+- FlatBuffers:同Protocol Buffers一样是Google开源的跨平台数据序列化库，可以应用到C++、C#,Go、Java、JavaScript、PHP、Python 等等语言，空间和时间复杂度上比其他的方式都要好，在使用过程中，不需要额外的内存，几乎接近原始数据在内存中的大小，但是缺点是牺牲了可读性
+
+最后我们用一张图来分析一下JSON、Protocol Buffers、FlatBuffers 它们序列化和反序列的性能，数据来源于[JSON vs Protocol Buffers vs FlatBuffers](https://codeburst.io/json-vs-protocol-buffers-vs-flatbuffers-a4247f8bda6f)
+
+![img](https:////p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/ef8b9fdbd95e463abf64bea9a2a39588~tplv-k3u1fbpfcp-zoom-1.image)
+
+FlatBuffers和Protocol Buffers无论是序列化还是反序列都完胜JSON，FlatBuffers 最初是Google为游戏或者其他对性能要求很高的应用开发的，接下来我们来看一下今天主角Protocol Buffer。
+
+### Protocol Buffer
+
+Protocol Buffer(简称Protobuf) 它是Google开源的跨语言编码协议，可以应用到C++、C#、Dart、Go、Java、Python等等语言，Google内部几乎所有RPC都在使用这个协议，使用了二进制编码压缩，体积更小，速度比JSON更快。
+
+> 从[Proto3.0.0 Release Note](https://github.com/protocolbuffers/protobuf/releases/tag/v3.0.0-alpha-1) 得知:protocol buffers最初开源时，它实现了Protocol Buffers语言版本2（称为 proto2）, 这也是为什么版本数从v2.0.0开始，从v3.0.0开始， 引入新的语言版本（proto3），而旧的版本（proto2）继续被支持。所以到目前为止Protobuf共两个版本proto2和proto3。
+
+**proto2和proto3应该学习那个版本？**
+
+proto3简化了proto2的语法，提高了开发的效率，因此也带来了版本不兼容的问题，因为2019年的时候才发布proto3稳定版本，所以在这之前使用Protocol Buffer的公司，大部分项目都是使用proto2的版本，从上文的源码分析部分可知，在DataStore中使用了proto2语法，所以proto2和proto3这两种语法都同时在使用。
 
-## 使用 Proto DataStore 存储类型化的对象
+对于初学者而言直接学习proto3语法就可以了，为了适应技术迭代的变化，当掌握proto3语法之后，可以顺带了解一下proto2语法以及proto3和proto2语法的区别，这样可以更好的理解其他的开源项目。
 
-Proto DataStore 实现使用 DataStore 和[协议缓冲区](https://developers.google.com/protocol-buffers)将类型化的对象保留在磁盘上。
+为了避免混淆proto3和proto2语法，在本文仅仅分析proto3语法，当我们了解完这些基本概念之后，我们开始分析如何在项目中使用Proto DataStore。
+
+
+
+
+
+Proto DataStore实现使用DataStore和[协议缓冲区](https://developers.google.com/protocol-buffers)将类型化的对象保留在磁盘上。
 
 ### 定义架构
 
@@ -196,7 +330,26 @@ https://blog.csdn.net/weixin_42324979/article/details/112650189?utm_medium=distr
 - 目前Jetpack Security没有支持DataStore，所以不能像SharedPreference一样支持加密
 - 不能安全的进行IPC，这点相对于SharedPreferences没有提升，有较强IPC需求的话首选MMKV
 - 使用PB进行序列化时需要额外定义IDL，这会产生一定工作量
-  
+
+
+
+
+
+
+
+最后用一张表格来对比一下 MMKV、DataStore、SharedPreferences 的不同之处，如果发现错误，或者有其他不同之处，期待你来一起完善。
+
+![img](https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/8903ca5079314ff7a03b33f60922c1bf~tplv-k3u1fbpfcp-zoom-1.image)
+
+
+
+目前为止，MMKV 功能比 DataStore 强大，毕竟 MMKV 已经经历好几个年头了， DataStore 才只是 alpha01 版本，但是 DataStore 作为 Jetpack 的成员，背靠 Google 的支持，加上全球的开发者一起来完善，从未来角度 DataStore 功能会逐渐完善。DataStore 的版本还是挺优势的，例如：类型安全检查，DataStore 编译的时候，就会告诉开发者类型不对，相比于运行时错误，编译时错误提示更好
+
+
+
+
+
+
 
 - [上一篇:9.App Startup简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/9.App%20Startup%E7%AE%80%E4%BB%8B.md)         
 - [下一篇:11.Hilt简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/11.Hilt%E7%AE%80%E4%BB%8B.md)
@@ -204,4 +357,4 @@ https://blog.csdn.net/weixin_42324979/article/details/112650189?utm_medium=distr
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/Jetpack/architecture/11.Hilt\347\256\200\344\273\213.md" "b/Jetpack/architecture/11.Hilt\347\256\200\344\273\213.md"
index 9bcd46b4..2d3164db 100644
--- "a/Jetpack/architecture/11.Hilt\347\256\200\344\273\213.md"
+++ "b/Jetpack/architecture/11.Hilt\347\256\200\344\273\213.md"
@@ -1,10 +1,319 @@
 # 11.Hilt简介
 
+## 依赖注入
+
+
+
+## Dagger
+
+说到依赖注入，做Android的人都会想到一个库：Dagger。
+
+说到Dagger，大家想到的都是牛逼、高端，又难学又难用。很多使用者用着用着就会掉进了自己亲手用Dagger搭建的迷宫中，越陷越深。
+
+## Hilt
+
+所以Android团队在Jetpack中增加了Hilt，它是一个专门针对Android平台的依赖注入库。它并不是提供了依赖注入的能力，而是提供了一种依赖注入的简单实现方式。Hilt 是在 Dagger 基础上进行开发的，减少了在项目中进行手动依赖，Hilt 集成了 Jetpack 库和 Android 框架类，并删除了大部分模板代码，让开发者只需要关注如何进行绑定，同时 Hilt 也继承了 Dagger 优点，编译时正确性、运行时性能、并且得到了 Android Studio 的支持。
+
+Hilt做的优化包括:  
+1. 无需编写大量的Component代码
+2. Scope也会与Component自动绑定
+3. 预定义绑定，例如Application和Activity
+4. 预定义的限定符，例如@ApplicationContext和@ActivityContext
+
+
+## Koin
+
+Koin - a smart Kotlin injection library to keep you  focused on your app, not on your tools
+
+[Koin](https://insert-koin.io/)是为Kotlin开发者提供的一个实用型轻量级依赖注入框架，采用纯 Kotlin 语言编写而成，仅使用功能解析，无代理、无代码生成、无反射。
+
+
+
+
+
+Hilt、Dagger、Koin等等都是依赖注入库，Google也在努力不断的完善依赖注入库从Dagger到Dagger2在到现在的Hilt，因为依赖注入是面向对象设计中最好的架构模式之一，使用依赖注入库有以下优点:   
+
+- 依赖注入库会自动释放不再使用的对象，减少资源的过度使用。
+- 在配置scopes范围内，可重用依赖项和创建的实例，提高代码的可重用性，减少了很多模板代码。
+- 代码变得更具可读性。
+- 易于构建对象。
+- 编写低耦合代码，更容易测试。
+
+
+
+## 添加依赖项
+
+首先，将 `hilt-android-gradle-plugin` 插件添加到项目的根级 `build.gradle` 文件中：
+
+```groovy
+buildscript {
+    ...
+    dependencies {
+        ...
+        classpath 'com.google.dagger:hilt-android-gradle-plugin:2.28-alpha'
+    }
+}
+```
+
+然后，应用 Gradle 插件并在 `app/build.gradle` 文件中添加以下依赖项：
+
+```groovy
+...
+apply plugin: 'kotlin-kapt'
+apply plugin: 'dagger.hilt.android.plugin'
+
+android {
+    ...
+}
+
+dependencies {
+    implementation "com.google.dagger:hilt-android:2.28-alpha"
+    kapt "com.google.dagger:hilt-android-compiler:2.28-alpha"
+}
+```
+
+**注意**：同时使用Hilt和[数据绑定](https://developer.android.com/topic/libraries/data-binding)的项目需要Android Studio 4.0或更高版本。
+
+Hilt使用 [Java 8 功能](https://developer.android.com/studio/write/java8-support)。如需在项目中启用Java 8，请将以下代码添加到`app/build.gradle`文件中：
+
+```groovy
+android {
+  ...
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+}
+```
+
+
+
+
+
+## Hilt常用注解的含义
+
+Hilt常用注解包含@HiltAndroidApp、@AndroidEntryPoint、@Inject、@Module、@InstallIn、@Provides、@EntryPoint等等。
+
+### @HiltAndroidApp
+
+1. 所有使用Hilt的App必须包含一个使用@HiltAndroidApp注解的Application。它会替代Dagger中的AppComponent。
+2. @HiltAndroidApp注解将会触发Hilt代码的生成，作为应用程序依赖项容器的基类。
+3. 生成的Hilt组件依附于Application的生命周期，它也是App的父组件，提供其他组件访问的依赖。
+4. 在Application中设置好@HiltAndroidApp之后，就可以使用Hilt提供的组件了，组件包含Application、Activity、Fragment、View、Service、BroadcastReceiver 等等。
+
+### @AndroidEntryPoint
+
+Hilt提供的@AndroidEntryPoint注解用于提供Android类的依赖（Activity、Fragment、View、Service、BroadcastReceiver）。
+
+- Activity:仅仅支持ComponentActivity的子类例如FragmentActivity、AppCompatActivity等等。
+- Fragment:仅仅支持继承androidx.Fragment的Fragment
+- View
+- Service
+- BroadcastReceiver
+
+如果您使用@AndroidEntryPoint为某个Android类添加注释，则还必须为依赖于该类的Android类添加注释。例如，如果您为某个Fragment添加注释，则还必须为使用该Fragment的所有Activity添加注释。
+
+### @Inject
+
+Hilt需要知道如何从相应的组件中提供必要依赖的实例。使用@Inject注解来告诉Hilt如何提供该类的实例，它常用于构造函数、非私有字段、方法中。
+
+**注意：在构建时，Hilt为Android类生成Dagger组件。然后Dagger遍历您的代码并执行以下步骤：**
+
+- 构建并验证依赖关系，确保没有未满足的依赖关系。
+- 生成它在运行时用于创建实际对象及其依赖项的类。
+
+```kotlin
+@AndroidEntryPoint
+class ExampleActivity : AppCompatActivity() {
+
+  @Inject lateinit var analytics: AnalyticsAdapter
+  ...
+}
+```
+
+**注意**：由Hilt注入的字段不能为私有字段。尝试使用Hilt注入私有字段会导致编译错误。
+
+### @Module
+
+有时，类型不能通过构造函数注入。发生这种情况可能有多种原因。例如，您不能通过构造函数注入接口。此外，您也不能通过构造函数注入不归您所有的类型，如来自外部库的类。在这些情况下，您可以使用Hilt模块向Hilt提供绑定信息。
+
+Hilt模块是一个带有@Module注释的类。与[Dagger 模块](https://developer.android.com/training/dependency-injection/dagger-android#dagger-modules)一样，它会告知Hilt如何提供某些类型的实例。与Dagger 模块不同的是，您必须使用@InstallIn为Hilt模块添加注释，以告知Hilt每个模块将用在或安装在哪个Android类中。
+
+常用于创建依赖类的对象(例如第三方库 OkHttp、Retrofit等等)，使用@Module注解的类，需要使用@InstallIn注解指定module的范围。
+
+```kotlin
+@Module
+@InstallIn(ApplicationComponent::class)
+// 这里使用了 ApplicationComponent，因此 NetworkModule 绑定到 Application 的生命周期。
+object NetworkModule {
+}
+```
+
+### @InstallIn
+
+使用@Module注入的类，需要使用@InstallIn注解指定module的范围，例如使用 @InstallIn(ActivityComponent::class) 注解的module会绑定到activity的生命周期上。
+
+Hilt提供了以下组件来绑定依赖与对应的Android类的活动范围。
+
+| Hilt 提供的组件           | 对应的 Android 类的活动范围               |
+| ------------------------- | ----------------------------------------- |
+| ApplicationComponent      | Application                               |
+| ActivityRetainedComponent | ViewModel                                 |
+| ActivityComponent         | Activity                                  |
+| FragmentComponent         | Fragment                                  |
+| ViewComponent             | View                                      |
+| ViewWithFragmentComponent | View annotated with @WithFragmentBindings |
+| ServiceComponent          | Service                                   |
+
+**注意：Hilt没有为broadcast receivers提供组件，因为Hilt直接从ApplicationComponent注入broadcast receivers。**
+
+Hilt会根据相应的Android类生命周期自动创建和销毁生成的组件类的实例，它们的对应关系如下表格所示。
+
+| Hilt 提供的组件           | 创建对应的生命周期     | 销毁对应的生命周期      |
+| ------------------------- | ---------------------- | ----------------------- |
+| ApplicationComponent      | Application#onCreate() | Application#onDestroy() |
+| ActivityRetainedComponent | Activity#onCreate()    | Activity#onDestroy()    |
+| ActivityComponent         | Activity#onCreate()    | Activity#onDestroy()    |
+| FragmentComponent         | Fragment#onAttach()    | Fragment#onDestroy()    |
+| ViewComponent             | View#super()           | View destroyed          |
+| ViewWithFragmentComponent | View#super()           | View destroyed          |
+| ServiceComponent          | Service#onCreate()     | Service#onDestroy()     |
+
+### @Provides
+
+它常用于被@Module注解标记类的内部的方法，并提供依赖项对象。
+
+```kotlin
+@Module
+@InstallIn(ApplicationComponent::class)
+// 这里使用了 ApplicationComponent，因此 NetworkModule 绑定到 Application 的生命周期。
+object NetworkModule {
+
+    /**
+     * @Provides 常用于被 @Module 注解标记类的内部的方法，并提供依赖项对象。
+     * @Singleton 提供单例
+     */
+    @Provides
+    @Singleton
+    fun provideOkHttpClient(): OkHttpClient {
+        return OkHttpClient.Builder()
+            .build()
+    }
+}
+```
+
+### @EntryPoint
+
+Hilt支持最常见的Android类Application、Activity、Fragment、View、Service、BroadcastReceiver等等，但是您可能需要在Hilt不支持的类中执行依赖注入，在这种情况下可以使用@EntryPoint注解进行创建，Hilt会提供相应的依赖。
+
+
+
+## 如何使用 Hilt 进行依赖注入
+
+我们先来看一个简单的例子，注入HiltSimple并在Application中调用它的doSomething方法。
+
+```kotlin
+class HiltSimple @Inject constructor() {
+    fun doSomething() {
+        Log.e(TAG, "----doSomething----")
+    }
+}
+
+@HiltAndroidApp
+class HiltApplication : Application() {
+    @Inject
+    lateinit var mHiltSimple: HiltSimple
+
+    override fun onCreate() {
+        super.onCreate()
+        mHiltSimple.doSomething()
+    }
+}
+```
+
+Hilt需要知道如何从相应的组件中提供必要依赖的实例。使用@Inject注解来告诉Hilt如何提供该类的实例，@Inject常用于构造函数、非私有字段、方法中。
+
+## Hilt vs Koin
+
+我们总共从以下几个方面对Hilt和Koin进行全方面的分析：
+
+- AndroidStudio支持Hilt在关联代码间进行导航，支持在@Inject修饰的构造器、@Binds或者@Provides修饰的方法、限定符之间进行跳转。
+
+- 项目结构：完成Hilt的依赖注入需要的文件往往多于Koin。
+
+- 代码行数：使用 [Statistic](https://plugins.jetbrains.com/plugin/4509-statistic) 工具来进行代码统计，反复对比了项目编译前和编译后，Hilt生成的代码多于Koin，随着项目越来越复杂，生成的代码量会越来越多。
+
+    | 代码行数 | Hilt   | Koin   |
+    | -------- | ------ | ------ |
+    | 编译之前 | 2414   | 2414   |
+    | 编译之后 | 149608 | 138405 |
+
+- 编译时间：Hilt编译时间总是大于Koin，这个结果告诉我们，如果是在一个非常大型的项目，这个代价是非常昂贵。
+
+    ```
+    Hilt:
+    BUILD SUCCESSFUL in 35s
+    27 actionable tasks: 27 executed
+    
+    Koin:
+    BUILD SUCCESSFUL in 18s
+    27 actionable tasks: 27 executed
+    ```
+    
+- 使用上对比：Hilt使用起来要比Koin麻烦很多，其入门门槛高于Koin，在阅读Hilt文档的时候花了好几天时间才消化，而Koin只需要花很短的时间，依赖注入部分的代码Hilt多于Koin，在一个更大更复杂的项目中所需要的代码也更多，也越来越复杂。
+
+    | 依赖注入框架 | Hilt | Koin |
+    | ------------ | ---- | ---- |
+    | 代码行数     | 122  | 42   |
+
+**为什么Hilt编译时间总是大于Koin？**
+
+因为在Koin中不需要使用注解，也不需要kapt，这意味着没有额外的代码生成，所有的代码都是Kotlin原始代码，所以说 Hilt编译时间总是大于Koin，从这个角度上同时也解释了，为什么会说Koin仅使用功能解析，无额外代码生成。
+
+**为什么Koin不需要用到反射？**
+
+因为Koin基于kotlin基础上进行开发的，使用了kotlin强大的语法糖（例如 Inline、Reified 等等）和函数式编程，来看一个简单的例子。
+
+```kotlin
+inline fun <reified T : ViewModel> Module.viewModel(
+    qualifier: Qualifier? = null,
+    override: Boolean = false,
+    noinline definition: Definition<T>
+): BeanDefinition<T> {
+    val beanDefinition = factory(qualifier, override, definition)
+    beanDefinition.setIsViewModel()
+    return beanDefinition
+}
+```
+
+内联函数支持具体化的类型参数，使用reified修饰符来限定类型参数，可以在函数内部访问它，由于函数是内联的，所以不需要反射。
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/hilt_koin.png?raw=true)
+
+If you need **compile-time** generating library – use **Hilt** over Dagger, due to simplifications provided. Also consider the best  documentation and plenty of examples from the box and in the internet.
+
+In case of **run-time** generation – use **Koin** over Kodein because it is simpler for using, has better support with docs and examples.
+
+
+
+# 参考
+
+
+
+- [Why would I use Android Hilt (Dagger2) when Koin is available](https://stackoverflow.com/questions/64824349/why-would-i-use-android-hilt-dagger2-when-koin-is-available)
+- [Android 中的依赖项注入](https://developer.android.com/training/dependency-injection)
+- [How Dagger, Hilt and Koin differ under the hood?](https://proandroiddev.com/how-dagger-hilt-and-koin-differ-under-the-hood-c3be1a2959d7)
+- [Finally, a loveable dependency injection for Android: Hilt & Koin](https://medium.com/@genc.tasbasi/finally-a-loveable-dependency-injection-for-android-hilt-koin-6cdfc08a6401)
+- [Koin — Dependency Injection for Android](https://medium.com/@genc.tasbasi/koin-dependency-injection-for-android-ab521da7e6f8)
+- [**Differences and Advantages of Hilt, Dagger2, Koin — 1**](https://medium.com/huawei-developers/differences-and-advantages-of-hilt-dagger2-koin-1-3af44e9a0722)
+- [Comparing Three Dependency Injection Solutions](https://androidessence.com/comparing-three-dependency-injection-solutions)
+- [Hilt, Koin, Kodein](https://smartbright.blog/?p=86)
+- [Change DI Library from Koin to Dagger-Hilt](https://proandroiddev.com/change-di-library-from-koin-to-dagger-hilt-53a4fb3e8dd0)
+- [Jetpack新成员，一篇文章带你玩转Hilt和依赖注入](https://blog.csdn.net/guolin_blog/article/details/109787732)
 
 
 
 
-https://zhuanlan.zhihu.com/p/335631378
 
 
 
@@ -15,4 +324,4 @@ https://zhuanlan.zhihu.com/p/335631378
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! `
\ No newline at end of file
+- Good Luck! `
diff --git "a/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md" "b/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md"
index 9f3486e3..a6a52562 100644
--- "a/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md"
+++ "b/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md"
@@ -500,6 +500,151 @@ class Kot {
 }
 ```
 
+run、with、let、also、apply都是作用域函数，这些作用域函数如何使用以及区分呢？我们将从以下三个方面来区分它们:  
+
+- 是否是扩展函数
+- 作用域函数的参数(this、it)
+- 作用域函数的返回值(调用本身、其他类型即最后一行)
+
+首先我们来看一下 with 和 T.run，这两个函数非常的相似，他们的区别在于 with 是个普通函数，T.run 是个扩展函数，来看一下下面的例子:   
+
+```kotlin
+val name: String? = null
+with(name){
+    val subName = name!!.substring(1,2)
+}
+
+// 使用之前可以检查它的可空性
+name?.run { val subName = name.substring(1,2) }?:throw IllegalArgumentException("name must not be null")
+```
+
+在这个例子当中，name?.run 会更好一些，因为在使用之前可以检查它的可空性。
+
+我们在来看一下 T.run 和 T.let，它们都是扩展函数，但是他们的参数不一样 T.run 的参数是 this, T.let 的参数是 it:   
+
+```kotlin
+val name: String? = "hi-dhl.com"
+
+// 参数是 this，可以省略不写
+name?.run {
+    println("The length  is ${this.length}  this 是可以省略的 ${length}")
+}
+
+// 参数 it
+name?.let {
+    println("The length  is  ${it.length}")
+}
+
+// 自定义参数名字
+name?.let { str ->
+    println("The length  is  ${str.length}")
+}
+```
+
+在上面的例子中看似 T.run 会更好，因为 this 可以省略，调用更加的简洁，但是 T.let 允许我们自定义参数名字，使可读性更强，如果倾向可读性可以选择 T.let。
+
+接下里我们来看一下 T.let 和 T.also 它们接受的参数都是 it, 但是它们的返回值是不同的 T.let 返回最后一行，T.also 返回调用本身:  
+
+```kotlin
+var name = "hi-dhl"
+
+// 返回调用本身
+name = name.also {
+    val result = 1 * 1
+    "juejin"
+}
+println("name = ${name}") // name = hi-dhl
+
+// 返回的最后一行
+name = name.let {
+    val result = 1 * 1
+    "hi-dhl.com"
+}
+println("name = ${name}") // name = hi-dhl.com
+```
+
+从上面的例子来看 T.also 似乎没有什么意义，细想一下其实是非常有意义的，在使用之前可以进行自我操作，结合其他的函数，功能会更强大: 
+
+```kotlin
+fun makeDir(path: String) = path.let{ File(it) }.also{ it.mkdirs() }
+```
+
+接下来看一下 T.apply 函数，T.apply 函数是一个扩展函数，返回值是它本身，并且接受的参数是 this:  
+
+```kotlin
+// 普通方法
+fun createInstance(args: Bundle) : MyFragment {
+    val fragment = MyFragment()
+    fragment.arguments = args
+    return fragment
+}
+// 改进方法
+fun createInstance(args: Bundle) 
+              = MyFragment().apply { arguments = args }
+              
+              
+// 普通方法
+fun createIntent(intentData: String, intentAction: String): Intent {
+    val intent = Intent()
+    intent.action = intentAction
+    intent.data=Uri.parse(intentData)
+    return intent
+}
+// 改进方法，链式调用
+fun createIntent(intentData: String, intentAction: String) =
+        Intent().apply { action = intentAction }
+                .apply { data = Uri.parse(intentData) }
+```
+
+以表格的形式汇总，更方便去理解
+
+| 函数    | 是否是扩展函数 | 函数参数(this、it) | 返回值(调用本身、最后一行) |
+| ------- | -------------- | ------------------ | -------------------------- |
+| with    | 不是           | this               | 最后一行                   |
+| T.run   | 是             | this               | 最后一行                   |
+| T.let   | 是             | it                 | 最后一行                   |
+| T.also  | 是             | it                 | 调用本身                   |
+| T.apply | 是             | this               | 调用本身                   |
+
+### 使用 T.also 函数交换两个变量
+
+接下来演示的是使用 T.also 函数，实现一行代码交换两个变量？我们先来回顾一下 Java 的做法。
+
+```java
+int a = 1;
+int b = 2;
+
+// Java - 中间变量
+int temp = a;
+a = b;
+b = temp;
+System.out.println("a = "+a +" b = "+b); // a = 2 b = 1
+
+// Java - 加减运算
+a = a + b;
+b = a - b;
+a = a - b;
+System.out.println("a = " + a + " b = " + b); // a = 2 b = 1
+        
+// Java - 位运算
+a = a ^ b;
+b = a ^ b;
+a = a ^ b;
+System.out.println("a = " + a + " b = " + b); // a = 2 b = 1
+
+// Kotlin
+a = b.also { b = a }
+println("a = ${a} b = ${b}") // a = 2 b = 1
+```
+
+来一起分析 T.also 是如何做到的，其实这里用到了 T.also 函数的两个特点。
+
+- 调用 T.also 函数返回的是调用者本身。
+- 在使用之前可以进行自我操作。
+
+也就是说 b.also { b = a } 会先将 a 的值 (1) 赋值给 b，此时 b 的值为 1，然后将 b 原始的值（2）赋值给 a，此时 a 的值为 2，实现交换两个变量的目的。
+
+
 
 #### `sNullOrEmpty | isNullOrBlank`
 
diff --git "a/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md" "b/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
index 10f39abf..af1f2699 100644
--- "a/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
+++ "b/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
@@ -318,10 +318,10 @@ main: Now I can quit.
 是一个可以被使用在 [CoroutineScope](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-coroutine-scope/index.html) 中的扩展属性。
 
 
-### 在 `finally` 中释放资源
+### 在`finally` 中释放资源
 
-我们通常使用如下的方法处理在被取消时抛出 [CancellationException](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-cancellation-exception/index.html) 
-的可被取消的挂起函数。比如说，`try {……} finally {……}` 表达式以及 Kotlin 的 `use` 函数一般在协程被取消的时候执行它们的终结动作：
+我们通常使用如下的方法处理在被取消时抛出[CancellationException](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-cancellation-exception/index.html) 
+的可被取消的挂起函数。比如说，`try {……} finally {……}`表达式以及Kotlin的`use` 函数一般在协程被取消的时候执行它们的终结动作：
 
 ```kotlin
 val job = launch {
@@ -450,18 +450,18 @@ The answer is 42
 Completed in 2017 ms
 ```
 
-### 使用 async 并发
+### 使用async并发
 
-如果 `doSomethingUsefulOne` 与 `doSomethingUsefulTwo` 之间没有依赖，并且我们想更快的得到结果，让它们进行 *并发* 吗？
-这就是 [async](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/async.html) 可以帮助我们的地方。
+如果`doSomethingUsefulOne`与`doSomethingUsefulTwo`之间没有依赖，并且我们想更快的得到结果，让它们进行并发吗？
+这就是[async](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/async.html)可以帮助我们的地方。
 
 在概念上，[async](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/async.html) 
-就类似于 [launch](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/launch.html)。
-它启动了一个单独的协程，这是一个轻量级的线程并与其它所有的协程一起并发的工作。不同之处在于 `launch` 返回一个 
+就类似于[launch](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/launch.html)。
+它启动了一个单独的协程，这是一个轻量级的线程并与其它所有的协程一起并发的工作。不同之处在于`launch`返回一个 
 [Job](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-job/index.html) 并且不附带任何结果值，
-而 `async` 返回一个 [Deferred](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-deferred/index.html) —— 
-一个轻量级的非阻塞可取消的future，这代表了一个将会在稍后提供结果的 promise。你可以使用 `.await()` 在一个延期的值上得到它的最终结果，
-但是 `Deferred` 也是一个 `Job`，所以如果需要的话，你可以取消它。
+而`async`返回一个[Deferred](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-deferred/index.html) —— 
+一个轻量级的非阻塞可取消的future，这代表了一个将会在稍后提供结果的promise。你可以使用`.await()` 在一个延期的值上得到它的最终结果，
+但是`Deferred`也是一个`Job`，所以如果需要的话，你可以取消它。
 
 ```kotlin
 val time = measureTimeMillis {
@@ -785,6 +785,43 @@ for (y in channel) println(y)
 println("Done!")
 ```
 
+### Architecture Component Coroutine
+
+如果你使用了Architecture Component，那么你也可以在其基础上使用Coroutine，因为Kotlin Coroutine已经提供了相应的api并且定制了CoroutineScope。
+在ViewModel中，为了能够使用Coroutine提供了viewModelScope.launch，同时一旦ViewModel被清除，对应的Coroutine也会自动取消。
+```kotlin
+ fun getAll() {
+        viewModelScope.launch {
+            val articleList = withContext(Dispatchers.IO) {
+                articleDao.getAll()
+            }
+            adapter.clear()
+            adapter.addAllData(articleList)
+        }
+    }
+```
+在IO线程通过articleDao从数据库取数据，一旦数据返回，在主线程进行处理。如果在取数据的过程中ViewModel已经清除了，那么数据获取也会停止，防止资源的浪费。
+
+对于Lifecycle，提供了LifecycleScope，我们可以直接通过launch来创建Coroutine
+```kotlin
+    private fun coroutine() {
+        lifecycleScope.launch {
+            delay(2000)
+            showToast("coroutine first")
+            delay(2000)
+            showToast("coroutine second")
+        }
+    }
+```
+因为Lifecycle是可以感知组件的生命周期的，所以一旦组件onDestroy了，相应的LifecycleScope.launch闭包中的调用也将取消停止。
+
+
+
+
+
+
+
+
 
 - [上一篇:7.Kotlin_注解&反射&扩展](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/7.Kotlin_%E6%B3%A8%E8%A7%A3%26%E5%8F%8D%E5%B0%84%26%E6%89%A9%E5%B1%95.md)       
 - [下一篇:9.Kotlin_androidktx](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/9.Kotlin_androidktx.md)

From 9f14343bd35886f8f1e9c818b24be66656bc87c9 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Fri, 28 May 2021 21:47:12 +0800
Subject: [PATCH 072/213] update README

---
 README.md | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/README.md b/README.md
index 6ef0cb7a..e3db9d51 100644
--- a/README.md
+++ b/README.md
@@ -155,6 +155,7 @@ Android学习笔记
     - [Glide简介(上)][25]
     - [Glide简介(下)][26]
     - [图片加载库比较][27]
+    - [Coil简介][320]
 
 
 - [RxJava][46]
@@ -193,6 +194,7 @@ Android学习笔记
 - [Gradle&Maven][49]
     - [Gradle专题][39]
     - [发布library到Maven仓库][40]
+    - [Composing builds简介][319]
 
 - [应用发布][50]
     - [使用Jenkins实现自动化打包][198]
@@ -670,6 +672,10 @@ Android学习笔记
 [316]: https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/ui/material/8.TabLayout%E7%AE%80%E4%BB%8B.md "8.TabLayout简介"
 [317]: https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/foundation/1.%E7%AE%80%E4%BB%8B.md "1.简介"
 [318]: https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/behavior/1.%E7%AE%80%E4%BB%8B.md "1.简介"
+[319]: https://github.com/CharonChui/AndroidNote/blob/master/Gradle%26Maven/Composing%20builds%E7%AE%80%E4%BB%8B.md  "Composing builds简介"
+[320]: https://github.com/CharonChui/AndroidNote/blob/master/ImageLoaderLibrary/Coil%E7%AE%80%E4%BB%8B.md "Coil简介"
+
+
 
 
 Developed By

From 482d6ae8d405f10510ddb805361ec5e1a15217f5 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Fri, 25 Jun 2021 11:09:48 +0800
Subject: [PATCH 073/213] update notes

---
 ...mposing builds\347\256\200\344\273\213.md" |  67 ++++--
 ...05\345\255\230\346\250\241\345\236\213.md" |  19 ++
 .../2.ViewBinding\347\256\200\344\273\213.md" |  21 +-
 ...&\347\261\273&\346\216\245\345\217\243.md" |  79 ++++---
 .../8.Kotlin_\345\215\217\347\250\213.md"     | 192 +++++++++++++++++-
 5 files changed, 310 insertions(+), 68 deletions(-)

diff --git "a/Gradle&Maven/Composing builds\347\256\200\344\273\213.md" "b/Gradle&Maven/Composing builds\347\256\200\344\273\213.md"
index 8a137ce3..e4060a5d 100644
--- "a/Gradle&Maven/Composing builds\347\256\200\344\273\213.md"	
+++ "b/Gradle&Maven/Composing builds\347\256\200\344\273\213.md"	
@@ -245,17 +245,19 @@ Composing builds：A composite build is simply a build that includes other build
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/buildsrc_composingbuild.png?raw=true)
 
 **使用方式**
- 1.新建module，名为versionPlugin（自起）
- 2.在该module下的build.gradle文件中，添加如下代码：
+
+1. 新建module，名为versionPlugin（自起）
+2. 在该module下的build.gradle文件中，添加如下代码：
 
 ```groovy
 buildscript {
+    ext.kotlin_version = "1.5.10"
     repositories {
-        jcenter()
+        mavenCentral()
     }
     dependencies {
-        // 因为使用的 Kotlin 需要需要添加 Kotlin 插件
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.4.10"
+        // 因为使用的Kotlin需要需要添加Kotlin插件
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
     }
 }
 
@@ -263,12 +265,9 @@ apply plugin: 'kotlin'
 apply plugin: 'java-gradle-plugin'
 
 repositories {
-    // 需要添加 jcenter 否则会提示找不到 gradlePlugin
-    jcenter()
-    google()
+    mavenCentral()
 }
 
-
 compileKotlin {
     kotlinOptions {
         jvmTarget = "1.8"
@@ -284,18 +283,18 @@ gradlePlugin {
     plugins {
         version {
             // 在app模块需要通过id引用这个插件
-            id = 'com.hi.dhl.plugin'
+            id = 'com.xx.xx.plugin'
             // 实现这个插件的类的路径
-            implementationClass = 'com.hi.dhl.plugin.Deps'
+            implementationClass = 'com.xx.xx.versionplugin.Deps'
         }
     }
 }
 ```
 
-3.在versionPlugin/src/main/java/包名/目录下新建Deps.kt文件，添加你的依赖配置，如：
+3. 在versionPlugin/src/main/java/包名/目录下新建Deps.kt文件，添加你的依赖配置，如：
 
 ```groovy
-package com.hi.dhl.plugin
+package com.xx.xx.versionplugin
 
 class Deps : Plugin<Project> {
     override fun apply(project: Project) {
@@ -308,24 +307,48 @@ class Deps : Plugin<Project> {
 }
 ```
 
-5.在settings.gradle文件内添加includeBuild(“versionPlugin”)，注意是includeBuild哦~，Rebuild项目
-6.后面就可以在需要使用的gradle文件中使用了，如app下的build.gradle，在首行添加以下内容：
+或者也可以按依赖类型用不同的类配置，例如
+
+```kotlin
+object CustomLibs {
+    ...
+        object Glide {
+        private const val glideVersion = "4.11.0"
+        const val glide = "com.github.bumptech.glide:glide:$glideVersion"
+        const val glideCompiler = "com.github.bumptech.glide:compiler:$glideVersion"
+    }
+
+    object Retrofit {
+        private const val retrofitVersion = "2.9.0"
+        const val retrofit = "com.squareup.retrofit2:retrofit:$retrofitVersion"
+        const val converter_gson = "com.squareup.retrofit2:converter-gson:$retrofitVersion"
+    }
+}
+```
+
+
+
+4. 在settings.gradle文件内添加`includeBuild 'versionPlugin'`，注意是includeBuild哦~，Rebuild项目    
+
+5. 后面就可以在需要使用的gradle文件中使用了，在app或其他module下的build.gradle，在首行添加以下内容：
 
 ```groovy
 plugins {
-    // 这个id就是在versionPlugin文件夹下build.gradle文件内定义的id
-    id "com.hi.dhl.plugin"
+    id 'com.android.application'
+    id 'kotlin-android'
+    id 'kotlin-kapt'
+    // 通过id来使用该plugin，这个id就是在versionPlugin文件夹下build.gradle文件内定义的id
+    id 'com.xx.xx.plugin'
 }
 ```
 
-注意: plugins{}需要放在app模块build.gradle文件内的首行位置
-
 使用如下:  
 
 ```groovy
-android {
-    implementation Deps.appcompat
-}
+dependencies {
+    implementation CustomLibs.Glide.glide
+    kapt CustomLibs.Glide.glideCompiler
+}    
 ```
 
 
diff --git "a/JavaKnowledge/Java\345\206\205\345\255\230\346\250\241\345\236\213.md" "b/JavaKnowledge/Java\345\206\205\345\255\230\346\250\241\345\236\213.md"
index 6aa45465..90eb117e 100644
--- "a/JavaKnowledge/Java\345\206\205\345\255\230\346\250\241\345\236\213.md"
+++ "b/JavaKnowledge/Java\345\206\205\345\255\230\346\250\241\345\236\213.md"
@@ -217,6 +217,25 @@ Class Reordering {
 在Java内存模型中，描述了在多线程代码中，哪些行为是正确的、合法的，以及多线程之间如何进行通信，代码中变量的读写行为如何反应到内存、CPU缓存的底层细节。
 
 
+## 问题: 匿名内部类访问局部变量时，为什么这个局部变量必须用final修饰? 
+这个问题并不是很严谨，严格来说应该是Java 1.8之前，匿名内部类访问局部变量时，才需要用final修饰。 
+我们平时经常会用匿名内部类访问局部变量的情况，编译器都会提示我们要对这个局部变量加final修饰，但是我们却并没有去仔细考虑过这是为什么？
+
+上面说到类和成员变量保存到堆内存中。而局部变量则保存在栈内存中。
+假设在main()方法中有一个局部变量a，然后main()方法里面又去创建了一个匿名内部类使用该局部变量a。 
+a是在栈内存中的，当main()方法执行结束，a就被清理了。但是你创建的内部类中的方法却可能在main()方法执行完成后再去执行，但是这时候局部变量已经不存在了，那怎么解决这个问题呢？ 
+因此实际上是在访问它的副本，而不是访问原始的局部变量。
+
+在Java的参数传递中，当基本类型作为参数传递时，传递的是值的拷贝，无论你怎么改变这个拷贝，原值是不会改变的；当对象作为参数传递时，传递的是对象的引用的拷贝，无论你怎么改变这个新的引用的指向，原来的引用是不会改变的（当然如果你通过这个引用改变了对象的内容，那么改变实实在在发生了）。知识点三，当final修饰基本类型变量时，不可更改其值，当final修饰引用变量时，不可更改其指向，只能更改其对象的内容。
+
+在Java中内部类会持有外部类的引用和方法中参数的引用，当反编译class文件后，内部类的class文件的构造函数参数中会传入外部类的对象以及方法内局部变量，不管是基本数据类型还是引用变量，如果重新赋值了，会导致内外指向的对象不一致，所以java就暴力的规定使用final，不能重新赋值。
+所以用final修饰实际上就是为了变量值(数据)的一致性。 这里所说的数据一致性，对引用变量来说是引用地址的一致性，对基本类型来说就是值的一致性。
+
+
+当然在JDK 1.8及以后，看起来似乎编译器取消了这种限制，没有被声明为final的变量或参数也可以在匿名内部类内部被访问了。但实际上是因为Java 8引入了effectively final的概念（A variable or parameter whose value is never changed after it is initialized is effectively final）。对于effectively final（事实上的final），可以省略final关键字，本质不变,所以，实际上是诸如effectively final的变量或参数被Java默认为final类型，所以才不会报错，而上述的根本原因没有任何变化。
+
+
+ It's about the scope of variables , Because anonymous inner classes appear inside a method , If it wants to access the parameters of the method or the variables defined in the method , Then these parameters and variables must be modified to final. Because although anonymous inner classes are inside methods , But when it's actually compiled , Inner classes are compiled into Outer.Inner, This means that the inner class is at the same level as the method in the outer class , A variable or parameter in a method in an external class is just a local variable of the method , The scope of these variables or parameters is only valid inside this method . Because internal classes and methods are at the same level when compiling , So the variables or parameters in the method are only final, Internal classes can be referenced .
 
 ---
 
diff --git "a/Jetpack/architecture/2.ViewBinding\347\256\200\344\273\213.md" "b/Jetpack/architecture/2.ViewBinding\347\256\200\344\273\213.md"
index 32985a8a..421a962c 100644
--- "a/Jetpack/architecture/2.ViewBinding\347\256\200\344\273\213.md"
+++ "b/Jetpack/architecture/2.ViewBinding\347\256\200\344\273\213.md"
@@ -231,6 +231,15 @@ class MainActivity : AppCompatActivity() {
 
 #### ActivityViewBinding
 
+```kotlin
+inline fun <T : ViewBinding> AppCompatActivity.viewBinding(crossinline bindingInflater: (LayoutInflater) -> T) =
+    lazy(LazyThreadSafetyMode.SYNCHRONIZED) {
+        val invoke = bindingInflater.invoke(layoutInflater)
+        setContentView(invoke.root)
+        invoke
+    }
+```
+或
 ```kotlin
 import android.os.Looper
 import android.view.LayoutInflater
@@ -293,8 +302,18 @@ binding.mtv.text = "Hello World"
 不幸的是，该属性委托仅对Activity有效，而对Fragment无效。 
 
 #### FragmentViewBinding
-
+需要在gradle中增加`implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"`的依赖:  
 ```kotlin
+import android.view.View
+import androidx.fragment.app.Fragment
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.Observer
+import androidx.viewbinding.ViewBinding
+import kotlin.properties.ReadOnlyProperty
+import kotlin.reflect.KProperty
+
 class FragmentViewBindingDelegate<T : ViewBinding>(
     val fragment: Fragment,
     val viewBindingFactory: (View) -> T
diff --git "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md" "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
index d4406391..565f17e1 100644
--- "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
+++ "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
@@ -13,7 +13,7 @@
 [Kotlin官网](https://kotlinlang.org/)
 
 `JetBrains`这家公司非常牛逼，开发了很多著名的软件，他们在使用`Java`的过程中发现`java`比较笨重不方便，所以就开发了`kotlin`，`kotlin`是
-一种全栈的开发语言，可以用它进行开发`web`、`web`后端、`Android`等。    但是JetBrains团队设计Kotlin所要面临的第一个问题就是必须兼容他们所拥有的数百万行Java代码库，这也代表了Kotlin基于整个Java社区所承载的使命之一，即需要与现有的Java代码完全兼容。这个背景也决定了Kotlin的核心目标--为Java程序员提供一门更好的变成语言。
+一种全栈的开发语言，可以用它进行开发`web`、`web`后端、`Android`等。    但是JetBrains团队设计Kotlin所要面临的第一个问题就是必须兼容他们所拥有的数百万行Java代码库，这也代表了Kotlin基于整个Java社区所承载的使命之一，即需要与现有的Java代码完全兼容。这个背景也决定了Kotlin的核心目标--为Java程序员提供一门更好的编程语言。
 
 很多开发者都说`Google`学什么不好，非要学苹果，出个`android`的`swift`版本，一定会搞不起来没人用，所以不用浪费时间去学习。在这里想引用马云
 的一句话: 
@@ -132,11 +132,10 @@ import android.os.Bundle
 
 // 定义类，继承AppCompatActivity
 class MainActivity : AppCompatActivity() {
-	
-	// 重写方法用overide，函数名用fun声明  参数是a: 类型的形式 ?是啥？它是指明该对象可能为null，
-	// 如果有了?那在调用该方法的时候参数可以传递null进入，如果没有?传递null就会报错
+    // 重写方法用overide，函数名用fun声明  参数是a: 类型的形式 ?是啥？它是指明该对象可能为null，
+    // 如果有了?那在调用该方法的时候参数可以传递null进入，如果没有?传递null就会报错
     override fun onCreate(savedInstanceState: Bundle?) {
-    	// super 
+        // super 
         super.onCreate(savedInstanceState)
         // 调用方法
         setContentView(R.layout.activity_main)
@@ -148,7 +147,7 @@ class MainActivity : AppCompatActivity() {
 
 ## 变量
 
-变量可以很简单地定义成可变`var`(可读可写)和不可变`val`(只读)的变量。如果var代表了varible(变量)，那么val可看成value(值)的缩写，但是也有人觉得这样并不直观或准确，而是把val解释成varible+final，即通过val声明的变量具有Java中的final关键字的效果(我们通过查看对val语法反编译后转化的java代码，从中可以很清楚的发现它是用final实现的。)，也就是引用不可变。因此，val声明的变量是只读变量，它的引用不可更改，但并不代表其引用对象也不可变。事实上，我们依然可以修改引用对象的可变成员。
+变量可以很简单地定义成可变`var`(可读可写)和不可变`val`(只读)的变量。如果var代表了varible(变量)，那么val可看成value(值)的缩写，但是也有人觉得这样并不直观或准确，而是把val解释成varible+final，即通过val声明的变量具有Java中的final关键字的效果(我们通过查看对val语法反编译后转化的java代码，从中可以很清楚的发现它是用final实现的)，也就是引用不可变。因此，val声明的变量是只读变量，它的引用不可更改，但并不代表其引用对象也不可变。事实上，我们依然可以修改引用对象的可变成员。
 
 声明:  
 ```kotlin
@@ -162,7 +161,7 @@ book.printName() // Diving into Kotlin
 
 再提示一下:`kotlin`中每行代码结束不需要分号了，不要和`java`是的每行都带分号
 
-字面上可以写明具体的类型。这个不是必须的，但是一个通用的`Kotlin`实践时省略变量的类型我们可以让编译器自己去推断出具体的类型，**Kotlin拥有比Java更加强大的类型推导功能，这避免了静态类型语言在编码时需要书写大量类型的弊端**:   
+字面上可以写明具体的类型。这个不是必须的，但是一个通用的`Kotlin`实践是省略变量的类型我们可以让编译器自己去推断出具体的类型，**Kotlin拥有比Java更加强大的类型推导功能，这避免了静态类型语言在编码时需要书写大量类型的弊端**:   
 ```kotlin
 var age = 18 // int
 val name = "charon" // string
@@ -298,7 +297,7 @@ class A {
 }
 fun main() {
     val a = A()
-	a.size = 11
+    a.size = 11
     println("${a.size}")
 }
 // 
@@ -409,7 +408,7 @@ val sex: String by lazy(LazyThreadSafetyMode.NONE) {
 
 - 每个对象的行为
 
-    对象的行为是它们的函数（functions）。它们决定了对象的行为，并且可能回使用对象的属性。例如，之前提到的Dog类，可能具有吠叫（bark）函数；Song这个类可能会有播放（play）函数。
+    对象的行为是它们的函数（functions）。它们决定了对象的行为，并且可能会使用对象的属性。例如，上面提到的Dog类，可能具有吠叫（bark）函数；Song这个类可能会有播放（play）函数。
 
 
 
@@ -585,7 +584,7 @@ class Bird (weight: Double = 0.00, age: Int = 0, color: String = "blue"){
 
 #### init语句块
 
-Kotlin引入了一种叫作init语句块的语法，它属于上述构造方法的一部分，两者在表现形式上确是分离的。Bird类的构造方法在类的外部，它只能对参数进行赋值。如果我们需要在初始化时进行其他的额外操作，那么我们就可以使用init语句块来执行。比如:  
+Kotlin引入了一种叫作init语句块的语法，它属于上述构造方法的一部分，两者在表现形式上却是分离的。Bird类的构造方法在类的外部，它只能对参数进行赋值。如果我们需要在初始化时进行其他的额外操作，那么我们就可以使用init语句块来执行。比如:  
 
 ```kotlin
 class Bird(weight: Double, aget: Int, color: String) {
@@ -693,7 +692,7 @@ data class Artist(
     var mbid: String)
 ```
 
-数据类自动覆盖它们的equals方法以改变==操作符的行为，由此通过检查对象的每个属性值来判断是否相等。例如，假设你创建了两个属性值完全相同的Recipe对象，使用==操作符对它们进行比较将返回true，因为它们存放了相同的数据：除了提供从Any父类继承的equals方法的新实现，数据类还覆盖了hashCode和toString方法。
+数据类自动覆盖它们的equals方法以改变==操作符的行为，由此通过检查对象的每个属性值来判断是否相等。例如，假设你创建了两个属性值完全相同的Artist对象，使用==操作符对它们进行比较将返回true，因为它们存放了相同的数据：除了提供从Any父类继承的equals方法的新实现，数据类还覆盖了hashCode和toString方法。
 
 通过数据类，会自动提供以下函数：
 
@@ -730,7 +729,7 @@ val charon2 = charon.copy(age = 19)
 
 
 
-与任何其他类一样，你可以向数据类添加属性和方法，只需要将它们包含在类主体中。但是有一个大问题。在编译器生成数据类的方法实现时，比如覆盖equals方法和创建copy方法，它仅包含在主构造函数中定义的属性。因此如果你在数据类主体中定义添加的属性，则它们不会被包含到任何编译器生成的方法中。
+与任何其他类一样，你可以向数据类添加属性和方法，只需要将它们包含在类主体中。但是有一个大问题,就是在编译器生成数据类的方法实现时，比如覆盖equals方法和创建copy方法，它仅包含在主构造函数中定义的属性。因此如果你在数据类主体中定义添加的属性，则它们不会被包含到任何编译器生成的方法中。
 
 ### 数据类定义了componentN方法
 
@@ -981,7 +980,7 @@ abstract class Derived : Base() {
 
 ## 接口:使用`interface`关键字
 
-接口可以让你在父类层次结构之外定义共同的行为接口用于为共同行为定义协议，使你可以不依赖严格的继承结构却又可以利用多态。与抽象类类似，接口不能被实例化且可以定义抽象或具体的方法和属性，但两者有一个关键的不同点：类可以实现多个接口，但是只能继承于一个直接父类。所以接口不仅拥有抽象类的优点，而且使用起来更加灵活。
+接口可以让你在父类层次结构之外定义共同的行为，接口用于为共同行为定义协议，使你可以不依赖严格的继承结构却又可以利用多态。与抽象类类似，接口不能被实例化且可以定义抽象或具体的方法和属性，但两者有一个关键的不同点：类可以实现多个接口，但是只能继承于一个直接父类。所以接口不仅拥有抽象类的优点，而且使用起来更加灵活。
 
 ```kotlin
 interface FlyingAnimal {
@@ -1021,7 +1020,7 @@ fun onCreate(savedInstanceState: Bundle?) {
     setContentView(R.layout.activity_main)
 }
 ```
-如果你没有指定它的返回值，它就会返回`Unit`与`Java`中的`void`类似，但是`Unit`是一个类型，而void只是一个关键字。`Unit`可以省略。
+如果你没有指定它的返回值，它就会返回`Unit`，`Unit`与`Java`中的`void`类似，但是`Unit`是一个类型，而void只是一个关键字。`Unit`可以省略。
 你当然也可以指定任何其它的返回类型:      
 
 ```kotlin
@@ -1034,9 +1033,32 @@ fun maxOf(a: Int, b: Int): Int {
 }
 ```
 
+### `Unit`:让函数调用皆为表达式
+
+如果函数返回`Unit`类型，该返回类型应该省略:   
+
+```kotlin
+fun foo() { // 省略了 ": Unit"
+
+}
+```
+
+之所以不能说Java中的函数调用皆是表达式，是因为存在特例void。众所周知，在Java中如果声明的函数没有返回值，那么它就需要用void来修饰，如： 
+
+```java
+void foo() {
+    System.out.println("return nothing")
+}
+```
+
+所以foo()就不具有值和类型信息，它就不能算作一个表达式。在Kotlin中，函数在所有的情况下都具有返回类型，所以他们引入了Unit来替代Java中的void关键字。
+
+Unit与Int一样，都是一种类型，然而它不代表任何信息，用面向对象的术语来描述就是一个单例，它的实例只有一个，可写为()。
+
+
 ### 表达式函数体
 
-然而如果返回的结果可以使用一个表达式计算出来，你可以不使用括号而是使用等号:         
+如果返回的结果可以使用一个表达式计算出来，你可以不使用括号而是使用等号:         
 
 ```kotlin
 fun add(x: Int,y: Int) : Int = x + y // 省略了{}
@@ -1104,33 +1126,6 @@ val mList2 = vars(0, *myArray, 6, 7)
 ```
 
 
-
-
-
-### `Unit`:让函数调用皆为表达式
-
-如果函数返回`Unit`类型，该返回类型应该省略:   
-
-```kotlin
-fun foo() { // 省略了 ": Unit"
-
-}
-```
-
-之所以不能说Java中的函数调用皆是表达式，是因为存在特例void。众所周知，在Java中如果声明的函数没有返回值，那么它就需要用void来修饰，如： 
-
-```java
-void foo() {
-    System.out.println("return nothing")
-}
-```
-
-所以foo()就不具有值和类型信息，它就不能算作一个表达式。在Kotlin中，函数在所有的情况下都具有返回类型，所以他们引入了Unit来替代Java中的void关键字。
-
-Unit与Int一样，都是一种类型，然而它不代表任何信息，用面向对象的术语来描述就是一个单例，它的实例只有一个，可写为()。
-
-
-
 ## 命名风格
 
 如果拿不准的时候，默认使用`Java`的编码规范，比如:   
diff --git "a/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md" "b/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
index af1f2699..b1e79261 100644
--- "a/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
+++ "b/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
@@ -1,9 +1,11 @@
 8.Kotlin_协程
 ===
 
+协程并不是Kotlin提出来的概念，其他的一些编程语言，例如Go、Python等都可以在语言层面上实现协程，甚至是Java，也可以通过使用扩展库来间接的支持协程。
+
 Kotlin引入了协程（Coroutine）来支持更好的异步操作，利用它我们可以避免在异步编程中使用大量的回调，同时相比传统多线程技术，它更容易提升系统的高并发处理能力。 
 
-### 起源
+## 起源
 
 协程是一个无优先级的子程序调用组件，允许子程序在特定的地方挂起恢复。线程包含于进程，协程包含于线程。只要内存足够，
 一个线程中可以有任意多个协程，但某一时刻只能有一个协程在运行，多个协程分享该线程分配到的计算机资源。
@@ -15,6 +17,43 @@ Kotlin引入了协程（Coroutine）来支持更好的异步操作，利用它
 
 协程就像一个轻量级的线程在幕后，启动协程就像启动一个单独的执行线程。线程在其他语言中很常见，例如Java，协程和线程可以并行运行，并互相通信。然而，不同点在于使用协程比使用线程更加高效。在性能方面，启动一个线程并使其保持运行是非常昂贵的。处理器通常只能同时运行有限数量的线程，并且运行尽可能少的线程会更高效。而另一方面，协程默认运行在共享的线程池中，同一个线程可以运行多个协程。由于使用的线程较少，当你想要运行异步任务时，使用协程会更加高效。
 
+## 进程、线程、协程
+进程：一段程序的执行过程，资源分配和调度的基本单位，有其独立地址空间，互相之间不发生干扰
+线程：轻量级进程，资源调度的最小单位，共享父进程地址空间和资源，其调度和进程一样要切换到内核态
+并行：同时发生，在多核CPU中，多个任务可同时在不同CPU上面同一时间执行
+并发：宏观并行，微观串行，操作系统根据相关算法，分配时间片来调度，从而达到一种宏观上并行的方式
+上下文：程序执行的状态，通常用调用栈记录程序执行的当前状态以及其相关的环境信息
+
+早期，CPU是单核，无法真正并行，为了产生共享CPU的假象，提出了时间片概念，将时间分割成连续的时间片段，多个程序交替获得CPU使用权限。 而管理时间片分配调度的调度器则成为操作系统的核心组件。
+
+程序能交替执行，但上下文切换必然会引起程序相关变量混乱，因此在物理地址基础上提出虚拟地址概念
+CPU增加内存管理单元，进行虚拟地址和物理地址的转换
+操作系统加入内存管理模块，管理物理内存和虚拟内存
+
+
+进程是一个实体，包括程序代码以及其相关资源(内存，I/O，文件等)，可被操作系统调度。但想一边操作I/O进行输入输出，一边想进行加减计算，就得两个进程，这样写代码，内存就爆表了。于是又想着能否有一轻量级进程呢，只执行程序，不需要独立的内存，I/O等资源，而是共享已有资源，于是产生了线程。
+
+一个进程可以跑很多个线程处理并发，但是线程进行切换的时候，操作系统会产生中断，线程会切换到相应的内核态，并进行上下文的保存，这个过程不受上层控制，是操作系统进行管理。然而内核态线程会产生性能消耗，因此线程过多，并不一定提升程序执行的效率。正是由于1.线程的调度不能精确控制；2.线程的切换会产生性能消耗。协程出现了。
+
+协程: 
+
+1. 协程是一种轻量级的用户态线程
+2. 开发者自行控制程序切换时机，而不是像进程和线程那样把控制权交给操作系统
+3. 协程没有线程、进程切换的时间和资源开销
+4. 协程是非抢占式调度，当前协程切换到其他协程是由自己控制；线程则是时间片用完抢占时间片调度
+
+优点:   
+1. 用户态，语言级别
+2. 无切换性能消耗
+3. 非抢占式
+4. 同步代码思维
+5. 减少同步锁
+缺点:  
+1. 注意全局变量
+2. 阻塞操作会导致整个线程被阻塞
+
+
+用一句话概括Kotlin Couroutine的特点即是"以同步之名，行异步之实".
 ## 使用
 
 如需在 Android 项目中使用协程，请将以下依赖项添加到应用的build.gradle文件中：
@@ -61,8 +100,6 @@ delay函数暂停当前协程在这种情况下，更好的解决方案是使用
 
 例如，以下代码将协程延迟1秒：
 
-
-
 ```kotlin
 import kotlinx.coroutines.*
 
@@ -358,6 +395,141 @@ main: Now I can quit.
 
 另一个区别是，协程不能在随机的指令中挂起，而只能在所谓的挂起点挂起，这会调用特别标记的函数。
 
+
+
+对于回调式的写法，如果并发场景再复杂一些，代码的嵌套可能会更多，这样的话维护起来就非常麻烦。但如果你使用了 Kotlin 协程，多层网络请求只需要这么写：
+
+```
+🏝️
+coroutineScope.launch(Dispatchers.Main) {       // 开始协程：主线程
+    val token = api.getToken()                  // 网络请求：IO 线程
+    val user = api.getUser(token)               // 网络请求：IO 线程
+    nameTv.text = user.name                     // 更新 UI：主线程
+}
+```
+
+
+
+协程最简单的使用方法，其实在前面章节就已经看到了。我们可以通过一个 `launch` 函数实现线程切换的功能：
+
+```
+🏝️
+//               👇
+coroutineScope.launch(Dispatchers.IO) {
+    ...
+}
+复制代码
+```
+
+这个 `launch` 函数，它具体的含义是：我要创建一个新的协程，并在指定的线程上运行它。这个被创建、被运行的所谓「协程」是谁？就是你传给 `launch` 的那些代码，这一段连续代码叫做一个「协程」。
+
+所以，什么时候用协程？当你需要切线程或者指定线程的时候。你要在后台执行任务？切！
+
+```
+🏝️
+launch(Dispatchers.IO) {
+    val image = getImage(imageId)
+}
+复制代码
+```
+
+然后需要在前台更新界面？再切！
+
+```
+🏝️
+coroutineScope.launch(Dispatchers.IO) {
+    val image = getImage(imageId)
+    launch(Dispatch.Main) {
+        avatarIv.setImageBitmap(image)
+    }
+}
+复制代码
+```
+
+好像有点不对劲？这不还是有嵌套嘛。
+
+如果只是使用 `launch` 函数，协程并不能比线程做更多的事。不过协程中却有一个很实用的函数：`withContext` 。这个函数可以切换到指定的线程，并在闭包内的逻辑执行结束之后，自动把线程切回去继续执行。那么可以将上面的代码写成这样：
+
+```
+🏝️
+coroutineScope.launch(Dispatchers.Main) {      // 👈 在 UI 线程开始
+    val image = withContext(Dispatchers.IO) {  // 👈 切换到 IO 线程，并在执行完成后切回 UI 线程
+        getImage(imageId)                      // 👈 将会运行在 IO 线程
+    }
+    avatarIv.setImageBitmap(image)             // 👈 回到 UI 线程更新 UI
+} 
+复制代码
+```
+
+这种写法看上去好像和刚才那种区别不大，但如果你需要频繁地进行线程切换，这种写法的优势就会体现出来。可以参考下面的对比：
+
+```
+🏝️
+// 第一种写法
+coroutineScope.launch(Dispachers.IO) {
+    ...
+    launch(Dispachers.Main){
+        ...
+        launch(Dispachers.IO) {
+            ...
+            launch(Dispacher.Main) {
+                ...
+            }
+        }
+    }
+}
+
+// 通过第二种写法来实现相同的逻辑
+coroutineScope.launch(Dispachers.Main) {
+    ...
+    withContext(Dispachers.IO) {
+        ...
+    }
+    ...
+    withContext(Dispachers.IO) {
+        ...
+    }
+    ...
+}
+复制代码
+```
+
+由于可以"自动切回来"，消除了并发代码在协作时的嵌套。由于消除了嵌套关系，我们甚至可以把 `withContext` 放进一个单独的函数里面：
+
+```
+🏝️
+launch(Dispachers.Main) {              // 👈 在 UI 线程开始
+    val image = getImage(imageId)
+    avatarIv.setImageBitmap(image)     // 👈 执行结束后，自动切换回 UI 线程
+}
+//                               👇
+fun getImage(imageId: Int) = withContext(Dispatchers.IO) {
+    ...
+}
+复制代码
+```
+
+这就是之前说的「用同步的方式写异步的代码」了。
+
+不过如果只是这样写，编译器是会报错的：
+
+```
+🏝️
+fun getImage(imageId: Int) = withContext(Dispatchers.IO) {
+    // IDE 报错 Suspend function'withContext' should be called only from a coroutine or another suspend funcion
+}
+复制代码
+```
+
+意思是说，`withContext` 是一个 `suspend` 函数，它需要在协程或者是另一个 `suspend` 函数中调用。
+
+
+
+
+
+
+
+
 #### 挂起函数
 
 当我们调用标记有特殊修饰符`suspend`的函数时，会发生挂起:    
@@ -817,7 +989,21 @@ println("Done!")
 
 
 
+### RxJava与协程
+
+异步就是同时进行一个以上彼此目的不同的任务。但是对于有前后依赖关系的任务，我们就需要利用异步中的回调机制处理。而异步回调机制又会导致代码结构过分耦合，遇到多重函数回调的嵌套耦合，也就是回调地狱，会导致代码难以维护。而解决回调地狱的方案就是链式调用结构。很自然想到使用RxJava来解决回调地狱，它确实可以很方便地解决上面的问题。
+
+RxJava，准确来讲是 ReactiveX 在 Java 上的实现，是一种响应式程序框架，我们通过它提供的「Observable」的编程范式进行链式调用，可以很好地消除回调。但是RxJava中流的创建、转化与消费都需要使用到各种类和丰富的操作符，这加大了RxJava的学习成本，因为你无法保证团队里面每一个成员都能看懂它。
+
+使用协程，同样可以像 Rx 那样有效地消除回调地狱，不过无论是设计理念，还是代码风格，两者是有很大区别的，协程在写法上和普通的顺序代码类似。在串行的执行中，虽然代码确实是顺序执行的，但其实是在不同的线程上顺序执行的。因为串行的执行中，执行是阻塞式的，主线程的阻塞会导致很严重的问题，所以所有的耗时操作不能在主线程中执行，所以就需要多线程并行来执行。在并行的执行中，异步回调其实就是代码的多线程顺序执行。
+ 那能不能既按照顺序的方式编写代码，又可以让代码在不同的线程顺序执行，自动完成线程的切换工作呢？
+
+那就是Kotlin协程。
+Kotlin 的协程是一种无栈协程的实现，它的控制流转依靠对协程体本身编译生成的状态机的状态流转来实现，变量保存也是通过闭包语法来实现的。异步回调就是代码的多线程顺序执行，而Kotlin协程可以实现顺序编写异步代码，自动进行线程切换。
+
+
 
+没法比较RxJava和协程哪个好，或者谁能取代谁，因为Rx和协程的设计思想本来就不同。
 
 
 

From 90d08d8e0b8063ce01b14bb9a2fcbef285cb0e3d Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 28 Jun 2021 15:27:12 +0800
Subject: [PATCH 074/213] update

---
 ...&\347\261\273&\346\216\245\345\217\243.md" | 85 +++++++++----------
 ...05\350\201\224\345\207\275\346\225\260.md" | 12 +--
 ...0\347\273\204&\351\233\206\345\220\210.md" | 29 +++----
 ...7&\345\205\263\351\224\256\345\255\227.md" |  4 +-
 ...2\344\270\276&\345\247\224\346\211\230.md" | 30 +++----
 ...47\346\211\277\351\227\256\351\242\230.md" |  2 -
 6 files changed, 71 insertions(+), 91 deletions(-)

diff --git "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md" "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
index 565f17e1..d5741133 100644
--- "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
+++ "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
@@ -31,7 +31,7 @@
 and first-class delegation`等实现
 - `Kotlin`可与`Java`语言无缝通信。这意味着我们可以在`Kotlin`代码中使用任何已有的`Java`库；同样的`Kotlin`代码还可以为`Java`代码所用
 - `Kotlin`在代码中很少需要在代码中指定类型，因为编译器可以在绝大多数情况下推断出变量或是函数返回值的类型。这样就能获得两个好处:简洁与安全
-- Kotlin 是一种静态类型的语言。这意味着，类型将在编译时解析且从不改变
+- `Kotlin`是一种静态类型的语言。这意味着，类型将在编译时解析且从不改变
 
 
 ## `Kotlin`优势
@@ -195,13 +195,13 @@ var weight = 70.5 // double
 	val bitwiseAnd = FLAG1 and FLAG2
 	```
 
-- 一个`String`可以像数组那样访问，并且被迭代:     
+- 一个`String`可以像数组那样访问，并且也可以被迭代:     
 	```kotlin
 	var s = "charon"
 	var c = s[2]
 
 	for (a in s) {
-	    Log.e("@@@", a +"");
+	    Log.e("@@@", a + "");
 	}
 	```
 
@@ -263,11 +263,11 @@ class MainActivity : AppCompatActivity() {
 }
 ```
 
-## 后端变量`Backing Fields`.
+## 后端变量`Backing Fields`
 
 `Kotlin`会默认创建`set get`方法，我们也可以自定义`get set`方法:
 
-在`kotlin`的`getter`和`setter`是不允许本身的局部变量的，因为属性的调用也是对`get`的调用，因此会产生递归，造成内存溢出。
+在`kotlin`的`getter`和`setter`是不允许调用本身的局部变量的，因为属性的调用也是对`get`的调用，因此会产生递归，造成内存溢出。
 
 例如:    
 
@@ -319,7 +319,7 @@ var myProperty: String
 ## 延迟初始化
 
 我们说过，在类内声明的属性必须初始化，如果设置非`null`的属性，应该将此属性在构造器内进行初始化。
-假如想在类内声明一个`null`属性，在需要时再进行初始化（最典型的就是懒汉式单例模式），与`Kotlin`的规则是相背的，此时我们可以声明一个属性并延迟其初始化，此属性用`lateinit`修饰符修饰。
+假如想在类内声明一个`null`属性，在需要时再进行初始化（最典型的就是懒汉式单例模式），这就与`Kotlin`的规则是相背的，此时我们可以声明一个属性并延迟其初始化，此属性用`lateinit`修饰符修饰。
 
 ```kotlin
 class MainActivity : AppCompatActivity() {
@@ -400,7 +400,7 @@ val sex: String by lazy(LazyThreadSafetyMode.NONE) {
 
 ## 类的定义:使用`class`关键字
 
-当你在定义类的时候，你需要想想该类所创建的对象需要什么。你需要考虑：
+当你在定义类的时候，需要想想该类所创建的对象需要什么：
 
 - 每个对象自身的特点
 
@@ -456,7 +456,7 @@ val myDog = Dog("Fido", 70, "Mixed" )
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/kotlin_class_dog.jpg?raw=true)        
 
-类中所定义的函数又称为成员函数。有时也被称为方法。
+类中所定义的函数又称为成员函数，有时也被称为方法。
 
 #### 创建对象的执行过程
 
@@ -587,7 +587,7 @@ class Bird (weight: Double = 0.00, age: Int = 0, color: String = "blue"){
 Kotlin引入了一种叫作init语句块的语法，它属于上述构造方法的一部分，两者在表现形式上却是分离的。Bird类的构造方法在类的外部，它只能对参数进行赋值。如果我们需要在初始化时进行其他的额外操作，那么我们就可以使用init语句块来执行。比如:  
 
 ```kotlin
-class Bird(weight: Double, aget: Int, color: String) {
+class Bird(weight: Double, age: Int, color: String) {
     init {
         println("the weight is ${weight}")
     }
@@ -611,16 +611,14 @@ class Bird(weight: Double, aget: Int, color: String) {
     val weight: Double
     val age: Int
     val color: String
+    init {
+        this.weight = weight
+        this.age = age
+    }
+    init {
+        this.color = color
+    }
 }
-
-init {
-    this.weight = weight
-    this.age = age
-}
-init {
-    this.color = color
-}
-
 ```
 
 可以发现，多个init语句块有利于进一步对初始化的操作进行职能分离，这在复杂的业务开发中显得特别有用。
@@ -768,31 +766,7 @@ class Person // 从 Any 隐式继承
 ```
 
 `Any`不是`java.lang.Object`。它除了`equals()`、`hashCode()`和`toString()`外没有任何成员。
-`Kotlin`中所有的类默认都是不可继承的(`final`)，为什么要这样设计呢？引用`Effective Java`书中的第17条:要么为继承而设计，并提供文档说明，
-要么就禁止继承。所以我们只能继承那些明确声明`open`或者`abstract`的类:要声明一个显式的超类型，我们把类型放到类头的冒号之后:   
-
-```kotlin
-open class Person(num: Int)
-// 继承
-class SuperPerson(num: Int) : Person(num)
-```
-
-冒号后面的Person(num)会调用Person类的构造函数，以确保所有的初始化代码（例如给属性赋值）能够被执行。调用父类构造函数是强制性的：如果父类有主构造函数，你必须在子类头中调用它，否则代码将无法通过编译。请记住，即使你没有在父类中显式地添加构造函数，编译器也会在编译代码的时候自动创建一个空构造函数。假如我们不想为Person类添加构造函数，因此编译器在编译代码的时候创建了一个空构造函数。该构造函数通过使用Person()被调用。
-
-
-
-如果该类有一个主构造函数，其基类必须用基类型的主构造函数参数就地初始化。
-如果类没有主构造函数，那么每个次构造函数必须使用`super`关键字初始化其基类型，或委托给另一个构造函数做到这一点。
-注意，在这种情况下，不同的次构造函数可以调用基类型的不同的构造函数:   
-
-```kotlin
-class MyView : View {
-    constructor(ctx: Context) : super(ctx)
-    constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
-}
-```
-
-在Java中，类默认是可以被继承的，除非你主动加final修饰符。而在Kotlin中恰好相反，默认是不可被继承的，除非你主动加可以继承的修饰符，那便是open，如果不加open，那它在转化为Java代码时就是final的:   
+`在Java中，类默认是可以被继承的，除非你主动加final修饰符。而在Kotlin中恰好相反，默认是不可被继承的，除非你主动加可以继承的修饰符，那便是open，如果不加open，那它在转化为Java代码时就是final的:   
 
 ```kotlin
 class Bird {
@@ -825,6 +799,27 @@ public final class Bird {
 }
 ```
 
+所以Kotlin`中所有的类默认都是不可继承的(`final`)，为什么要这样设计呢？引用`Effective Java`书中的第17条:要么为继承而设计，并提供文档说明，
+要么就禁止继承。所以我们只能继承那些明确声明`open`或者`abstract`的类:要声明一个显式的超类型，我们把类型放到类头的冒号之后:   
+
+```kotlin
+open class Person(num: Int)
+// 继承
+class SuperPerson(num: Int) : Person(num)
+```
+
+冒号后面的Person(num)会调用Person类的构造函数，以确保所有的初始化代码（例如给属性赋值）能够被执行。调用父类构造函数是强制性的：如果父类有主构造函数，你必须在子类头中调用它，否则代码将无法通过编译。请记住，即使你没有在父类中显式地添加构造函数，编译器也会在编译代码的时候自动创建一个空构造函数。假如我们不想为Person类添加构造函数，因此编译器在编译代码的时候创建了一个空构造函数。该构造函数通过使用Person()被调用。
+
+如果该类有一个主构造函数，其基类必须用基类型的主构造函数参数就地初始化。
+如果类没有主构造函数，那么每个次构造函数必须使用`super`关键字初始化其基类型，或委托给另一个构造函数做到这一点。
+注意，在这种情况下，不同的次构造函数可以调用基类型的不同的构造函数:   
+
+```kotlin
+class MyView : View {
+    constructor(ctx: Context) : super(ctx)
+    constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
+}
+```
 
 
 ### Any
@@ -1090,7 +1085,7 @@ fun main(args: Array<String>) {
 }
 ```
 
-从Kotlin1.3版本器，你可以忽略main函数的参数，写成如下形式:   
+从Kotlin1.3版本起，你可以忽略main函数的参数，写成如下形式:   
 
 ```kotlin
 fun main() {
@@ -1105,7 +1100,7 @@ fun main() {
 ### 可变长参数函数:使用`vararg`关键字
 
 ```kotlin
-fun vars(vararg v:Int){
+fun vars(vararg v: Int){
     for(vt in v){
         print(vt)
     }
diff --git "a/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md" "b/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
index 00f773c3..e426256e 100644
--- "a/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
+++ "b/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
@@ -154,7 +154,7 @@ class CountryTest {
     countryApp.filterContries(countries, countryTest::isBigEuropeanCountry)
     ```
 
-经过重构后的程序显然比之前要优雅许多，程序可以根据任意的筛选需求，调用同一个filterCountries方法来获取国家数据。
+经过重构后的程序显然比之前要优雅许多，程序可以根据任意的需求筛选，调用同一个filterCountries方法来获取国家数据。
 
 #### 方法引用表达式更多使用场景
 
@@ -187,10 +187,6 @@ fun main(args: Array<String>) {
 }
 ```
 
-
-
-
-
 ## 匿名函数
 
 再来思考下上面代码中的CountryTest类，这仍算不上是一种很好的方案。因为每增加一个需求，我们都需要在类中专门写一个新增的筛选方法。然而Shaw的需求很多都是临时性的，不需要被复用。Shaw觉得这样还是比较麻烦，他打算用匿名函数对程序进一步的优化。
@@ -250,7 +246,7 @@ val foo = { x: Int ->
 
 
 > “Lambda 表达式”(lambda expression)其实就是匿名函数，`Lambda`表达式基于数学中的`λ`演算得名，直接对应于其中的`lambda`抽象
-> `(lambda abstraction)`，是一个匿名函数，即没有函数名的函数。`Lambda`表达式可以表示闭包（注意和数学传统意义上的不同）。
+> `(lambda abstraction)`，是一个匿名函数，即没有函数名的函数。`Lambda`表达式可以表示闭包。
 
 
 
@@ -289,7 +285,7 @@ Runnable runnable2=()->{
 - 函数体(如果存在的话)在`->`后面。
 
 `Lambda`表达式是定义匿名函数的简单方法。由于`Lambda`表达式避免在抽象类或接口中编写明确的函数声明，进而也避免了类的实现部分，
-所以它是非常有用的。在`Kotlin`语言中，可以将一函数作为另一个函数的参数。
+所以它是非常有用的。
 
 `Lambda`表达式由箭头左侧函数的参数（在圆括号里的内容）定义的，将值返回到箭头右侧。
 `view.setOnClickListener({ view -> toast("Click")})`
@@ -397,7 +393,7 @@ val addFive: (Int) -> Int = { x -> x + 5 }
 由于lambda具有单独的参数x，而且编译器能够推断出x为Int类型，因此我们可以省略该x参数，并在lambda的主体中使用it替换它：
 
 ```kotlin
-val addFive: (Int) - Int = { it + 5 }
+val addFive: (Int) -> Int = { it + 5 }
 ```
 
 在上述代码中，{it+5}等价于{x->x+5}，但更加简洁。请注意，你只能在编译器能够推断该参数类型的情况下使用it语法。例如，以下代码将无法编译，因为编译器不知道it应该是什么类型：
diff --git "a/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md" "b/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md"
index 2a3ed383..213e4c91 100644
--- "a/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md"
+++ "b/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md"
@@ -4,8 +4,7 @@
 前面介绍了基本语法和编码规范后，接下来学习下基本类型。  
 
 在`Kotlin`中，所有东西都是对象，在这个意义上讲我们可以在任何变量上调用成员函数和属性。 一些类型可以有特殊的内部表示——例如，
-数字、字符和布尔值可以在运行时表示为原生类型值，但是对于用户来说，它们看起来就像普通的类。 在本节中，我们会描述`Kotlin`中使用的基本类型:
-数字、字符、布尔值、数组与字符串。
+数字、字符和布尔值可以在运行时表示为原生类型值，但是对于用户来说，它们看起来就像普通的类。
 
 ### 数字  
 
@@ -197,7 +196,8 @@ val str = "$s.length is ${s.length}" // 求值结果为 "abc.length is 3"
 Kotlin中的判等性主要有两种类型： 
 
 - 结构相等。通过操作符==来判断两个对象的内容是否相等。
-- 引用相等。通过操作符===来判断两个对象的引用是否一样，与之相反的判断操作符是！==。如果比较的是运行时的原始类型，比如Int，那么===判断的效果也等价于==。
+- 引用相等。通
+引用相等由`===`以及其否定形式`!===`操作判断。`a === b`当且仅当`a`和`b`指向同一个对象时求值为`true`。如果比较的是运行时的原始类型，比如Int，那么===判断的效果也等价于==。
 
 ```kotlin
 var a = "Java"
@@ -214,13 +214,6 @@ c === f // false
 ```
 
 
-
-### 引用相等
-
-引用相等由`===`以及其否定形式`!===`操作判断。`a === b`当且仅当`a`和`b`指向同一个对象时求值为`true`。
-
-### 结构相等
-
 结构相等由`==`以及其否定形式`!==`操作判断。按照惯例，像`a == b`这样的表达式会翻译成      
 `a?.equals(b) ?: (b === null)`
 也就是说如果`a`不是`null`则调用`equals(Any?)`函数，否则即`a`是`null`检查`b`是否与`null`引用相等。
@@ -254,14 +247,14 @@ print(boxedA == anotherBoxedA) // 输出“true”
     我们就不能在定义这个类之外的文件中使用它。
     另一方面，如果我们在一个类里面使用了private修饰符，那访问权限就被限制在这个类里面了。甚至是继承这个类的子类也不能使用它。
 
-- `protected`.    
+- `protected`    
     在Java中是包、类及子类可访问，而在Kotlin中只允许类及子类。
 
 - `internal`
     它与Java的default有点像但也有所区别。如果是一个定义为`internal`的包成员的话，对所在的整个`module`可见。如果它是一个其它领域的成员，它就需要依赖那个领域的可见性了。
     比如如果写了一个`private`类，那么它的`internal`修饰的函数的可见性就会限制与它所在的这个类的可见性。
 
-- `public`.   
+- `public`   
     你应该可以才想到，这是最没有限制的修饰符。这是默认的修饰符，成员在任何地方被修饰为public，很明显它只限制于它的领域。
 
 ### 数组
@@ -525,14 +518,14 @@ str?.length
 这么写编译器是能通过的，那么`result`的类型是什么呢？在`Kotlin`中，编译器会自动根据结果判断变量的类型，翻译成普通代码如下:   
 
 ```kotlin
-if(str == null)
-    result = null;            // 这里result为一个引用类型
-else
-    result = str.length;    // 这里result为Int
+if(str == null) {
+    result = null         // 这里result为一个引用类型
+} else {
+    result = str.length   // 这里result为Int
+}
 ```
 
-那么如果我们需要的就是一个`Int`的结果(事实上大部分情况都是如此)，那又该怎么办呢？在`kotlin`中除了`?`表示可为空以外，还有一个新的符号`:`双
-感叹号`!!`，表示一定不能为空。所以上面的例子，如果要对`result`进行操作，可以这么写:  
+那么如果我们需要的就是一个`Int`的结果(事实上大部分情况都是如此)，那又该怎么办呢？在`kotlin`中除了`?`表示可为空以外，还有一个新的符号:双感叹号`!!`，表示一定不能为空。所以上面的例子，如果要对`result`进行操作，可以这么写:  
 
 ```kotlin
 var str : String? = null
diff --git "a/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md" "b/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md"
index 4457adc7..f922d625 100644
--- "a/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md"
+++ "b/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md"
@@ -172,8 +172,8 @@ for (i in 4 downTo 1 step 2) println(i)
 ```kotlin
 var nums = 1 until 100
 for(num in nums) {
-	println(num)
-	// 这样打印出来是1 2 3 .....99
+    println(num)
+    // 这样打印出来是1 2 3 .....99
 }
 ```
 
diff --git "a/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md" "b/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
index 975e2b90..27224838 100644
--- "a/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
+++ "b/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
@@ -276,7 +276,7 @@ fun eval(expr: Expr): Double = when (expr) {
 }
 ```
 
-使用密封类的关键好处在于使用`when`表达式 的时候，如果能够
+使用密封类的关键好处在于使用`when`表达式的时候，如果能够
 验证语句覆盖了所有情况，就不需要为该语句再添加一个`else`语句了。
 
 ```kotlin
@@ -344,7 +344,7 @@ object Resource {
 
 对象也能用于创建匿名类实现。
 
-```java
+```kotlin
 recycler.adapter = object : RecyclerView.Adapter() {
     override fun onBindViewHolder(holder: RecyclerView.ViewHolder?, position: Int) {
     }
@@ -392,7 +392,7 @@ public class Prize {
 
 上面是很常见的Java代码，也许你已经习惯了，但是如果仔细思考，会发现这种语法其实并不是非常好。因为在一个类中既有静态变量、静态方法，
 也有普通变量、普通方法的声明。然而，静态变量和静态方法是属于一个类的，普通变量、普通方法是属于一个具体对象的。
-虽然有static作为区分，然而在代码结构上职能并不是区分得很清晰。 
+虽然有static作为区分，然而在代码结构上职能并不是区分的很清晰。 
 
 那么，有没有一种方式能将这两部分代码清晰的分开，但又不失语义化呢？Kotlin中引入了伴生对象的概念，简单来说，
 这是一种利用companion object两个关键字创造的语法。 
@@ -459,7 +459,6 @@ class Prize private constructor(val name: String, val count: Int, val type: Int)
 class App : Application() {
     companion object {
          private lateinit var instance: App
-
      }
  
      override fun onCreate() {
@@ -607,7 +606,7 @@ class Example {
 
 class DelegateProperty {
     var temp = "old"
-	// getValue和setValue方法的参数是固定的
+    // getValue和setValue方法的参数是固定的
     operator fun getValue(ref: Any?, p: KProperty<*>): String {
         return "DelegateProperty --> ${p.name} --> $temp"
     }
@@ -761,8 +760,7 @@ Just run when first being used
 value
 value
 ```
-可以看到，只有第一次调用了`lazy`里的日志输出，说明`lazy`方法块只有第一次执行了。按照个人理解，上面的`lazy`模块可以这么翻译
-
+可以看到，只有第一次调用了`lazy`里的日志输出，说明`lazy`方法块只有第一次执行了。按照个人理解，上面的`lazy`模块可以这么翻译:    
 ```kotlin
 String lazyValue;
 String getLazyValue(){
@@ -782,8 +780,8 @@ void test(){
 `lazy`延迟初始化是可以接受参数的，提供了如下三个参数: 
 
 - `LazyThreadSafetyMode.SYNCHRONIZED`: 添加同步锁，使`lazy`延迟初始化线程安全
-- `LazyThreadSafetyMode. PUBLICATION`： 初始化的`lambda`表达式可以在同一时间被多次调用，但是只有第一个返回的值作为初始化的值。
-- `LazyThreadSafetyMode. NONE`：没有同步锁，多线程访问时候，初始化的值是未知的，非线程安全，一般情况下，不推荐使用这种方式，除非你能保证初始化和属性始终在同一个线程
+- `LazyThreadSafetyMode.PUBLICATION`： 初始化的`lambda`表达式可以在同一时间被多次调用，但是只有第一个返回的值作为初始化的值。
+- `LazyThreadSafetyMode.NONE`：没有同步锁，多线程访问时候，初始化的值是未知的，非线程安全，一般情况下，不推荐使用这种方式，除非你能保证初始化和属性始终在同一个线程
 
 如果你指定的参数为`LazyThreadSafetyMode.SYNCHRONIZED`,则可以省略，因为`lazy`默认就是使用的`LazyThreadSafetyMode.SYNCHRONIZED`。
 
@@ -792,17 +790,17 @@ void test(){
 如果你要观察一个属性的变化过程，那么可以将属性委托给`Delegates.observable`, `observable`函数原型如下：
 
 ```kotlin
-    public inline fun <T> observable(initialValue: T, crossinline onChange: (property: KProperty<*>, oldValue: T, newValue: T) -> Unit):
-            ReadWriteProperty<Any?, T> =
-        object : ObservableProperty<T>(initialValue) {
-            override fun afterChange(property: KProperty<*>, oldValue: T, newValue: T) = onChange(property, oldValue, newValue)
-        }
+public inline fun <T> observable(initialValue: T, crossinline onChange: (property: KProperty<*>, oldValue: T, newValue: T) -> Unit):
+        ReadWriteProperty<Any?, T> =
+    object : ObservableProperty<T>(initialValue) {
+        override fun afterChange(property: KProperty<*>, oldValue: T, newValue: T) = onChange(property, oldValue, newValue)
+    }
 ```
 
 接受2个参数：
 
-- `initialValue`： 初始值
-- `onChange`： 属性值被修改时的回调处理器，回调有三个参数`property`,`oldValue`,`newValue`,分别为： 被赋值的属性、旧值与新值。
+- `initialValue`：初始值
+- `onChange`：属性值被修改时的回调处理器，回调有三个参数`property`,`oldValue`,`newValue`,分别为：被赋值的属性、旧值与新值。
 
 可观察属性对应的是我们常用的观察者模式，机制类似于我们给`View`增加`Listener`。同样的`kotlin`给了我们很方便的实现:
 
diff --git "a/KotlinCourse/6.Kotlin_\345\244\232\347\273\247\346\211\277\351\227\256\351\242\230.md" "b/KotlinCourse/6.Kotlin_\345\244\232\347\273\247\346\211\277\351\227\256\351\242\230.md"
index 331c030d..bd8ca990 100644
--- "a/KotlinCourse/6.Kotlin_\345\244\232\347\273\247\346\211\277\351\227\256\351\242\230.md"
+++ "b/KotlinCourse/6.Kotlin_\345\244\232\347\273\247\346\211\277\351\227\256\351\242\230.md"
@@ -1,8 +1,6 @@
 6.Kotlin_多继承问题
 ===
 
-
-
 继承和实现是面向对象程序设计中不变的主题。Java是不支持类的多继承的，Kotlin亦是如此。他们为什么要这样设计呢？ 现实中，其实多继承的需求经常会出现，然而类的多继承方式会导致进程关系上语义的混淆。
 
 

From 001252292d9a08f8eda5baf5eb062c8c80b62acb Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Tue, 6 Jul 2021 18:12:43 +0800
Subject: [PATCH 075/213] add notes

---
 .../material/9.BottomNavigation\347\256\200\344\273\213.md" | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 "Jetpack/ui/material/9.BottomNavigation\347\256\200\344\273\213.md"

diff --git "a/Jetpack/ui/material/9.BottomNavigation\347\256\200\344\273\213.md" "b/Jetpack/ui/material/9.BottomNavigation\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..d0d58c38
--- /dev/null
+++ "b/Jetpack/ui/material/9.BottomNavigation\347\256\200\344\273\213.md"
@@ -0,0 +1,6 @@
+# 9.BottomNavigation简介
+
+
+  
+
+- [上一篇:7.Snackbar简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/ui/material/7.Snackbar%E7%AE%80%E4%BB%8B.md)
\ No newline at end of file

From 3da61837908839a32d6d060dd38fd7e17cc074f5 Mon Sep 17 00:00:00 2001
From: xuchuanren <xuchuanren@B000000405212Y.local>
Date: Thu, 26 Aug 2021 13:09:49 +0800
Subject: [PATCH 076/213] update

---
 .../2.ViewBinding\347\256\200\344\273\213.md" | 33 +++++++++----------
 ...57\345\212\250\350\277\207\347\250\213.md" |  4 +--
 2 files changed, 18 insertions(+), 19 deletions(-)

diff --git "a/Jetpack/architecture/2.ViewBinding\347\256\200\344\273\213.md" "b/Jetpack/architecture/2.ViewBinding\347\256\200\344\273\213.md"
index 421a962c..012cbdf1 100644
--- "a/Jetpack/architecture/2.ViewBinding\347\256\200\344\273\213.md"
+++ "b/Jetpack/architecture/2.ViewBinding\347\256\200\344\273\213.md"
@@ -22,11 +22,11 @@ android {
 
 ```xml
 <LinearLayout ... >
-        <TextView android:id="@+id/name" />
-        <ImageView android:cropToPadding="true" />
-        <Button android:id="@+id/button"
-            android:background="@drawable/rounded_button" />
-    </LinearLayout>
+    <TextView android:id="@+id/name" />
+    <ImageView android:cropToPadding="true" />
+    <Button android:id="@+id/button"
+        android:background="@drawable/rounded_button" />
+</LinearLayout>
 ```
 所生成的绑定类的名称就为ResultProfileBinding。此类具有两个字段：一个是名为name的TextView，另一个是名为button的Button。该布局中的ImageView没有ID，因此绑定类中不存在对它的引用。
 
@@ -36,11 +36,10 @@ android {
 如果你希望在生成绑定类时忽略某个布局文件，可以将tools:viewBindingIgnore="true"属性添加到相应布局文件的根视图中: 
 ```xml
 <LinearLayout
-            ...
-            tools:viewBindingIgnore="true" >
-        ...
-    </LinearLayout>
-    
+    ...
+    tools:viewBindingIgnore="true" >
+    ...
+</LinearLayout>
 ```
 
 ### 2.代码中使用
@@ -204,12 +203,12 @@ fragment_order.xml内容如下:
 ```
 这个时候即使我们对include指定了id，在ViewBinding中也不会像普通include那样生成获取对应id的变量。这种情况下，我们需要使用placeholder.xml自动生成的PlaceholderBinding类，然后调用它的bind()方法。 
 ```kotlin
- override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
-        binding = FragmentOrderBinding.inflate(layoutInflater, container, false)
-        placeholderBinding = PlaceholderBinding.bind(binding.root)
-        placeholderBinding.tvPlaceholder.text = getString(R.string.please_wait)
-        return binding.root
-    }
+override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
+    binding = FragmentOrderBinding.inflate(layoutInflater, container, false)
+    placeholderBinding = PlaceholderBinding.bind(binding.root)
+    placeholderBinding.tvPlaceholder.text = getString(R.string.please_wait)
+    return binding.root
+}
 ```
 
 ### View Binding 的传统使用方式
@@ -413,7 +412,7 @@ ViewBinding与DataBinding均会生成可用于直接引用视图的绑定类。
 - [Make Android View Binding great with Kotlin](https://proandroiddev.com/make-android-view-binding-great-with-kotlin-b71dd9c87719)
 - [How to Simplify your Android View Binding Delegation](https://medium.com/easyread/how-to-simplify-your-android-view-binding-delegation-d07812b2a616)
 
-
+## 目录
 
 - [上一篇:1.简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/1.%E7%AE%80%E4%BB%8B.md)         
 - [下一篇:3.Lifecycle简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/3.Lifecycle%E7%AE%80%E4%BB%8B.md)
diff --git "a/SourceAnalysis/Activity\345\220\257\345\212\250\350\277\207\347\250\213.md" "b/SourceAnalysis/Activity\345\220\257\345\212\250\350\277\207\347\250\213.md"
index 5c0d5d6c..8af22363 100644
--- "a/SourceAnalysis/Activity\345\220\257\345\212\250\350\277\207\347\250\213.md"
+++ "b/SourceAnalysis/Activity\345\220\257\345\212\250\350\277\207\347\250\213.md"
@@ -3,7 +3,7 @@ Activity启动过程
 
 前两天面试了天猫的开发，被问到了`Activity`启动过程，不懂啊....
 
-![](https://raw.githubusercontent.com/CharonChui/Pictures/master/app launch summary.jpg)
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/app%20launch%20summary.jpg)
 
 
 今天就来分析一下，我们开启`Activity`主要有两种方式:    
@@ -1508,4 +1508,4 @@ final void startActivityLocked(ActivityRecord r, boolean newTask,
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 

From 93b95cc9292b0cb75b3a88faf7064111f64775a9 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 5 May 2022 21:11:07 +0800
Subject: [PATCH 077/213] modify file

---
 ...7\245\350\257\206\345\244\247\346\235\202\347\203\251.md" | 5 +++++
 1 file changed, 5 insertions(+)

diff --git "a/BasicKnowledge/\347\237\245\350\257\206\345\244\247\346\235\202\347\203\251.md" "b/BasicKnowledge/\347\237\245\350\257\206\345\244\247\346\235\202\347\203\251.md"
index f9a082f8..f2fc9fa7 100644
--- "a/BasicKnowledge/\347\237\245\350\257\206\345\244\247\346\235\202\347\203\251.md"
+++ "b/BasicKnowledge/\347\237\245\350\257\206\345\244\247\346\235\202\347\203\251.md"
@@ -407,6 +407,11 @@ protected void setFullscreen(boolean on) {
     <style name="Theme" parent="android:Theme"></style>
     ```
 
+21.apk签名信息获取
+---
+
+/Users/xxx/Library/Android/sdk/build-tools/30.0.3/apksigner verify --print-certs xxx.apk    
+
 ---
 
 - 邮箱 ：charon.chui@gmail.com  

From af570ed3c7cc578de84f023744769ca203b261db Mon Sep 17 00:00:00 2001
From: Charon <CharonChui@users.noreply.github.com>
Date: Mon, 20 Jun 2022 20:16:00 +0800
Subject: [PATCH 078/213] =?UTF-8?q?Update=201.=E6=93=8D=E4=BD=9C=E7=B3=BB?=
 =?UTF-8?q?=E7=BB=9F=E7=AE=80=E4=BB=8B.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...347\263\273\347\273\237\347\256\200\344\273\213.md" | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md" "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
index b95e65a4..821fa737 100644
--- "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
+++ "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
@@ -193,11 +193,13 @@ Android平台的基础是Linux内核，比如ART虚拟机最终调用底层Linux
 - init进程还启动`servicemanager`(binder服务管家)、`bootanim`(开机动画)等重要服务
 - init进程孵化出Zygote进程，Zygote进程是Android系统的第一个Java进程(即虚拟机进程)，`Zygote是所有Java进程的父进程`，Zygote进程本身是由init进程孵化而来的。
 
-- Zygote进程，是由init进程通过解析init.rc文件后fork生成的，Zygote进程主要包含：
-    - 加载ZygoteInit类，注册Zygote Socket服务端套接字
+- Zygote进程.是由init进程通过解析init.rc文件后fork生成的.
+    Zygote本身是一个Native的应用程序，与驱动、内核等均无关系。Zygote最初的名字叫“app_process”，这个名字是在Android.mk文件中指定的，但在运行过程中，app_process通过Linux下的pctrl系统调用将自己的名字换成了“Zygote”，所以我们通过ps命令看到的进程名是“Zygote”。
+    Zygote进程主要包含：
+    - 加载ZygoteInit类，注册Zygote Socket服务端套接字.Zygote及系统中其他程序的通信没有使用Binder，而是采用了基于AF_UNIX类型的Socket。
     - 加载虚拟机
-    - 提前加载类preloadClasses
-    - 提前加载资源preloadResouces
+    - 预加载类preloadClasses：preloadClass函数的执行时间比较长，这是导致Android系统启动慢的原因之一。
+    - 预加载资源preloadResouces：它主要是加载framework-res.apk中的资源。在UI编程中常使用的com.android.R.XXX资源是系统默认的资源，它们就是由Zygote加载的。
 - System Server进程，是由Zygote进程fork而来，`System Server是Zygote孵化的第一个进程`，System Server负责启动和管理整个Java framework，包含ActivityManager，WindowManager，PackageManager，PowerManager等服务。
 - Media Server进程，是由init进程fork而来，负责启动和管理整个C++ framework，包含AudioFlinger，Camera Service等服务。
 - Zygote进程孵化出的第一个App进程是Launcher，这是用户看到的桌面App；

From c98fbdee01d177a5f5667f181ca45794cca0e3b0 Mon Sep 17 00:00:00 2001
From: Charon <CharonChui@users.noreply.github.com>
Date: Mon, 20 Jun 2022 20:24:08 +0800
Subject: [PATCH 079/213] =?UTF-8?q?Update=201.=E6=93=8D=E4=BD=9C=E7=B3=BB?=
 =?UTF-8?q?=E7=BB=9F=E7=AE=80=E4=BB=8B.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...34\347\263\273\347\273\237\347\256\200\344\273\213.md" | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md" "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
index 821fa737..a112ae8d 100644
--- "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
+++ "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
@@ -194,10 +194,12 @@ Android平台的基础是Linux内核，比如ART虚拟机最终调用底层Linux
 - init进程孵化出Zygote进程，Zygote进程是Android系统的第一个Java进程(即虚拟机进程)，`Zygote是所有Java进程的父进程`，Zygote进程本身是由init进程孵化而来的。
 
 - Zygote进程.是由init进程通过解析init.rc文件后fork生成的.
-    Zygote本身是一个Native的应用程序，与驱动、内核等均无关系。Zygote最初的名字叫“app_process”，这个名字是在Android.mk文件中指定的，但在运行过程中，app_process通过Linux下的pctrl系统调用将自己的名字换成了“Zygote”，所以我们通过ps命令看到的进程名是“Zygote”。
+    Zygote本身是一个Native的应用程序，与驱动、内核等均无关系。Zygote最初的名字叫“app_process”，这个名字是在Android.mk文件中指定的，但在运行过程中，app_process通过Linux下的pctrl系统调用将自己的名字换成了“Zygote”，所以我们通过ps命令看到的进程名是“Zygote”。Zygote是在Android系统中创建Java世界的盘古，它创建了第一个Java虚拟机，同时它又是女娲，它成功地繁殖了framework的核心system_server进程。
     Zygote进程主要包含：
-    - 加载ZygoteInit类，注册Zygote Socket服务端套接字.Zygote及系统中其他程序的通信没有使用Binder，而是采用了基于AF_UNIX类型的Socket。
-    - 加载虚拟机
+    - 创建AppRuntime对象，并调用它的start。此后的活动则由AppRuntime来控制。
+    - 加载虚拟机:调用startVm创建Java虚拟机，然后调用startReg来注册JNI函数。
+    - 加载ZygoteInit类，通过JNI调用com.android.internal.os.ZygoteInit类的main函数，从此进入了Java世界。然而在这个世界刚开创的时候，什么东西都没有。注册Zygote Socket服务端套接字.Zygote及系统中其他程序的通信没有使用Binder，而是采用了基于AF_UNIX类型的Socket。调用registerZygoteSocket。通过这个函数，它可以响应子孙后代的请求。
+    - 启动System Server进程(分裂出了一个system_server进程)：zygote觉得自己的工作压力太大，便通过调用startSystemServer分裂一个子进程system_server来为Java世界服务。Java世界中系统Service所驻留的进程system_server，该进程是framework的核心。如果它死了，就会导致Zygote自杀。
     - 预加载类preloadClasses：preloadClass函数的执行时间比较长，这是导致Android系统启动慢的原因之一。
     - 预加载资源preloadResouces：它主要是加载framework-res.apk中的资源。在UI编程中常使用的com.android.R.XXX资源是系统默认的资源，它们就是由Zygote加载的。
 - System Server进程，是由Zygote进程fork而来，`System Server是Zygote孵化的第一个进程`，System Server负责启动和管理整个Java framework，包含ActivityManager，WindowManager，PackageManager，PowerManager等服务。

From e49d19238f49fabc77f6923d48e54572d1bdb390 Mon Sep 17 00:00:00 2001
From: Charon <CharonChui@users.noreply.github.com>
Date: Tue, 21 Jun 2022 14:54:58 +0800
Subject: [PATCH 080/213] =?UTF-8?q?Update=201.=E6=93=8D=E4=BD=9C=E7=B3=BB?=
 =?UTF-8?q?=E7=BB=9F=E7=AE=80=E4=BB=8B.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md" | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md" "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
index a112ae8d..9055caaf 100644
--- "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
+++ "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
@@ -202,7 +202,7 @@ Android平台的基础是Linux内核，比如ART虚拟机最终调用底层Linux
     - 启动System Server进程(分裂出了一个system_server进程)：zygote觉得自己的工作压力太大，便通过调用startSystemServer分裂一个子进程system_server来为Java世界服务。Java世界中系统Service所驻留的进程system_server，该进程是framework的核心。如果它死了，就会导致Zygote自杀。
     - 预加载类preloadClasses：preloadClass函数的执行时间比较长，这是导致Android系统启动慢的原因之一。
     - 预加载资源preloadResouces：它主要是加载framework-res.apk中的资源。在UI编程中常使用的com.android.R.XXX资源是系统默认的资源，它们就是由Zygote加载的。
-- System Server进程，是由Zygote进程fork而来，`System Server是Zygote孵化的第一个进程`，System Server负责启动和管理整个Java framework，包含ActivityManager，WindowManager，PackageManager，PowerManager等服务。
+- System Server进程，是由Zygote进程fork而来，`System Server是Zygote孵化的第一个进程`，System Server负责启动和管理整个Java framework，包含ActivityManager，WindowManager，PackageManager，PowerManager等服务，也就是说Java中的核心Service都在这里启动。同时会启动Binder通信系统，调用Looper.loop()启动消息循环。
 - Media Server进程，是由init进程fork而来，负责启动和管理整个C++ framework，包含AudioFlinger，Camera Service等服务。
 - Zygote进程孵化出的第一个App进程是Launcher，这是用户看到的桌面App；
 - Zygote进程还会创建Browser，Phone，Email等App进程，每个App至少运行在一个进程上。

From 356f5de978df6b5cf93870ca841771f5e69b6fa3 Mon Sep 17 00:00:00 2001
From: Charon <CharonChui@users.noreply.github.com>
Date: Tue, 21 Jun 2022 16:03:00 +0800
Subject: [PATCH 081/213] =?UTF-8?q?Update=201.=E6=93=8D=E4=BD=9C=E7=B3=BB?=
 =?UTF-8?q?=E7=BB=9F=E7=AE=80=E4=BB=8B.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...4\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md" | 1 +
 1 file changed, 1 insertion(+)

diff --git "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md" "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
index 9055caaf..ccd54508 100644
--- "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
+++ "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
@@ -203,6 +203,7 @@ Android平台的基础是Linux内核，比如ART虚拟机最终调用底层Linux
     - 预加载类preloadClasses：preloadClass函数的执行时间比较长，这是导致Android系统启动慢的原因之一。
     - 预加载资源preloadResouces：它主要是加载framework-res.apk中的资源。在UI编程中常使用的com.android.R.XXX资源是系统默认的资源，它们就是由Zygote加载的。
 - System Server进程，是由Zygote进程fork而来，`System Server是Zygote孵化的第一个进程`，System Server负责启动和管理整个Java framework，包含ActivityManager，WindowManager，PackageManager，PowerManager等服务，也就是说Java中的核心Service都在这里启动。同时会启动Binder通信系统，调用Looper.loop()启动消息循环。
+    另外System Server进程还会启动一个Watch Dog的现成。Watch Dog的中文意思是“看门狗”。我依稀记得其最初存在的意义是因为早期嵌入式设备上的程序经常“跑飞”（比如说电磁干扰等），所以专门设置了一个硬件看门狗，每隔一段时间，看门狗就去检查一下某个参数是不是被设置了，如果发现该参数没有被设置，则判断为系统出错，然后就会强制重启。在软件层面上，Android对SystemServer的参数是否被设置也很谨慎，所以专门为它增加了一条看门狗，可它看的是哪个门呢？就是看几个重要Service的门，一旦发现Service出了问题，就会杀掉system_server，而这也会使zygote随其一起自杀，最后导致重启Java世界。具体实现是隔一段时间给另外一个线程发送一条MONITOR消息，那个线程将检查各个Service的健康情况。而看门狗会等待检查结果，如果第二次还没有返回结果，那么它会杀掉SS。
 - Media Server进程，是由init进程fork而来，负责启动和管理整个C++ framework，包含AudioFlinger，Camera Service等服务。
 - Zygote进程孵化出的第一个App进程是Launcher，这是用户看到的桌面App；
 - Zygote进程还会创建Browser，Phone，Email等App进程，每个App至少运行在一个进程上。

From d0879432f3bf3b85ff7d4df0ae1a623fc5f219a6 Mon Sep 17 00:00:00 2001
From: Charon <CharonChui@users.noreply.github.com>
Date: Wed, 22 Jun 2022 14:08:05 +0800
Subject: [PATCH 082/213] =?UTF-8?q?Update=202.Android=E7=BA=BF=E7=A8=8B?=
 =?UTF-8?q?=E9=97=B4=E9=80=9A=E4=BF=A1=E4=B9=8BHandler=E6=B6=88=E6=81=AF?=
 =?UTF-8?q?=E6=9C=BA=E5=88=B6.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...andler\346\266\210\346\201\257\346\234\272\345\210\266.md" | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git "a/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md" "b/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md"
index 0090c429..dfc392cf 100644
--- "a/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md"
+++ "b/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md"
@@ -179,7 +179,7 @@ private Looper(boolean quitAllowed) {
     mThread = Thread.currentThread();
 }
 ```
-从代码上可以看到prepare()方法的作用是创建一个Looper对象，然后将该Looper对象保存到sThreadLocal中。
+从代码上可以看到prepare()方法的作用是创建一个Looper对象，然后将该Looper对象保存到sThreadLocal中。也就是说，prepare函数通过ThreadLocal机制，巧妙地把Looper和调用prepare的线程（也就是最终的处理线程）绑定在一起了。当事件源向这个Looper发送消息的时候，其实是把消息加到这个Looper的消息队列里了。那么，该消息就将由和Looper绑定的处理线程来处理。
 
 这里有点麻烦了，我们上面使用的代码中并没有调用Looper.prepare()方法啊，理论上这里应该是null，Handler是无法使用的，为什么我们还能正常使用Handler？Looper.prepare()究竟是什么时候调用的？那我们需要看一下prepare()和prepare(boolean quitAllowed)方法都有哪些地方调用了: 
 
@@ -921,4 +921,4 @@ public class MyActivity extends Activity {
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 

From a43bbca845e8018aa32d9ad962e7f33f4439ae4e Mon Sep 17 00:00:00 2001
From: Charon <CharonChui@users.noreply.github.com>
Date: Wed, 22 Jun 2022 14:12:46 +0800
Subject: [PATCH 083/213] =?UTF-8?q?Update=202.Android=E7=BA=BF=E7=A8=8B?=
 =?UTF-8?q?=E9=97=B4=E9=80=9A=E4=BF=A1=E4=B9=8BHandler=E6=B6=88=E6=81=AF?=
 =?UTF-8?q?=E6=9C=BA=E5=88=B6.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...ler\346\266\210\346\201\257\346\234\272\345\210\266.md" | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git "a/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md" "b/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md"
index dfc392cf..424a31dd 100644
--- "a/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md"
+++ "b/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md"
@@ -800,7 +800,12 @@ public final class MessageQueue {
 ```
 
 
-
+根据前面的分析可知，Handler中的消息队列实际就是某个Looper的消息队列，那么，Handler如此安排的目的何在？
+在回答这个问题之前，我先来问一个问题：怎么往Looper的消息队列插入消息？如果不知道Handler，这里有一个很原始的方法可解决上面这个问题：
+- 调用Looper的myQueue，它将返回消息队列对象MessageQueue。
+- 构造一个Message，填充它的成员，尤其是target变量。
+- 调用MessageQueue的enqueueMessage，将消息插入消息队列。
+这种原始方法的确很麻烦，且极容易出错。但有了Handler后，我们的工作就变得异常简单了。Handler更像一个辅助类，帮助我们简化编程的工作。
 
 
 

From b82a745e5a58f680f6bbee5348524f551658a773 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Fri, 30 Sep 2022 17:52:15 +0800
Subject: [PATCH 084/213] add gralde part

---
 .../Gradle\344\270\223\351\242\230.md"        | 18 ++++
 ...62\347\252\201\350\247\243\345\206\263.md" | 82 +++++++++++++++++++
 .../1.OpenGL\347\256\200\344\273\213.md"      | 17 ++--
 3 files changed, 111 insertions(+), 6 deletions(-)
 create mode 100644 "Gradle&Maven/duplicate class\345\206\262\347\252\201\350\247\243\345\206\263.md"

diff --git "a/Gradle&Maven/Gradle\344\270\223\351\242\230.md" "b/Gradle&Maven/Gradle\344\270\223\351\242\230.md"
index 9ac175bc..79e9314b 100644
--- "a/Gradle&Maven/Gradle\344\270\223\351\242\230.md"
+++ "b/Gradle&Maven/Gradle\344\270\223\351\242\230.md"
@@ -6,6 +6,12 @@ Gradle专题
 
 接下来我们就系统的学习一下`Gradle`。    
 
+作用
+---
+
+首先我们要知道它有什么用？ Gradle是一个工具，同时它也是一个编程框架。使用这个工具可以完成app的编译打包等工作。
+
+
 简介
 ---
 
@@ -22,6 +28,18 @@ Gradle专题
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_build_process.png?raw=true)
 
+Gradle与Android Studio的关系
+---
+
+Gradle跟Android Studio其实没有关系，但是Gradle官方还是很看重Android开发的，Google在推出AS的时候选中了Gradle作为构建工具，为了支持Gradle
+能在AS上使用，Google做了个AS的插件叫Android Gradle Plugin，所以我们能在AS上使用Gradle完全是因为这个插件的原因。在项目的根目录有个build.gradle文件，里面有这么一句代码:  
+```
+classpath 'com.android.tools.build:gradle:2.1.2'
+```
+这个就是依赖gradle插件的代码，后面的版本号代表的是android gradle plugin的版本，而不是Gradle的版本，这个是Google定的，跟Gradle官方没关系。
+
+
+
 
 
 基本的项目设置
diff --git "a/Gradle&Maven/duplicate class\345\206\262\347\252\201\350\247\243\345\206\263.md" "b/Gradle&Maven/duplicate class\345\206\262\347\252\201\350\247\243\345\206\263.md"
new file mode 100644
index 00000000..58008579
--- /dev/null
+++ "b/Gradle&Maven/duplicate class\345\206\262\347\252\201\350\247\243\345\206\263.md"	
@@ -0,0 +1,82 @@
+duplicate class冲突解决
+===
+
+```
+Duplicate class com.x.util.Base64Encoder found in modules jetified-b64encode-1.0.8-runtime (com.x.x.x.x:b64encode:1.0.8) and jetified-b64encode_v2_0 (b64encode_v2_0.jar)
+```
+今天在开发过程中遇到了这个错误。提示Base64Encoder在com.x.x.x.x:b64encode:1.0.8和b64encode_v2_0.jar里面重复了，一个是1.0.8版本一个是2.0版本。
+那么这里要做的就是exclude一个就可以。 
+
+1. 首先需要找到是哪个依赖中有该依赖:  
+通常情况下我们会直接查找一下该类就能看到有那几个库中包含，但是这里只能查到jar包的类，所以需要用另一种方式。
+Terminal执行:  
+```
+./gradlew app:dependencies
+```
+执行后会将所有的依赖列出:  
+```
+|    \--- androidx.annotation:annotation:1.1.0 -> 1.2.0
++--- com.google.android.gms:play-services-tasks:17.2.1
+|    \--- com.google.android.gms:play-services-basement:17.6.0
+|         +--- androidx.collection:collection:1.0.0 -> 1.1.0
+|         |    \--- androidx.annotation:annotation:1.1.0 -> 1.2.0
+|         +--- androidx.core:core:1.2.0 -> 1.5.0
+|         |    +--- androidx.annotation:annotation:1.2.0
+|         |    +--- androidx.lifecycle:lifecycle-runtime:2.0.0 -> 2.3.1
+|         |    |    +--- androidx.arch.core:core-runtime:2.1.0
+|         |    |    |    +--- androidx.annotation:annotation:1.1.0 -> 1.2.0
+|         |    |    |    \--- androidx.arch.core:core-common:2.1.0
+|         |    |    |         \--- androidx.annotation:annotation:1.1.0 -> 1.2.0
+|         |    |    +--- androidx.lifecycle:lifecycle-common:2.3.1 (*)
+|         |    |    +--- androidx.arch.core:core-common:2.1.0 (*)
+|         |    |    \--- androidx.annotation:annotation:1.1.0 -> 1.2.0
+|         |    +--- androidx.versionedparcelable:versionedparcelable:1.1.1
+|         |    |    +--- androidx.annotation:annotation:1.1.0 -> 1.2.0
+|         |    |    \--- androidx.collection:collection:1.0.0 -> 1.1.0 (*)
+|         |    \--- androidx.collection:collection:1.0.0 -> 1.1.0 (*)
+|         \--- androidx.fragment:fragment:1.0.0 -> 1.3.4
+|              +--- androidx.annotation:annotation:1.1.0 -> 1.2.0
+|              +--- androidx.core:core:1.2.0 -> 1.5.0 (*)
+|              +--- androidx.collection:collection:1.1.0 (*)
+```
+
+2. 接下来就是在该列表中搜索，找到后直接在`build.gradle`中使用exclude:  
+```
+implementation("com.xxx.xxx:pass-sdk-core-router:${PASS_VERSION}") {
+    // 去除扫码相关功能
+    exclude group: "com.xxx.passport", module: "pass-module-qrcode"
+    // 去除人脸登录相关功能
+    exclude group: "com.xxx.passport", module: "pass-module-face"
+}
+```
+
+3. 但是有时候会发现有很多个库中都会有该依赖，一个一个的去添加不太适合，这时可以在app的buid.gradle中统一配置:  
+```
+android {
+    compileSdkVersion rootProject.android.extCompileSdkVersion
+    buildToolsVersion rootProject.android.extBuildToolsVersion
+    useLibrary 'org.apache.http.legacy'
+    compileOptions {
+        targetCompatibility JavaVersion.VERSION_1_8
+        sourceCompatibility JavaVersion.VERSION_1_8
+    }
+    configurations {
+        implementation.exclude group: 'com.xxx.xxx.common.toolbox' , module:'b64encode'
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
index ad360a9c..777ec332 100644
--- "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -1,14 +1,18 @@
 ## 1.OpenGL简介
 
-最近想要在播放器上做一个效果，需要用到OpenGL，一直以来也没关注学习过，就想着学习学习。在网上已经有很多文章，这里为什么还要写？主要是因为在学的时候发现那些文章看完后还是雨里雾里的不明白。要不就是不连贯，要不就是各种错误，各种理解的不对，导致我稀里糊涂的，干脆我不看了，买了一本书，看了书之后再去看文章就彻底明白了，所以我想写一个简单的，能从入门开始一步步学习的，能简单的学会，文章里面有一些是从下面写的参考链接中拷贝过来的，也有一些是自己从书上看的。
+最近想要在播放器上做一个效果，需要用到OpenGL，一直以来也没关注学习过，就想着学习学习。在网上已经有很多文章，这里为什么还要写？主要是因为在学的
+时候发现那些文章看完后还是雨里雾里的不明白。要不就是不连贯，要不就是各种错误，各种理解的不对，而且版本不同，最开始看的3.0版本，后面我就都用3.0的来写，
+结果网上的例子都是2.0的，GLSL的语法不一样，搞的死活出不来效果，耽误时间，所以干脆我系统学一遍，顺便记录下来，写一个简单的，能从入门开始一步步学习的，
+文章里面有一些是从下面写的参考链接中拷贝过来的，也有一些是自己从书上看的。本书所有的例子都是用OpenGL ES3.0版本、GLSL ES 300版本来写。
+文章里面有一些是从下面写的参考链接中拷贝过来的，也有一些是自己从书上看的。
 
 [OpenGL官网](https://www.opengl.org/)
 
 OpenGL(Open Graphics Library开放图形库)是用于渲染2D、3D矢量图形的跨语言、跨平台的应用程序编程接口。
 
-OpenGL的前身是硅谷图形功能(SGI)公司为其图形工作站开发的IRIS GL,后来因为IRIS GL的移植性不好，所以在其基础上，开发出了OpenGl。OpenGl一般用于在图形工作站，PC端使用，由于性能各方面原因，在移动端使用OpenGl基本带不动。为此，Khronos公司就为OpenGl提供了一个子集，OpenGl ES(OpenGl for Embedded System)。
+OpenGL的前身是硅谷图形功能(SGI)公司为其图形工作站开发的IRIS GL,后来因为IRIS GL的移植性不好，所以在其基础上，开发出了OpenGl。OpenGl一般用
+于在图形工作站，PC端使用，由于性能各方面原因，在移动端使用OpenGl基本带不动。为此，Khronos公司就为OpenGl提供了一个子集，OpenGl ES(OpenGl for Embedded System)。
 
-网上已经有很多文章，这里为什么还要写？主要是因为最近在学的时候发现那些文章看完后还是雨里雾里的不明白。方法不明白，不知道为什么要那样用，而且版本不同，最开始看的3.0版本，后面我就都用3.0的来写，结果网上的例子都是2.0的，GLSL的语法不一样，搞的死活出不来效果，耽误时间，所以干脆我系统学一遍，顺便记录下来，写一个简单的，能从入门开始一步步学习的，文章里面有一些是从下面写的参考链接中拷贝过来的，也有一些是自己从书上看的。本书所有的例子都是用OpenGL ES3.0版本、GLSL ES 300版本来写。
 
 
 
@@ -27,7 +31,8 @@ OpenGL ES是免费的跨平台的功能完善的2D/3D图形库接口的API,是Op
 
 ### OpenGL的作用
 
-在手机上有两大元件，一个是CPU一个是GPU。显示图形界面也有两种方式，一个是使用CPU渲染，一个是使用GPU渲染，但是目前为止最高效的方法就是有效的使用图形处理单元(GPU)，图像的处理和渲染就是在将要渲染到窗口上的像素上做很多的浮点匀速，而GPU可以并行的做浮点运算，所以用GPU来分担CPU的部分，可以提高效率，可以说GPU渲染其实是一种硬件加速。
+在手机上有两大元件，一个是CPU,一个是GPU。显示图形界面也有两种方式，一个是使用CPU渲染，一个是使用GPU渲染，但是目前为止最高效的方法就是有效的使用图形处理单元(GPU)，
+图像的处理和渲染就是在将要渲染到窗口上的像素上做很多的浮点匀速，而GPU可以并行的做浮点运算，所以用GPU来分担CPU的部分，可以提高效率，可以说GPU渲染其实是一种硬件加速。
 
 - 图片处理:比如图片色调转换、美颜等。
 - 摄像头预览效果处理。比如美颜相机、恶搞相机等。
@@ -69,7 +74,7 @@ OpenGL ES 3.0实现了具有可编程着色功能的图形管线，有两个规
 
 - 顶点着色器(Vertex Shader): 用来渲染图形顶点的OpenGL ES代码。生成每个顶点的最终位置
 
-   着色器(shader)是在GPU上运行的小程序。从名称可以看出，可通过处理它们来处理顶点。此程序使用OpenGL ES SL语言来编写。它是一个描述顶点或像素特性的简单程序。OpenGL最本质的概念之一就是着色器，它是图形硬件设备所执行的一类特殊函数。理解着色器最好的办法就是把它看做是专为图形处理单元(即GPU)编译的一种小型程序。任何一种OpenGL程序本质上都可以被分为两部分：CPU端运行的部分，采用C++、Java之类的语言编写；以及GPU端运行的部分，使用GLSL语言编写。
+  着色器(shader)是在GPU上运行的小程序。从名称可以看出，可通过处理它们来处理顶点。此程序使用OpenGL ES SL语言来编写。它是一个描述顶点或像素特性的简单程序。OpenGL最本质的概念之一就是着色器，它是图形硬件设备所执行的一类特殊函数。理解着色器最好的办法就是把它看做是专为图形处理单元(即GPU)编译的一种小型程序。任何一种OpenGL程序本质上都可以被分为两部分：CPU端运行的部分，采用C++、Java之类的语言编写；以及GPU端运行的部分，使用GLSL语言编写。
 
   顶点着色器可以操作的属性有: 位置、颜色、纹理坐标，但是不能创建新的顶点。最终产生纹理坐标、颜色、点位置等信息送往后续阶段。
 
@@ -85,7 +90,7 @@ OpenGL ES 3.0实现了具有可编程着色功能的图形管线，有两个规
 
   - 裁剪是指对于不在视椎体(屏幕上可见的3D区域)内的图元进行裁剪。
 
-  - 淘汰是指根据图元面向前方或后方选择排期它们(如事物内部的点)。
+  - 淘汰是指根据图元面向前方或后方选择抛弃它们(如事物内部的点)。
 
 - 光栅化阶段(Rasterization Stage)
 

From 7e4b687dc2c5ae51dbd9b9d8e7ede2d042a26b30 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Tue, 6 Dec 2022 17:52:42 +0800
Subject: [PATCH 085/213] add ffmpeg part

---
 VideoDevelopment/.DS_Store                    | Bin 0 -> 6148 bytes
 ...72\347\241\200\347\237\245\350\257\206.md" | 109 ++++++-
 ...14\346\255\245\345\216\237\347\220\206.md" |  63 ++++
 ...50\345\221\275\344\273\244\350\241\214.md" | 286 ++++++++++++++++++
 .../FFmpeg/FFmpeg\347\256\200\344\273\213.md" |  27 ++
 .../RTMP.md"                                  |   2 -
 .../FLV.md"                                   |  63 ++--
 .../TS.md"                                    |   8 -
 ...74\345\274\217\350\257\246\350\247\243.md" |   9 +-
 ...01\350\243\205\346\240\274\345\274\217.md" |  29 +-
 10 files changed, 528 insertions(+), 68 deletions(-)
 create mode 100644 VideoDevelopment/.DS_Store
 create mode 100644 "VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/\351\237\263\350\247\206\351\242\221\345\220\214\346\255\245\345\216\237\347\220\206.md"
 create mode 100644 "VideoDevelopment/FFmpeg/FFmpeg\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214.md"
 create mode 100644 "VideoDevelopment/FFmpeg/FFmpeg\347\256\200\344\273\213.md"

diff --git a/VideoDevelopment/.DS_Store b/VideoDevelopment/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..63369ec8e7e79eeeaf351066160344353fa5fe36
GIT binary patch
literal 6148
zcmeHKOHRWu5S@X7BC+X`rLWK%m@06Atk|Ja6c$MxA%VosH{k$WgEO(_jb~VxMq*PT
zRLxZO8_&<llWJ#(h}X~C715H28Vo@eWk$q2>pHREGa#2557ZC+s=H6)G*jq5n&jEf
z=?1@%CYpc#%0H&I-3)1iyymlezkPlCxcXUROxs^$rpG;=s(oI%r`?ctJ!*qn7iYj3
za0Z+KXW(EA*uBzR9IT=jat54%V_`tfhkzj%4YOi7Ixv+M0Jwm;2z2QsBqta~!>kAo
zgf$hYscbC<YdY+~;-X<z)O2ENKG=5tZeF<Tj{2d56Gug#odIW{X5dtpOS%8A@t2ux
z^6L~|IRnnXkukuFwrkgTDZ5+uUQh1YfN_T*B5_$12=wYB01G)sE{jwBL3G4L!>lM(
T#9q>Y{vl8Z@yQwZ0|veT^o=pd

literal 0
HcmV?d00001

diff --git "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
index 7964053a..1d617b21 100644
--- "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
+++ "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
@@ -46,19 +46,18 @@
     人类能听到的声音都成为音频，但是一般我们所说到的音频时存储在计算机里的声音。
 
 - 比特率(码率)
-  
-
-码率就是数据传输时单位时间传送的数据位数,一般我们用的单位是`kbps`即千位(bit)每秒，也就是每秒钟传送多少个千位的信息。 通俗一点的理解就是取样率，单位时间内取样率越大，精度就越高，处理出来的文件就越接近原始文件，但是文件体积与取样率是成正比的，所以几乎所有的编码格式重视的都是如何用最低的码率达到最少的失真。但是因为编码算法不一样，所以也不能用码率来统一衡量音质或者画质.小写的b表示bit(位)，大写的B表示byte(字节)，一个字节=8个位，即1B=8b；前面的k表示1024的意思，即1024个位(Kb)或者1024个字节(KB)，表示文件的大小单位，一般使用KB。1KB/s=8Kbps。码率(kbps)=文件大小(KB)*8/时间(秒)。     
-
+    码率就是数据传输时单位时间传送的数据位数,一般我们用的单位是`kbps`即千位(bit)每秒，也就是每秒钟传送多少个千位的信息。 通俗一点的理解就是取样率，单位时间内取样率越大，精度就越高，处理出来的文件就越接近原始文件，但是文件体积与取样率是成正比的，所以几乎所有的编码格式重视的都是如何用最低的码率达到最少的失真。但是因为编码算法不一样，所以也不能用码率来统一衡量音质或者画质.小写的b表示bit(位)，大写的B表示byte(字节)，一个字节=8个位，即1B=8b；前面的k表示1024的意思，即1024个位(Kb)或者1024个字节(KB)，表示文件的大小单位，一般使用KB。1KB/s=8Kbps。码率(kbps)=文件大小(KB)*8/时间(秒)。     
 - 动态码率(VBR: Variable Bit Rate)
   
-   比特率可以随着图像复杂程度的不同而随之变化。图像内容简单的片段采用较小的码率，图像
-  
-  内容复杂的片段采用较大的码率，这样既保证了播放质量，又兼顾了数据量的限制。例如RMVB视频文件，其中的VB就是指VBR，表示采用动态比特率编码方式，达到播放质量与体积兼得的效果。
+    比特率可以随着图像复杂程度的不同而随之变化。图像内容简单的片段采用较小的码率，图像内容复杂的片段采用较大的码率，这样既保证了播放质量，又兼顾了数据量的限制。例如RMVB视频文件，其中的VB就是指VBR，表示采用动态比特率编码方式，达到播放质量与体积兼得的效果。 使用VBR编码时，系统将自动为内容的简单部分分配较少的比特，从而留出足量的比特用于生成高质量的复杂部分。这意味着复杂性恒定的内容（例如新闻播音）不会受益于VBR编码。
+
+    对混合内容使用VBR编码时，在文件大小相同的条件下，VBR编码的输出结果要比CBR编码的输出结果质量好得很多。在某些情况下，与CBR编码文件质量相同的VBR编码文件，其大小可能只有前者的一半。
   
 - 静态比特率(CBR: Constant Bit Rate)
-  
-    比特率恒定，图像内容复杂的片段质量不稳定，图像内容简单的片段质量较好。
+    固定比特率，指文件从头到尾都是一种位速率。在流式播放方案中使用CBR编码最为有效。使用CBR编码时，比特率在流的进行过程中基本保持恒定并且接近目标比特率，始终处于由缓冲区大小确定的时间窗内。
+
+    CBR编码的缺点在于编码内容的质量不稳定。因为内容的某些片段要比其他片段更难压缩，所以CBR流的某些部分质量就比其他部分差。此外，CBR编码会导致相邻流的质量不同。通常在较低比特率下，质量的变化会更加明显。
+    
   
 - 帧率(Frame Rate)
   
@@ -74,6 +73,22 @@
 
     刷新率是指屏幕每秒画面被刷新的次数，刷新率分为垂直刷新率和水平刷新率，一般提到的刷新率通常是指垂直刷新率。垂直刷新率表示屏幕上图像每秒重绘多少次，也就是每秒屏幕刷新的次数，以Hz（赫兹）为单位。刷新率越高，图像就越稳定，图像显示就越自然清晰，对眼镜的影响也越小。刷新率月底，图像闪烁和抖动的就越厉害，眼镜疲劳的越快。一般来说，如果能达到80Hz以上的刷新率，就可以完全消除图像闪烁和抖动感。
 
+- 分辨率
+    分辨率是一个表示平面图像精细程度的概念，通常它是以横向和纵向点的数量来衡量的，表示成水平点数垂直点数的形式，在计算机显示领域我们也表示成“每英寸像素”（ppi）。
+     在一个固定的平面内，分辨率越高，意味着可使用的点数越多，图像越细致。分辨率有多种，在显示器上有表示显示精度的显示分辨率，在打印机上有表示打印精度的打印分辨率，在扫描仪上有表示扫描精度的扫描分辨率。
+
+    下面我们重点介绍一下显示分辨率：
+
+    显示分辨率是显示器在显示图像时的分辨率，分辨率是用点来衡量的，显示器上这个“点”就是指像素（pixel）。显示分辨率的数值是指整个显示器所有可视面积上水平像素和垂直像素的数量。
+
+    例如800×600的分辨率，是指在整个屏幕上水平显示800个像素，垂直显示600个像素。显示分辨率的水平像素和垂直像素的总数总是成一定比例的，一般为4：3、5：4或8：5 。每个显示器都有自己的最高分辨率，并且可以兼容其它较低的显示分辨率，所以一个显示器可以用多种不同的分辨率显示。
+
+    显示分辨率虽然是越高越好，但是还要考虑一个因素，就是人眼能否识别。例如，在14英寸最高分辨率为 1024×768的显示器上800×600是人眼能识别的最高分辨率（我们称为最佳分辨率）。1024× 768 这个分辨率下显示器虽然可以精确的显示图像，但人眼已不能准确的识别屏幕信息了。
+
+    LCD液晶显示器和传统的CRT显示器，分辨率都是重要的参数之一。传统CRT显示器所支持的分辨率较有弹性，而LCD的像素间距已经固定，所以支持的显示模式不像CRT那么多。LCD的最佳分辨率，也叫最大分辨率，在该分辨率下，液晶显示器才能显现最佳影像。
+
+
+
 - DTS
 
     Decode Time Stamp，主要用于标识读入内存中的比特流在什么时候开始送入解码器中进行解码。
@@ -139,6 +154,20 @@
 - `MP3`:(`MPEG-1 or MPEG-2 Audio Layer III`)，是当曾经非常流行的一种数字音频编码和有损压缩格式，它被设计来大幅降低音频数据量。它是在1991 年，由位于德国埃尔朗根的研究组织`Fraunhofer-Gesellschaft`的一组工程师发明和标准化的。`MP3`的普及曾对音乐产业造成极大的冲击与影响。
 - `WMA`:(`Windows Media Audio`)由微软公司开发的一种数字音频压缩格式，本身包括有损和无损压缩格式。
 
+
+MPEG-1 or MPEG-2 Audio Layer III是一种音频压缩技术，其全称是动态影像专家压缩标准音频层面3（Moving Picture Experts Group Audio Layer III），简称为MP3，是目前最流行的音频编码格式。
+    MP3文件是由帧（frame）构成的，帧是MP3文件最小的组成单位。MPEG音频文件是MPEG1标准中的声音部分，也叫MPEG音频层，它根据压缩质量和编码复杂程度划分为三层，即 Layer-1、Layer2、Layer3，且分别对应MP1、MP2、MP3这三种声音文件，并根据不同的用途，使用不同层次的编码。MPEG音频编码的层次越高，编码器越复杂，压缩率也越高，MP1和MP2的压缩率分别为4:1和6:1-8:1，而MP3的压缩率则高达10:1-12:1，也就是说，一分钟CD音质的音乐，未经压缩需要10MB的存储空间，而经过MP3压缩编码后只有1MB左右。不过MP3对音频信号采用的是有损压缩方式，为了降低声音失真度，MP3采取了“感官编码技术”，即编码时先对音频文件进行频谱分析，然后用过滤器滤掉噪音电平，接着通过量化的方式将剩下的每一位打散排列，最后形成具有较高压缩比的MP3文件，并使压缩后的文件在回放时能够达到比较接近原音源的声音效果。根据MPEG规范的说法，MPEG-4中的AAC（Advanced audio coding）将是MP3格式的下一代。
+
+音频编码方案之间音质比较（AAC，MP3，WMA等）结果： 
+
+AAC+ > MP3PRO > AAC> RealAudio > WMA > MP3
+目前最常见的音频格式有 Mp3、AC-3、ACC，MP3最广泛的支持最多，AC-3是杜比公司的技术，ACC是MPEG-4中的音频标准，ACC是目前比较先进和具有优势的技术。对应入门，知道有这几种最常见的音频格式足以。
+
+
+#### PCM介绍
+
+PCM是英文Pulse-code modulation的缩写，中文译名是脉冲编码调制。我们知道在现实生活中，人耳听到的声音是模拟信号，PCM就是要把声音从模拟转换成数字信号的一种技术，它的原理简单地说就是利用一个固定的频率对模拟信号进行采样，采样后的信号在波形上看就像一串连续的幅值不一的脉冲，把这些脉冲的幅值按一定的精度进行量化，这些量化后的数值被连续地输出、传输、处理或记录到存储介质中，所有这些组成了数字音频的产生过程。
+
 ---
 
 
@@ -190,6 +219,21 @@
 一些音视频的参数含义
 ---
 
+ 数码音频系统是通过将声波波形转换成一连串的二进制数据来再现原始声音的，实现这个步骤使用的设备是模/数转换器（A/D），它以每秒上万次的速率对声波进行采样，每一次采样都记录下了原始模拟声波在某一时刻的状态，称之为样本。
+
+将一串的样本连接起来，就可以描述一段声波了，把每一秒钟所采样的数目称为采样频率或采率，单位为HZ（赫兹）。采样频率越高所能描述的声波频率就越高。采样率决定声音频率的范围（相当于音调），可以用数字波形表示。要正确理解音频采样可以分为采样的位数和采样的频率。
+
+采样的位数：采样位数可以理解为采集卡处理声音的解析度。这个数值越大，解析度就越高，录制和回放的声音就越真实。我们首先要知道：电脑中的声音文件是用数字0和1来表示的。所以在电脑上录音的本质就是把模拟声音信号转换成数字信号。
+
+反之，在播放时则是把数字信号还原成模拟声音信号输出。采集卡的位是指采集卡在采集和播放声音文件时所使用数字声音信号的二进制位数。采集卡的位客观地反映了数字声音信号对输入声音信号描述的准确程度。
+
+8位代表2的8次方—256，16位则代表2的16次方—64K。比较一下，一段相同的音乐信息，16位声卡能把它分为64K个精度单位进行处理，而8位声卡只能处理256个精度单位，造成了较大的信号损失，最终的采样效果自然是无法相提并论的。
+
+
+采样频率：是指录音设备在一秒钟内对声音信号的采样次数，采样频率越高声音的还原就越真实越自然。在当今的主流采集卡上，采样频率一般共分为22.05KHz、44.1KHz、48KHz三个等级，22.05KHz只能达到FM广播的声音品质，44.1KHz则是理论上的CD音质界限，48KHz则更加精确一些。对于高于48KHz的采样频率人耳已无法辨别出来了，所以在电脑上没有多少使用价值。
+
+
+
 ***声道***：目前人们所使用的各种声场技术规范非常多，但最常见的几乎都来自三家公司，他们是`Dolby`（杜比）、`HTX`和`DTS`。
 
 声卡所支持的声道数是衡量声卡档次的重要指标之一，从单声道到最新的环绕立体声，下面一一详细介绍：
@@ -212,10 +256,55 @@
 YUV
 ---
 
-YUV(也成YCbCr)是电视系统所采用的一种颜色编码方法，他是一种亮度与色度分离的色彩格式。其中Y表示明亮度也就是灰阶值，它是基础信号。U表示色度，V表示浓度，UV的作用是描述影像色彩及饱和度，它们用于指定像素的颜色。U和V不是基础信号，他俩都是被正交调制的。早期的电视都是黑白的，即只有亮度值(Y)，有了彩色电视之后，加入了UV两种色度，形成现在的YUV，也叫YCbCr。人眼对亮度敏感，对色度不敏感，因此减少部分UV的数据量，人眼也无法感知出来，这样就可以通过压缩UV的分辨率，在不影响观感的前提下，减少视频的体积。
+YUV(也成YCbCr)是电视系统所采用的一种颜色编码方法，他是一种亮度与色度分离的色彩格式。
+- 其中Y表示明亮度(Luminance或Luma)也就是灰阶值，它是基础信号。
+- U表示色度
+- V表示浓度
+UV的作用是描述影像色彩及饱和度，它们用于指定像素的颜色。
+U和V不是基础信号，他俩都是被正交调制的。早期的电视都是黑白的，即只有亮度值(Y)，有了彩色电视之后，加入了UV两种色度，形成现在的YUV。
+人眼对亮度敏感，对色度不敏感，因此减少部分UV的数据量，人眼也无法感知出来，这样就可以通过压缩UV的分辨率，在不影响观感的前提下，减少视频的体积。
 
 YUV和RGB视频信号相比，最大的优点在于只需要占用极少的带宽，YUV只需要占用RGB一般的带宽。
 
+YUV码流的存储格式其实与其采样的方式密切相关，主流的采样方式有四种，
+- YUV 4:4:4
+YUV三个信道的抽样率相同，因此在生成的图像里，每个象素的三个分量信息完整（每个分量通常8比特），经过8比特量化之后，未经压缩的每个像素占用3个字节。
+
+　　下面的四个像素为: [Y0 U0 V0] [Y1 U1 V1] [Y2 U2 V2] [Y3 U3 V3]
+
+　　存放的码流为: Y0 U0 V0 Y1 U1 V1 Y2 U2 V2 Y3 U3 V3
+
+- YUV 4:2:2 
+每个色差信道的抽样率是亮度信道的一半，所以水平方向的色度抽样率只是4:4:4的一半。对非压缩的8比特量化的图像来说，每个由两个水平方向相邻的像素组成的宏像素需要占用4字节内存。
+
+　　下面的四个像素为：[Y0 U0 V0] [Y1 U1 V1] [Y2 U2 V2] [Y3 U3 V3]
+
+　　存放的码流为：Y0 U0 Y1 V1 Y2 U2 Y3 V3
+
+　　映射出像素点为：[Y0 U0 V1] [Y1 U0 V1] [Y2 U2 V3] [Y3 U2 V3]
+- YUV 4:2:0 
+4:2:0并不意味着只有Y，Cb而没有Cr分量。它指得是对每行扫描线来说，只有一种色度分量以2:1的抽样率存储。相邻的扫描行存储不同的色度分量，也就是说，如果一行是4:2:0的话，下一行就是4:0:2，再下一行是4:2:0...以此类推。对每个色度分量来说，水平方向和竖直方向的抽样率都是2:1，所以可以说色度的抽样率是4:1。对非压缩的8比特量化的视频来说，每个由2x2个2行2列相邻的像素组成的宏像素需要占用6字节内存。
+
+　　下面八个像素为：[Y0 U0 V0] [Y1 U1 V1] [Y2 U2 V2] [Y3 U3 V3]
+
+　　[Y5 U5 V5] [Y6 U6 V6] [Y7U7 V7] [Y8 U8 V8]
+
+　　存放的码流为：Y0 U0 Y1 Y2 U2 Y3
+
+　　Y5 V5 Y6 Y7 V7 Y8
+
+　　映射出的像素点为：[Y0 U0 V5] [Y1 U0 V5] [Y2 U2 V7] [Y3 U2 V7]
+
+　　[Y5 U0 V5] [Y6 U0 V5] [Y7U2 V7] [Y8 U2 V7]
+- YUV 4:1:1 
+4:1:1的色度抽样，是在水平方向上对色度进行4:1抽样。对于低端用户和消费类产品这仍然是可以接受的。对非压缩的8比特量化的视频来说，每个由4个水平方向相邻的像素组成的宏像素需要占用6字节内存。
+
+　　下面的四个像素为: [Y0 U0 V0] [Y1 U1 V1] [Y2 U2 V2] [Y3 U3 V3]
+
+　　存放的码流为: Y0 U0 Y1 Y2 V2 Y3
+
+　　映射出像素点为：[Y0 U0 V2] [Y1 U0 V2] [Y2 U0 V2] [Y3 U0 V2]
+
 
 PAR DAR SAR
 ---
diff --git "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/\351\237\263\350\247\206\351\242\221\345\220\214\346\255\245\345\216\237\347\220\206.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/\351\237\263\350\247\206\351\242\221\345\220\214\346\255\245\345\216\237\347\220\206.md"
new file mode 100644
index 00000000..7fc9d5a0
--- /dev/null
+++ "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/\351\237\263\350\247\206\351\242\221\345\220\214\346\255\245\345\216\237\347\220\206.md"
@@ -0,0 +1,63 @@
+音视频同步原理
+===
+
+
+为什么需要音视频同步？
+
+媒体数据经过解复用流程后，音频/视频解码便是独立的，也是独立播放的。而在音频流和视频流中，其播放速度都是有相关信息指定的：
+- 视频：帧率，表示视频一秒显示的帧数。
+- 音频：采样率，表示音频一秒播放的样本的个数。
+
+从帧率及采样率，即可知道视频/音频播放速度。声卡和显卡均是以一帧数据来作为播放单位，如果单纯依赖帧率及采样率来进行播放，在理想条件下，应该是同步的，不会出现偏差。
+
+以一个44.1KHz的AAC音频流和24FPS的视频流为例：
+
+一个AAC音频frame每个声道包含1024个采样点，则一个frame的播放时长(duration)为：(1024/44100)×1000ms = 23.22ms；一个视频frame播放时长(duration)为：1000ms/24 = 41.67ms。理想情况下，音视频完全同步。 
+但实际情况下，如果用上面那种简单的方式，慢慢的就会出现音视频不同步的情况，要不是视频播放快了，要么是音频播放快了。可能的原因如下：
+
+一帧的播放时间，难以精准控制。音视频解码及渲染的耗时不同，可能造成每一帧输出有一点细微差距，长久累计，不同步便越来越明显。（例如受限于性能，42ms才能输出一帧）
+
+音频输出是线性的，而视频输出可能是非线性，从而导致有偏差。
+
+媒体流本身音视频有差距。（特别是TS实时流，音视频能播放的第一个帧起点不同）
+
+所以，解决音视频同步问题，引入了时间戳：
+
+首先选择一个参考时钟（要求参考时钟上的时间是线性递增的）；
+
+编码时依据参考时钟上的给每个音视频数据块都打上时间戳；
+
+播放时，根据音视频时间戳及参考时钟，来调整播放。
+
+所以，视频和音频的同步实际上是一个动态的过程，同步是暂时的，不同步则是常态。以参考时钟为标准，放快了就减慢播放速度；播放快了就加快播放的速度。
+
+### DTS、PTS
+
+- DTS（Decoding Time Stamp）：即解码时间戳，这个时间戳的意义在于告诉播放器该在什么时候解码这一帧的数据。
+
+- PTS（Presentation Time Stamp）：即显示时间戳，这个时间戳用来告诉播放器该在什么时候显示这一帧的数据。
+
+当视频流中没有 B 帧时，通常 DTS 和 PTS 的顺序是一致的。但如果有 B 帧时，就回到了我们前面说的问题：解码顺序和播放顺序不一致了，即视频输出是非线性的。
+
+比如一个视频中，帧的显示顺序是：I B B P，因为B帧解码需要依赖P帧，因此这几帧在视频流中的顺序可能是：I P B B，这时候就体现出每帧都有 DTS 和 PTS 的作用了。DTS 告诉我们该按什么顺序解码这几帧图像，PTS 告诉我们该按什么顺序显示这几帧图像。流中P帧在B帧之前，但显示确实在B帧之后。
+
+
+实现音视频同步，在播放时，需要选定一个参考时钟，读取帧上的时间戳，同时根据的参考时钟来动态调节播放。现在已经知道时间戳就是PTS，那么参考时钟的选择一般来说有以下三种：
+
+- 将视频同步到音频上：就是以音频的播放速度为基准来同步视频。
+- 将音频同步到视频上：就是以视频的播放速度为基准来同步音频。
+- 将视频和音频同步外部的时钟上：选择一个外部时钟为基准，视频和音频的播放速度都以该时钟为标准。
+
+当播放源比参考时钟慢，则加快其播放速度，或者丢弃；快了，则延迟播放。
+这三种是最基本的策略，考虑到人对声音的敏感度要强于视频，频繁调节音频会带来较差的观感体验，且音频的播放时钟为线性增长，所以一般会以音频时钟为参考时钟，视频同步到音频上。
+
+调整策略可以尽量采用渐进的方式，因为音视频同步是一个动态调节的过程，一次调整让音视频PTS完全一致，没有必要，且可能导致播放异常较为明显。
+
+调整策略仅仅对早到的或晚到的数据块进行延迟或加快处理，有时候是不够的。如果想要更加主动并且有效地调节播放性能，需要引入一个反馈机制，也就是要将当前数据流速度太快或太慢的状态反馈给“源”，让源去放慢或加快数据流的速度。
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/VideoDevelopment/FFmpeg/FFmpeg\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214.md" "b/VideoDevelopment/FFmpeg/FFmpeg\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214.md"
new file mode 100644
index 00000000..48913990
--- /dev/null
+++ "b/VideoDevelopment/FFmpeg/FFmpeg\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214.md"
@@ -0,0 +1,286 @@
+FFmpeg常用命令行
+===
+### ffmpeg
+
+1.分离视频音频流
+
+ffmpeg -i input_file -vcodec copy -an output_file_video　　//分离视频流
+ffmpeg -i input_file -acodec copy -vn output_file_audio　　//分离音频流
+
+2.视频解复用
+
+ffmpeg –i test.mp4 –vcodec copy –an –f m4v test.264
+ffmpeg –i test.avi –vcodec copy –an –f m4v test.264
+
+3.视频转码
+
+ffmpeg –i test.mp4 –vcodec h264 –s 352*278 –an –f m4v test.264              //转码为码流原始文件
+ffmpeg –i test.mp4 –vcodec h264 –bf 0 –g 25 –s 352*278 –an –f m4v test.264  //转码为码流原始文件
+ffmpeg –i test.avi -vcodec mpeg4 –vtag xvid –qsame test_xvid.avi            //转码为封装文件
+//-bf B帧数目控制，-g 关键帧间隔控制，-s 分辨率控制
+
+4.视频封装
+
+ffmpeg –i video_file –i audio_file –vcodec copy –acodec copy output_file
+
+5.视频剪切
+
+ffmpeg –i test.avi –r 1 –f image2 image-%3d.jpeg        //提取图片
+ffmpeg -ss 0:1:30 -t 0:0:20 -i input.avi -vcodec copy -acodec copy output.avi    //剪切视频
+//-r 提取图像的频率，-ss 开始时间，-t 持续时间
+
+6.视频录制
+
+ffmpeg –i rtsp://192.168.3.205:5555/test –vcodec copy out.avi
+
+7.YUV序列播放
+
+ffplay -f rawvideo -video_size 1920x1080 input.yuv
+
+8.YUV序列转AVI
+
+ffmpeg –s w*h –pix_fmt yuv420p –i input.yuv –vcodec mpeg4 output.avi
+
+常用参数说明：
+
+主要参数： -i 设定输入流 -f 设定输出格式 -ss 开始时间 视频参数： -b 设定视频流量，默认为200Kbit/s -r 设定帧速率，默认为25 -s 设定画面的宽与高 -aspect 设定画面的比例 -vn 不处理视频 -vcodec 设定视频编解码器，未设定时则使用与输入流相同的编解码器 音频参数： -ar 设定采样率 -ac 设定声音的Channel数 -acodec 设定声音编解码器，未设定时则使用与输入流相同的编解码器 -an 不处理音频
+
+------------------------------------------------------------------------
+
+----------------------------------------------------------------------------------------------------------
+
+------------------------------------------------------------------------
+
+0.压缩转码mp4文件
+
+ffmpeg -i input.avi -s 640x480 output.avi
+
+ffmpeg -i input.avi -s vga output.avi
+
+ 
+
+1、将文件当做直播送至live
+
+ffmpeg -re -i localFile.mp4 -c copy -f flv rtmp://server/live/streamName
+
+2、将直播媒体保存至本地文件
+
+ 
+
+ffmpeg -i rtmp://server/live/streamName -c copy dump.flv
+
+3、将其中一个直播流，视频改用h264压缩，音频不变，送至另外一个直播服务流
+
+ 
+
+ffmpeg -i rtmp://server/live/originalStream -c:a copy -c:v libx264 -vpre slow -f flv rtmp://server/live/h264Stream
+
+ 
+
+4、将其中一个直播流，视频改用h264压缩，音频改用faac压缩，送至另外一个直播服务流
+
+ffmpeg -i rtmp://server/live/originalStream -c:a libfaac -ar 44100 -ab 48k -c:v libx264 -vpre slow -vpre baseline -f flv rtmp://server/live/h264Stream
+
+5、将其中一个直播流，视频不变，音频改用faac压缩，送至另外一个直播服务流
+
+ffmpeg -i rtmp://server/live/originalStream -acodec libfaac -ar 44100 -ab 48k -vcodec copy -f flv rtmp://server/live/h264_AAC_Stream
+
+6、将一个高清流，复制为几个不同视频清晰度的流重新发布，其中音频不变
+
+ffmpeg -re -i rtmp://server/live/high_FMLE_stream -acodec copy -vcodec x264lib -s 640×360 -b 500k -vpre medium -vpre baseline rtmp://server/live/baseline_500k -acodec copy -vcodec x264lib -s 480×272 -b 300k -vpre medium -vpre baseline rtmp://server/live/baseline_300k -acodec copy -vcodec x264lib -s 320×200 -b 150k -vpre medium -vpre baseline rtmp://server/live/baseline_150k -acodec libfaac -vn -ab 48k rtmp://server/live/audio_only_AAC_48k
+
+7、功能一样，只是采用-x264opts选项
+
+ffmpeg -re -i rtmp://server/live/high_FMLE_stream -c:a copy -c:v x264lib -s 640×360 -x264opts bitrate=500:profile=baseline:preset=slow rtmp://server/live/baseline_500k -c:a copy -c:v x264lib -s 480×272 -x264opts bitrate=300:profile=baseline:preset=slow rtmp://server/live/baseline_300k -c:a copy -c:v x264lib -s 320×200 -x264opts bitrate=150:profile=baseline:preset=slow rtmp://server/live/baseline_150k -c:a libfaac -vn -b:a 48k rtmp://server/live/audio_only_AAC_48k
+
+8、将当前摄像头及音频通过DSSHOW采集，视频h264、音频faac压缩后发布
+
+ffmpeg -r 25 -f dshow -s 640×480 -i video=”video source name”:audio=”audio source name” -vcodec libx264 -b 600k -vpre slow -acodec libfaac -ab 128k -f flv rtmp://server/application/stream_name
+
+9、将一个JPG图片经过h264压缩循环输出为mp4视频
+
+ffmpeg.exe -i INPUT.jpg -an -vcodec libx264 -coder 1 -flags +loop -cmp +chroma -subq 10 -qcomp 0.6 -qmin 10 -qmax 51 -qdiff 4 -flags2 +dct8x8 -trellis 2 -partitions +parti8x8+parti4x4 -crf 24 -threads 0 -r 25 -g 25 -y OUTPUT.mp4
+
+10、将普通流视频改用h264压缩，音频不变，送至高清流服务(新版本FMS live=1)
+
+ffmpeg -i rtmp://server/live/originalStream -c:a copy -c:v libx264 -vpre slow -f flv “rtmp://server/live/h264Stream live=1〃
+
+
+------------------------------------------------------------------------
+
+----------------------------------------------------------------------------------------------------------
+
+------------------------------------------------------------------------
+
+ 
+
+1.采集usb摄像头视频命令：
+
+ffmpeg -t 20 -f vfwcap -i 0 -r 8 -f mp4 cap1111.mp4
+
+ 
+
+./ffmpeg -t 10 -f vfwcap -i 0 -r 8 -f mp4 cap.mp4
+
+具体说明如下：我们采集10秒，采集设备为vfwcap类型设备，第0个vfwcap采集设备（如果系统有多个vfw的视频采集设备，可以通过-i num来选择），每秒8帧，输出方式为文件，格式为mp4。
+
+ 
+
+2.最简单的抓屏：
+
+ffmpeg -f gdigrab -i desktop out.mpg 
+
+ 
+
+3.从屏幕的（10,20）点处开始，抓取640x480的屏幕，设定帧率为5 ：
+
+ffmpeg -f gdigrab -framerate 5 -offset_x 10 -offset_y 20 -video_size 640x480 -i desktop out.mpg 
+
+ 
+
+4.ffmpeg从视频中生成gif图片：
+
+ffmpeg -i capx.mp4 -t 10 -s 320x240 -pix_fmt rgb24 jidu1.gif
+
+
+### ffplay
+ffplay是以FFmpeg框架未基础，外加渲染音视频的库libSDL构建的媒体文件播放器。
+
+ffplay [选项] [输入文件]
+
+```
+ffplay /Users/xxx/Desktop/111.mp4
+ffplay http://219.151.31.38/liveplay-kk.rtxapp.com/live/program/live/hnwshd/4000000/mnf.m3u8
+```
+如果按s键就可以进入frame-step模式，即按s键一次就会播放下一帧图像。
+
+##### 主要选项
+
+- '-x width'        强制以 "width" 宽度显示
+- '-y height'       强制以 "height" 高度显示
+- '-an'             禁止音频
+- '-vn'             禁止视频
+- '-ss pos'         跳转到指定的位置(秒)
+- '-t duration'     播放 "duration" 秒音/视频
+- '-bytes'          按字节跳转
+- '-nodisp'         禁止图像显示(只输出音频)
+- '-f fmt'          强制使用 "fmt" 格式
+- '-window_title title'  设置窗口标题(默认为输入文件名)
+- '-loop number'    循环播放 "number" 次(0将一直循环)
+- '-showmode mode'  设置显示模式
+	- 可选的 mode ：
+	- '0, video'    显示视频
+	- '1, waves'    显示音频波形
+	- '2, rdft'     显示音频频带
+	- 默认值为 'video'，你可以在播放进行时，按 "w" 键在这几种模式间切换
+- '-i input_file'   指定输入文件
+- '-sync type'          设置主时钟为音频、视频、或者外部。默认为音频。主时钟用来进行音视频同步
+- '-threads count'      设置线程个数
+- '-autoexit'           播放完成后自动退出
+- '-exitonkeydown'      任意键按下时退出
+- '-exitonmousedown'    任意鼠标按键按下时退出
+- '-acodec codec_name'  强制指定音频解码器为 "codec_name"
+- '-vcodec codec_name'  强制指定视频解码器为 "codec_name"
+- '-scodec codec_name'  强制指定字幕解码器为 "codec_name"
+
+如果希望从视频的第30秒开始播放，播放10秒钟的文件，则可以使用如下命令 
+`ffplay -ss 30 -t 10 /Users/xxx/Desktop/111.mp4`
+
+##### 音画同步
+
+ffplay也是一个视频播放器，所以不得不提出来的一个问题是：音画同步。
+ffplay的音画同步的实现方式其实有三种，分别是：
+- 以音频为主时间轴作为同步源
+- 以视频为主时间轴作为同步源
+- 以外部时钟为主时间轴作为同步源。
+
+下面就以音频为主时间轴来作为同步源来作为案例进行讲解，而且ffplay默认也是以音频为基准进行对齐的，那么以音频作为对齐基准是如何实现的呢？
+
+首先需要说明的是，播放器接收到的视频帧或者音频帧，内部都是会有时间戳（PTS时钟）来标识它实际应该在什么时刻展示，实际的对齐策略如下：
+    比较视频当前的播放时间和音频当前的播放时间，如果视频播放过快，则通过加大延迟或者重复播放来降低视频播放速度，如果视频播放慢了，则通过减小延迟或者丢帧来追赶音频播放的时间点。
+    关键就在于音视频时间的比较和延迟的计算，当前在比较的过程中会设置一个阈值，如果超过预设的阈值就应该作出调整（丢帧或者重复渲染），这就是整个对齐策略。
+
+在使用ffplay的时候，我们可以明确的指定使用那种对齐方式，比如： 
+`ffplay test.mp4 -sync audio`
+上面这个命令显式的指定了使用以音频为基准进行音视频同步的方式播放视频文件，当然这也是ffplay的默认播放设置。
+`ffplay test.mp4 -sync video`
+上面这个命令显式的指定了使用以视频为基准进行音视频同步的方式播放视频文件。
+`ffplay test.mp4 -sync ext`
+上面这个命令显式的指定了使用外部时钟为基准进行音视频同步的方式播放视频文件。
+
+
+### ffprobe
+ffprobe是ffmpeg命令行中用来查看媒体文件格式的工具。 
+
+命令格式: 
+`ffprobe [文件名]`
+
+```
+ffprobe /Users/xxx/Desktop/111.mp4
+
+ffprobe version 4.4 Copyright (c) 2007-2021 the FFmpeg developers
+  built with Apple clang version 12.0.5 (clang-1205.0.22.9)
+  configuration: --prefix=/usr/local/Cellar/ffmpeg/4.4_2 --enable-shared --enable-pthreads --enable-version3 --cc=clang --host-cflags= --host-ldflags= --enable-ffplay --enable-gnutls --enable-gpl --enable-libaom --enable-libbluray --enable-libdav1d --enable-libmp3lame --enable-libopus --enable-librav1e --enable-librubberband --enable-libsnappy --enable-libsrt --enable-libtesseract --enable-libtheora --enable-libvidstab --enable-libvorbis --enable-libvpx --enable-libwebp --enable-libx264 --enable-libx265 --enable-libxml2 --enable-libxvid --enable-lzma --enable-libfontconfig --enable-libfreetype --enable-frei0r --enable-libass --enable-libopencore-amrnb --enable-libopencore-amrwb --enable-libopenjpeg --enable-libspeex --enable-libsoxr --enable-libzmq --enable-libzimg --disable-libjack --disable-indev=jack --enable-avresample --enable-videotoolbox
+  libavutil      56. 70.100 / 56. 70.100
+  libavcodec     58.134.100 / 58.134.100
+  libavformat    58. 76.100 / 58. 76.100
+  libavdevice    58. 13.100 / 58. 13.100
+  libavfilter     7.110.100 /  7.110.100
+  libavresample   4.  0.  0 /  4.  0.  0
+  libswscale      5.  9.100 /  5.  9.100
+  libswresample   3.  9.100 /  3.  9.100
+  libpostproc    55.  9.100 / 55.  9.100
+Input #0, mov,mp4,m4a,3gp,3g2,mj2, from '/Users/xuchuanren/Desktop/111.mp4':
+  Metadata:
+    major_brand     : isom
+    minor_version   : 512
+    compatible_brands: isomiso2avc1mp41
+    encoder         : Multimedia Cloud Transcode (cloud.baidu.com)
+    comment         : Content Adaptive Encoding 3.0
+  Duration: 00:00:41.52, start: 0.000000, bitrate: 163 kb/s  // 视频的时长是41秒52毫秒，开始播放时间是0，，整个文件的比特率是163Kbit/s
+  Stream #0:0(und): Video: h264 (High) (avc1 / 0x31637661), yuv420p, 1280x720 [SAR 1:1 DAR 16:9], 91 kb/s, 25 fps, 25 tbr, 12800 tbn, 50 tbc (default)
+  // 上面这一行的信息是，第一个流是视频流，编码格式是h264格式(封装格式是AVC1)，每一帧的数据表示为yuv420p，分辨率为1280*720.这路流的比特率为91Kbit/s，帧率为每秒钟25帧
+    Metadata:
+      handler_name    : VideoHandler
+      vendor_id       : [0][0][0][0]
+  Stream #0:1(und): Audio: aac (LC) (mp4a / 0x6134706D), 44100 Hz, stereo, fltp, 65 kb/s (default)
+  // 上面这一行的信息是，第二个流为音频流，编码方式为ACC(封装格式为MP4A),并且采用的Profile是LC规格，采样率是44.1KHz，声道是立体声，这路流的比特率是65Kbit/s
+    Metadata:
+      handler_name    : SoundHandler
+      vendor_id       : [0][0][0][0]
+```
+
+查看流的格式信息
+ffprobe -show_format -i /Users/xxx/Desktop/111.mp4 
+
+```
+[FORMAT]
+filename=/Users/xxx/Desktop/111.mp4
+nb_streams=2
+nb_programs=0
+format_name=mov,mp4,m4a,3gp,3g2,mj2
+format_long_name=QuickTime / MOV
+start_time=0.000000
+duration=41.518000
+size=848895
+bit_rate=163571
+probe_score=100
+TAG:major_brand=isom
+TAG:minor_version=512
+TAG:compatible_brands=isomiso2avc1mp41
+TAG:encoder=Multimedia Cloud Transcode (cloud.baidu.com)
+TAG:comment=Content Adaptive Encoding 3.0
+[/FORMAT]
+```
+查看每一帧信息
+ffprobe -show_frames -i /Users/xxx/Desktop/111.mp4 
+
+查看包信息
+ffprobe -show_packets -i /Users/xxx/Desktop/111.mp4 
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/VideoDevelopment/FFmpeg/FFmpeg\347\256\200\344\273\213.md" "b/VideoDevelopment/FFmpeg/FFmpeg\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..5e5d1c78
--- /dev/null
+++ "b/VideoDevelopment/FFmpeg/FFmpeg\347\256\200\344\273\213.md"
@@ -0,0 +1,27 @@
+FFmpeg简介
+===
+
+FFmpeg是一个开源免费跨平台的视频和音频流方案，属于自由软件，采用LGPL或GPL许可证（依据你选择的组件）。它提供了录制、转换以及流化音视频的完整解决方案。它包含了非常先进的音频/视频编解码库libavcodec，为了保证高可移植性和编解码质量，libavcodec里很多codec都是从头开发的。
+
+主要的开发库：
+
+- libavutil：包含一些公共的工具函数，包括随机数生成、数据结构、核心多媒体工具等；
+- libavcodec：用于各种类型声音/图像encode/decode编解码库；
+- libavformat：用于各种音视频封装格式（mp4/AVI/Flv等）的生成和解析muxer/demuxer，包括获取解码所需信息以生成解码上下文结构和读取音视频帧等功能；
+- libavdevice:读取电脑（或者其他设备上）的多媒体设备的数据 或者输出数据到指定的多媒体设备上；
+- libswresample: 用于音频采样采样数据（PCM）转换的库；
+- libswscale：用于视频场景比例缩放、色彩映射转换的库；
+- libavfilter: 包含媒体滤波器的库
+
+主要的工具集：
+
+- ffmpeg：一个命令行工具，可用于格式转换、解码、编码等；
+- ffsever：一个 HTTP 、RTSP的实时广播流媒体服务器；
+- ffplay：是一个简单的播放器，使用ffmpeg 库解析和解码，通过SDL显示；
+- ffprobe : 一个多媒体流分析工具。 它从多媒体流中收集信息 并且以人类和机器可读的形式打印出来。
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/RTMP.md" "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/RTMP.md"
index ed3d7a1a..425d5974 100644
--- "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/RTMP.md"
+++ "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/RTMP.md"
@@ -1,8 +1,6 @@
 RTMP
 ===
 
-
-
 Real Time Messaging Protocol(实时消息传送协议):是Adobe Systems公司为Flash播放器和服务器之间音频、视频和数据传输开发的开放协议。协议基于`TCP`，是一个协议族(默认端口1935)，包括RTMP基本协议及RTMPT/RTMPS/RTMPE等多种变种。RTMP 是一种设计用来进行实时数据通信的网络协议，主要用来在Flash/AIR平台和支持RTMP协议的流媒体/交互服务器之间进行音视频和数据通信。市面上绝大部分PC秀场使用的都是它，他有低延迟(2s左右)、稳定性高、技术完善、高支持度、编码兼容性高等特点。但是RTMP协议不使用标准的HTTP接口传输数据(TCP、UDP端口)，所以在一些特殊的网络环境下可能被防火墙屏蔽掉。默认端口号：1935
 
 RTMP的整体流程为:  
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/FLV.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/FLV.md"
index 15f1f6e5..fc651d43 100644
--- "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/FLV.md"
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/FLV.md"
@@ -2,15 +2,18 @@ FLV
 ===
 
 
-
-FLV封装格式是由一个文件头（FLV header）和很多tag组成（FLV body）组成的二进制文件。Tag中包含了音频数据以及视频数据。FLV的结构如下图所示。
+FLV封装格式是由一个文件头（FLV header）和很多tag组成的（FLV body）二进制文件。
+Tag中包含了音频数据以及视频数据，每个Tag又有一个preTagSize字段，标记着前面一个Tag的大小，FLV的结构如下图所示。
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_tag.jpg?raw=true)
 
 
+tag又可以分成三类:
+- Audio Tag：音频流
+- Video Tag：视频流
+- Script Tag：脚本流，又称Metadata Tag
 
-tag又可以分成三类:audio,video,script，分别代表音频流，视频流，脚本流，而每个tag又由tag header和tag data组成。
-
+每个tag又由tag header和tag data组成。一般一个flv文件由一个头部信息，一个script Tag，以及若干个video Tag和audio Tag组成。
 
 
 #### FLV整体结构图：
@@ -18,84 +21,74 @@ tag又可以分成三类:audio,video,script，分别代表音频流，视频流
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_tag.jpg?raw=true)
 
 
-
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_header_tag.png?raw=true)
 
 
-
 #### FLV文件头结构图
 
-
-
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_tag_2.png?raw=true)   
 
-
-
-​    FLV文件头由9bytes组成，前3个bytes是文件类型，总是“FLV”，也就是（0x46 0x4C 0x56）。第4btye是版本号，目前一般是0x01。第5byte是流的信息，倒数第一bit是1表示有视频（0x01），倒数第三bit是1表示有音频（0x4），有视频又有音频就是0x01 | 0x04（0x05），其他都应该是0。最后4bytes表示FLV 头的长度，3+1+1+4 = 9。
+FLV文件头由9bytes组成，前3个bytes是文件类型，总是“FLV”，也就是（0x46 0x4C 0x56）。
+第4btye是版本号，目前一般是0x01。第5byte是流的信息，倒数第一bit是1表示有视频（0x01），倒数第三bit是1表示有音频（0x4），有视频又有音频就是0x01 | 0x04（0x05），其他都应该是0。最后4bytes表示FLV 头的长度，3+1+1+4 = 9。
 
 ２、 FLV body结构分析
 
-​    FLV body由若干个tag 组成。每一个tag第一部分是tag header，tag header长度为11bytes，但是每个tag header前面有4bytes记录着上一个tag的长度。
+FLV body由若干个tag 组成。每一个tag第一部分是tag header，tag header长度为11bytes，但是每个tag header前面有4bytes记录着上一个tag的长度。
 
-​    tag结构图：
+tag结构图：
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_body_tag.png?raw=true)   
 
-​    tag header：
+tag header：
 
-​    １）第1个byte为记录着tag的类型，音频（0x8），视频（0x9），脚本（0x12）；
+１）第1个byte为记录着tag的类型，音频（0x8），视频（0x9），脚本（0x12）；
 
-​    ２）第2到4bytes是数据区的长度，也就是tag data的长度；
+２）第2到4bytes是数据区的长度，也就是tag data的长度；
 
-​    ３）再后面3个bytes是时间戳，单位是毫秒，类型为0x12则时间戳为0，时间戳控制着文件播放的速度，可以根据音视频的帧率类设置；
+３）再后面3个bytes是时间戳，单位是毫秒，类型为0x12则时间戳为0，时间戳控制着文件播放的速度，可以根据音视频的帧率类设置；
 
-​    ４）时间戳后面一个byte是扩展时间戳，时间戳不够长的时候用；
+４）时间戳后面一个byte是扩展时间戳，时间戳不够长的时候用；
 
-​    ５）最后3bytes是streamID，但是总为0，再后面就是数据区了（tag data），也即是h264的裸流；
+５）最后3bytes是streamID，但是总为0，再后面就是数据区了（tag data），也即是h264的裸流；
 
-​    ６）tag header 长度为1+3+3+1+3=11。
+６）tag header 长度为1+3+3+1+3=11。
 
-​    音频TagData结构分析：
+音频TagData结构分析：
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_audio_tag.png?raw=true)   
 
-​    音频参数中各字段的值及其意义如下表所示：
-
+音频参数中各字段的值及其意义如下表所示：
 
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_audio_tag2.png?raw=true)   
 
- 音频参数对照表
+音频参数对照表
 
-​    视频TagData结构：
+视频TagData结构：
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_video_tag.png?raw=true)   
 
+Script TagData结构
 
-
-​    Script TagData结构
-
-​    Script Tag通常被称为Metadata Tag，会放一些关于FLV视频和音频的元数据信息如：duration、width、height等。通常此类型Tag会跟在File Header后面作为第一个Tag出现，而且只有一个。
+Script Tag通常被称为Metadata Tag，会放一些关于FLV视频和音频的元数据信息如：duration、width、height等。通常此类型Tag会跟在File Header后面作为第一个Tag出现，而且只有一个。
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_script_tag.png?raw=true)   
 
 
 
+第一个AMF包：
 
-
-​    第一个AMF包：
-
-​    第1个字节表示AMF包类型，一般总是0x02，表示字符串。第2-3个字节为UI16类型值，标识字符串的长度，一般总是 0x000A（“onMetaData”长度）。后面字节为具体的字符串，一般  为“onMetaData”（6F,6E,4D,65,74,61,44,61,74,61）。
+第1个字节表示AMF包类型，一般总是0x02，表示字符串。第2-3个字节为UI16类型值，标识字符串的长度，一般总是 0x000A（“onMetaData”长度）。后面字节为具体的字符串，一般  为“onMetaData”（6F,6E,4D,65,74,61,44,61,74,61）。
 
 所以第一个AMF包总共占13字节。
 
-​    第二个AMF包结构图：
+第二个AMF包结构图：
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_awf_tag.png?raw=true)   
 
  第二个AMF包结构图
 
-​    第1个字节表示AMF包类型，一般总是0x08，表示数组。第2-5个字节为UI32类型值，表示数组元素的个数，后面即为各数组元素的封装。数组元素为元素名称和值组成的对。“数组元素结构”部分是推测，已经确认适用于duration、width、height等常见元素，但并不确认适用于所有元素。常见的数组元素如下表所示。
+第1个字节表示AMF包类型，一般总是0x08，表示数组。第2-5个字节为UI32类型值，表示数组元素的个数，后面即为各数组元素的封装。数组元素为元素名称和值组成的对。“数组元素结构”部分是推测，已经确认适用于duration、width、height等常见元素，但并不确认适用于所有元素。常见的数组元素如下表所示。
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_amf_tag.jpg?raw=true)   
 
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/TS.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/TS.md"
index 947ab46a..6b0e0dc2 100644
--- "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/TS.md"
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/TS.md"
@@ -1,8 +1,6 @@
 TS
 ===
 
-
-
 TS的全称为MPEG2-TS，TS即Transport Stream的缩写。它是分包发送的，每一个包长188字节（还有192和204字节的包）。包的结构为，包头4字节（第一个字节为0x47），负载为184字节。
 
 VD的音视频格式为MPEG2-PS，全称是Program Stream。而TS的全称则是Transport Stream。MPEG2-PS主要应用于存储的具有固定时长的节目，如DVD电影，而MPEG-TS则主要应用于实时传送的节目，比如实时广播的电视节目。这两种格式的主要区别是什么呢？简单地打个比喻说，你将DVD上的VOB文件的前面一截cut掉（或者干脆就是数据损坏），那么就会导致整个文件无法解码了，而电视节目是你任何时候打开电视机都能解码（收看）的。在TS流里可以填入很多类型的数据，如视频、音频、自定义信息等。所以，MPEG2-TS格式的特点就是要求从视频流的任一片段开始都是可以独立解码的。
@@ -17,12 +15,9 @@ TS文件（流）可以分为三层：TS层（Transport Stream）、PES层（Pac
 
 ES层就是音视频数据，PES层是在音视频数据上加了时间戳等对数据帧的说明信息，TS层是在PES层上加入了数据流识别和传输的必要信息。TS文件（码流）由多个TS Packet组成的。
 
-
-
 ![image-20210309114928103](https://raw.githubusercontent.com/CharonChui/Pictures/master/ts_archi.png?raw=true)
 
 
-
 ### TS层
 
 TS包大小固定为188字节，TS层分为三个部分：TS Header、Adaptation Field、Payload。
@@ -99,9 +94,6 @@ ES层指的就是音视频数据。
 一般的，视频为H.264视频，音频为AAC音频。
 
 
-
-
-
 ## TS流生成及解析流程
 
 ### TS 流生成流程
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/fMP4\346\240\274\345\274\217\350\257\246\350\247\243.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/fMP4\346\240\274\345\274\217\350\257\246\350\247\243.md"
index 539663d5..5b7b47c3 100644
--- "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/fMP4\346\240\274\345\274\217\350\257\246\350\247\243.md"
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/fMP4\346\240\274\345\274\217\350\257\246\350\247\243.md"
@@ -45,7 +45,14 @@ Fragmented MP4 以 Fragment 的方式存储视频信息。每个 Fragment 由一
 #### Movie Extends Box (mvex)(fMP4专有)
 
 **mvex 是 fMP4 的标准盒子。它的作用是告诉解码器这是一个fMP4的文件，具体的 samples 信息内容不再放到 trak 里面，而是在每一个 moof 中**。基本格式为：
-
+```
+aligned(8) class MovieExtendsHeaderBox extends FullBox(‘mehd’, version, 0) { if (version==1) {
+      unsigned int(64)  fragment_duration;
+   } else { // version==0
+      unsigned int(32)  fragment_duration;
+   }
+}
+```
 
 
 ### moof
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217.md"
index a81d1123..c98f5a96 100644
--- "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217.md"
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217.md"
@@ -1,17 +1,27 @@
 视频封装格式
 ===
 
-
 一个完整的视频文件，包括音频、视频和基础元信息，我们常见的视频文件如mp4、mov、flv、avi、rmvb等视频文件，就是一个容器的封装，里面包含了音频和视频两部分，并且都是通过一些特定的编码算法，进行编码压缩过后的。
 
 例如：将一个Xvid视频编码文件和一个MP3音频编码文件按AVI封装标准封装以后，就得到一个AVI后缀的视频文件。
 
-
-
 封装，也叫多路复用(mux)。封装的目的一般为了在一个文件（流）中能同时存储视频（video）、音频（audio）、字幕（subtitle）等内容——这也正是“复用”的含义所在（分时复用）。封装还有另一个作用是在网络环境下确保数据的可靠快速传输。
 
 编码的目的是为了压缩媒体数据。有别于通用文件数据的压缩，在图像或音频压缩的时候，可以借助图像特性（如前后关联、相邻图块关联）或声音特性（听觉模型）进行压缩，可以达到比通用压缩技术更高的压缩比。
 
+常用视频封装格式及对应的文件格式： 
+
+| 视频封装格式 | 视频文件格式 |
+
+| ------ | ------ | 
+
+| AVI(Audio Video Interleave) | AVI | 
+| WMV(Windows Media Video) | WMV | 
+| MPEG分为MPEG-1,MPEG-2,MPEG-4 | MPG MPEG VOB DAT 3GP MP4 | 
+| Matroska | MKV | 
+| Real Video | RM RMVB | 
+| QuickTime File Format | MOV | 
+| Flash Video | FLV | 
 
 
 
@@ -21,7 +31,7 @@
 
 #### 音频编码格式有如下:
 
-- AAC
+- AAC : Advanced Audio Coding
 - AMR
 - PCM
 - ogg(ogg vorbis音频)
@@ -30,11 +40,8 @@
 - APE(monkey’s 音频)
 - AU(sun 格式)
 - WMA
-
-音频编码方案之间音质比较（AAC，MP3，WMA等）结果： 
-
-AAC+ > MP3PRO > AAC> RealAudio > WMA > MP3
-目前最常见的音频格式有 Mp3、AC-3、ACC，MP3最广泛的支持最多，AC-3是杜比公司的技术，ACC是MPEG-4中的音频标准，ACC是目前比较先进和具有优势的技术。对应入门，知道有这几种最常见的音频格式足以。
+- MP3 
+    
 
 ## 视频编码格式
 
@@ -47,7 +54,7 @@ AAC+ > MP3PRO > AAC> RealAudio > WMA > MP3
 
 - Xvid(MPEG4)
 
-- H265
+- H265(High Efficiency Video Coding,简称 HEVC)
 
 - H264 
 
@@ -92,8 +99,6 @@ H.264最大的优势是具有很高的数据压缩比率，在同等图像质量
 
 
 
-
-
 为什么把flv叫做流式文件格式？ 和mp4，avi不是一样都是音视频的容器吗？ 有什么区别？
 
 通常说的流式文件是可以边传边解的，开始不需要整个文件。特点是有文件头信息（这个不是必需的）和中间打包了，可以直接解析分包，而且文件可以任意大小，而不需要通过索引分包。FLV，MPEG，RMVB等都可以直接依次分包解析，而MP4，AVI一定要依赖索引表才行，而且开始就要固定位置好，如果索引表在尾部，还没办法解析。

From 491fdcc3544638e4437692bb351503e9bd225142 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 14 Dec 2022 20:13:16 +0800
Subject: [PATCH 086/213] add notes

---
 ...66\346\236\204\347\256\200\344\273\213.md" |  73 +++-
 "Architect/2.UML\347\256\200\344\273\213.md"  |  17 +
 JavaKnowledge/.DS_Store                       | Bin 0 -> 6148 bytes
 ...70\350\247\201\347\256\227\346\263\225.md" | 117 -----
 ...60\346\215\256\347\273\223\346\236\204.md" | 200 +++++++--
 .../\347\256\227\346\263\225.md"              | 320 ++++++++++++++
 ...04\345\244\215\346\235\202\345\272\246.md" | 179 --------
 ...73\347\273\237\347\256\200\344\273\213.md" |  27 +-
 ...13\344\270\216\347\272\277\347\250\213.md" |  23 +-
 ...05\345\255\230\347\256\241\347\220\206.md" |  30 +-
 README.md                                     |   4 +-
 ...06\351\242\221\345\234\272\346\231\257.md" |  98 +++++
 .../FFmpeg/FFmpeg\345\210\207\347\211\207.md" |  12 +
 ...50\345\221\275\344\273\244\350\241\214.md" | 413 +++++++++++++-----
 .../FFmpeg/FFmpeg\347\256\200\344\273\213.md" |  46 +-
 .../FLV.md"                                   |  56 ++-
 .../M3U8.md"                                  |  84 ++++
 ...74\345\274\217\350\257\246\350\247\243.md" |   7 +-
 18 files changed, 1211 insertions(+), 495 deletions(-)
 create mode 100644 JavaKnowledge/.DS_Store
 delete mode 100644 "JavaKnowledge/\345\270\270\350\247\201\347\256\227\346\263\225.md"
 rename "JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204.md" => "JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\346\225\260\346\215\256\347\273\223\346\236\204.md" (55%)
 create mode 100644 "JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\347\256\227\346\263\225.md"
 delete mode 100644 "JavaKnowledge/\347\256\227\346\263\225\347\232\204\345\244\215\346\235\202\345\272\246.md"
 create mode 100644 "VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/\351\237\263\350\247\206\351\242\221\345\234\272\346\231\257.md"
 create mode 100644 "VideoDevelopment/FFmpeg/FFmpeg\345\210\207\347\211\207.md"
 create mode 100644 "VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/M3U8.md"

diff --git "a/Architect/1.\346\236\266\346\236\204\347\256\200\344\273\213.md" "b/Architect/1.\346\236\266\346\236\204\347\256\200\344\273\213.md"
index fe4d4cdc..6fa7327a 100644
--- "a/Architect/1.\346\236\266\346\236\204\347\256\200\344\273\213.md"
+++ "b/Architect/1.\346\236\266\346\236\204\347\256\200\344\273\213.md"
@@ -1,6 +1,46 @@
 1.系统架构
 ===
 
+#### 什么是系统架构
+
+关于系统架构，维基百科给出了一个非常好的定义。
+A system architecture is the conceptual model that defines the structure, behavior, and more views of a system.[
+(系统架构是概念模型，定义了系统的结构、行为和更多的视图)
+
+* 系统架构是一个概念模型。
+* 系统架构定义了系统的结构、行为以及更多的视图。
+关于这个定义，这里给出了另外一种解读，供大家参考。
+* 静。首先，从静止的角度，描述系统如何组成，以及系统的功能在这些组成部分之间是如何划分的。这就是系统的“结构”。一般要描述的是：系统包含哪些子系统，每个子系统有什么功能。在做这些描述时，应感觉自己是一名导游，带着游客在系统的子系统间参观。
+* 动。然后，从动态的角度，描述各子系统之间是如何联动的，它们是如何相互配合完成系统预定的任务或流程的。这就是系统的“行为”。在做这个描述时，应感觉自己是一名电影导演，将系统的各种运行情况通过一个个短片展现出来。
+* 细。最后，在以上两种描述的基础上，从不通的角度，更详细的刻画出系统的细节和全貌。这就是“更多的视图”。
+
+
+
+
+好代码的特性： 
+1. 鲁棒(Solid and Robust)
+2. 高效(Fast)
+3. 简洁(Maintainable and Simple)
+4. 简短(Small)
+5. 可测试(Testable)
+6. 共享(Re-Usable)
+7. 可移植(Portable)
+8. 可观测(Observvable)/可监控(Monitorable)
+9. 可运维(Operational): 可运维重点关注成本、效率和稳定性三个方面
+10. 可扩展(Scalable and Extensible)
+
+
+工程能力的定义： 
+使用系统化的方法，在保证质量的前提下，更高效率的为客户/用户持续交付有价值的软件或服务的能力。
+
+在《软件开发的201个原则》一书中，将“质量第一”列为全书的第一个原则，可见其重要性。
+Edward Yourdon建议，当你被要求加快测试、忽视剩余的少量Bug、在设计或需求达成一致前就开始编码时，要直接说“不”。
+开发前期的设计文档、技术评审3天以上100%。代码规范，缺乏认真的代码评审。
+降低质量要求，事实上不会降低研发成本，反而会增加整体的研发成本。在研发阶段通过降低质量所“节省”的研发成本，会在软件维护阶段加倍偿还。
+
+在研发前期(需求分析和系统设计)多投入资源，相对于把资源都投入在研发后期(编码、测试等)，其收益更大。
+
+
 ### 架构三要素
 
 #### 构件
@@ -27,9 +67,40 @@
 系统架构虽然是软件系统的结构，行为，属性的高级抽象，但其根本就是在需求分析的基础行为下，制定技术框架，对需求的技术实现。 
 
 
+### 系统设计的原则和方法： 
+
+* 单一目的
+* 对外关系清晰
+* 重视资源约束
+* 根据需求做决策
+* 基于模型思考
+
+
+#### 单一职责原则
+
+
+
+#### 开放-封闭原则
+无论模块是多么的‘封闭’，都会存在一些无法对之封闭的变化。既然不可能完全封闭，设计人员必须对于他设计的模块应该对哪种变化封闭做出选择。他必须先猜测出最有可能发生的变化种类，然后构造抽象来隔离那些变化
+
+开放-封闭原则是面向对象设计的核心所在。遵循这个原则可以带来面向对象技术所声称的巨大好处，也就是可维护、可扩展、可复用、灵活性好。开发人员应该仅对程序中呈现出频繁变化的那些部分做出抽象，然而，对于应用程序中的每个部分都刻意地进行抽象同样不是一个好主意。拒绝不成熟的抽象和抽象本身一样重要
+
+
+#### 依赖倒转原则
+
+
+
+#### 迪米特法则
+迪米特法则首先强调的前提是在类的结构设计上，每一个类都应当尽量降低成员的访问权限，也就是说，一个类包装好自己的private状态，不需要让别的类知道的字段或行为就不要公开
+
+我们在程序设计时，类之间的耦合越弱，越有利于复用，一个处在弱耦合的类被修改，不会对有关系的类造成波及。也就是说，信息的隐藏促进了软件的复用。”
+
+
+
+
+
 
 
-​		
 ---
 - 邮箱 ：charon.chui@gmail.com  
 - Good Luck! 
diff --git "a/Architect/2.UML\347\256\200\344\273\213.md" "b/Architect/2.UML\347\256\200\344\273\213.md"
index c0259a46..2bcf58de 100644
--- "a/Architect/2.UML\347\256\200\344\273\213.md"
+++ "b/Architect/2.UML\347\256\200\344\273\213.md"
@@ -2,6 +2,23 @@
 
 推荐使用[Visual Paradigm](https://www.visual-paradigm.com/cn/)，如果是非商业用途可以下载社区版，免费使用
 
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/uml_demo.png?raw=true)   
+
+
+类图分三层，第一层显示类的名称，如果是抽象类，则就用斜体显示。第二层是类的特性，通常就是字段和属性。第三层是类的操作，通常是方法或行为。注意前面的符号，‘+’表示public，‘-’表示private，‘#’表示protected。”
+
+继承关系用空心三角形+实线来表示。
+接口用空心三角形+虚线来表示。
+关联关系用实线箭头来表示。
+聚合表示一种弱的‘拥有’关系，体现的是A对象可以包含B对象，但B对象不是A对象的一部分。聚合关系用空心的菱形+实线箭头来表示。
+合成（Composition，也有翻译成‘组合’的）是一种强的‘拥有’关系，体现了严格的部分和整体的关系，部分和整体的生命周期一样.合成关系用实心的菱形+实线箭头来表示
+依赖关系（Dependency），用虚线箭头来表示。
+
+
+
+
 ## 类图
 
 ## 时序图
diff --git a/JavaKnowledge/.DS_Store b/JavaKnowledge/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..bf3070814d6f3de67d704daffef65ea47ad99cae
GIT binary patch
literal 6148
zcmeHK%}N6?5Kh`^Q;N`og5CmN3%33uUe>n0K)2{YrFPv?7q^?GKNcyKJ$SQsU%;2}
z?i+|6eHJG_6}1(;C@M2B`6iQ@Wb^Hk><~g|q3h-e$q+&qsKi(bnh7GurH)C=c%}iV
zoTD=AU;7VEuN^x6STs6*BLni?CF|jFaB<(beEt4}10%Oi=zHx>F84@d@x;`0k|kN1
z9oi?NXLo9yZo5!x?aN+82;UjmHD}kW_o|uMq6j)QFQ~Uvg6GyD<Y3PWT+u6tZs4|6
zuB``HilwTVg?@iyZ9U8L%el=#miIT8b6LK+vOXB3*xcgMR=IlWHv@5{xuo#fDVZ@i
zf*~01w&geS_OWP&qmc24rYMyhUu~R~!{YhV&E58-DEA9d;mK#Ko!PCx7eND7813TK
zqoIimAOpz2cQRm(9hUyiMR0Cp02%m`49N3=gG#gvMjF-80gWmF02AO=0=BFrWDYlI
z8H_Z-2nf}wfI5|$5`*e=@N*Mq8H_aQbV5z>LCwn4R47!f4)b#rPN=03TVwzkc*{Us
zcQf+--}$)yf189oWB?iXR}9cZ$u1ROOXhAJ+nl^>Ip`6n6d4z3d`SUAUBwV9ui|-7
aCE(}M0JIE78o>jCKLUydY><H;W#Ad@a);gk

literal 0
HcmV?d00001

diff --git "a/JavaKnowledge/\345\270\270\350\247\201\347\256\227\346\263\225.md" "b/JavaKnowledge/\345\270\270\350\247\201\347\256\227\346\263\225.md"
deleted file mode 100644
index 81add14e..00000000
--- "a/JavaKnowledge/\345\270\270\350\247\201\347\256\227\346\263\225.md"
+++ /dev/null
@@ -1,117 +0,0 @@
-常见算法
-===
-
-算法（Algorithm）是一系列解决问题的清晰指令，也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。如果一个算法有缺陷，或不适合于某个问题，
-执行这个算法将不会解决这个问题。不同的算法可能用不同的时间、空间或效率来完成同样的任务。一个算法的优劣可以用空间复杂度与时间复杂度来衡量。         
-算法可以理解为有基本运算及规定的运算顺序所构成的完整的解题步骤。或者看成按照要求设计好的有限的确切的计算序列，并且这样的步骤和序列可以解决一类问题。
-```java
-/**
- * 1到100所有素数的和
- * 素数就是只能够被1和自身整除的数
- */
-public class dd {
-    public static void main(String[] args) {
-        int i = 2; // i 即为所求素数
-        System.out.println("i= " + i);
-        for (i = 3; i <= 100; i = i + 2) {
-            boolean f = true;
-            Label: for (int j = 2; j < i; j++) {
-                if (i % j == 0) { // if(true)时，i为非素数
-                    f = false;
-                    break Label; // 加了Label貌似只是起到提高效率
-                }
-            }
-            if (f) {// 当f=true时，i为素数。
-                System.out.println("i= " + i);
-            }
-        }
-    }
-}
-
-/**
- *古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第四个月后每个月又生一对兔子，假如兔子都不死，
- *问每个月的兔子总数为多少？ 
- *
- */
-public class aa{
-    public static void main(String[] args) {
-        int i = 0;
-        for (i = 1; i < 20; i++) {
-            System.out.println(f(i));
-        }
-    }
-    
-    public static int f(int x) {
-        if(x==1||x==2) {
-            return 1;
-        }else {
-            return f(x-1)+f(x-2);
-        }
-    }
-}
-```
-
-3.有两个有序数组`a`,`b`,现需要将其合并成一个新的有序数组。
-
-简单的思路就是先放到一个新的数组中，再排序。但是这样的没体现任何算法，这里考的不是快速排序等排序算法。关键应该是如何利用`有序` 已知这个条件。可以这样想，假设两个源数组的长度不一样，那么假设其中短的数组用完了，即全部放入到新数组中去了，那么长数组中剩下的那一段就可以直接拿来放入到新数组中去了。
-
-其中用到的思想是:归并排序思想
-
-```java
-public static int[] merge(int[] a, int[] b) {
-    int lengthA = a.length;
-    int lengthB = b.length;
-    int[] result = new int[lengthA + lengthB];
-
-    //aIndex:用于标示a数组    bIndex：用来标示b数组  resultIndex：用来标示传入的数组
-    int aIndex = 0, bIndex = 0, resultIndex = 0;
-
-    while (aIndex < lengthA && bIndex < lengthB) {
-        if (a[aIndex] < b[bIndex]) {
-            result[resultIndex++] = a[aIndex];
-            aIndex++;
-        } else {
-            result[resultIndex++] = b[bIndex];
-            bIndex++;
-        }
-    }
-
-    // a有剩余
-    while (aIndex < lengthA) {
-        result[resultIndex++] = a[aIndex];
-        aIndex++;
-    }
-
-    // b有剩余
-    while (bIndex < lengthB) {
-        result[resultIndex++] = b[bIndex];
-        bIndex++;
-    }
-    return result;
-}
-````
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
diff --git "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204.md" "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\346\225\260\346\215\256\347\273\223\346\236\204.md"
similarity index 55%
rename from "JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204.md"
rename to "JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\346\225\260\346\215\256\347\273\223\346\236\204.md"
index b3f671cc..90661d16 100644
--- "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204.md"
+++ "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\346\225\260\346\215\256\347\273\223\346\236\204.md"
@@ -1,6 +1,38 @@
 数据结构
 ===
 
+结构，简单的理解就是关系，比如分子结构，就是说组成分子的原子之间的排列方式。严格点说，结构是指各个组成部分相互搭配和排列的方式。在现实世界中，不同数据元素之间不是独立的，而是存在特定的关系，我们将这些关系称为结构。那数据结构是什么？
+
+数据结构：是相互之间存在一种或多种特定关系的数据元素的集合。
+
+在计算机中，数据元素并不是孤立、杂乱无序的，而是具有内在联系的数据集合。数据元素之间存在的一种或多种特定关系，也就是数据的组织形式。
+
+
+按照视点的不同，我们把数据结构分为逻辑结构和物理结构。
+
+#### 逻辑结构
+逻辑结构：是指数据对象中数据元素之间的相互关系。其实这也是我们今后最需要关注的问题。逻辑结构分为以下四种：
+- 集合结构
+    集合结构：集合结构中的数据元素除了同属于一个集合外，它们之间没有其他关系。各个数据元素是“平等”的，它们的共同属性是“同属于一个集合”。数据结构中的集合关系就类似于数学中的集合
+- 线性结构
+    线性结构：线性结构中的数据元素之间是一对一的关系
+- 树形结构
+    树形结构：树形结构中的数据元素之间存在一种一对多的层次关系
+- 图形结构
+    图形结构：图形结构的数据元素是多对多的关系            
+
+#### 物理结构
+物理结构(有些成为存储结构)：是指数据的逻辑结构在计算机中的存储形式。
+- 顺序存储结构
+    顺序存储结构：是把数据元素存放在地址连续的存储单元里，其数据间的逻辑关系和物理关系是一致的
+    这种存储结构其实很简单，说白了，就是排队占位。大家都按顺序排好，每个人占一小段空间，大家谁也别插谁的队。我们之前学计算机语言时，数组就是这样的顺序存储结构。当你告诉计算机，你要建立一个有9个整型数据的数组时，计算机就在内存中找了片空地，按照一个整型所占位置的大小乘以9，开辟一段连续的空间，于是第一个数组数据就放在第一个位置，第二个数据放在第二个，这样依次摆放。
+- 链式存储结构
+    链式存储结构：是把数据元素存放在任意的存储单元里，这组存储单元可以是连续的，也可以是不连续的。数据元素的存储关系并不能反映其逻辑关系，因此需要用一个指针存放数据元素的地址，这样通过地址就可以找到相关联数据元素的位置
+
+    
+
+
+
 常见的数据结构:    
 
 - 数组`(Array)`
@@ -13,8 +45,23 @@
 - 图`(Graph)`
 
 
-数组`(Array)`
----
+## 线性表 
+
+零个或多个数据元素的有限序列。除第一个元素外，每一个元素有且只有一个直接前驱元素，除了最后一个元素外，每一个元素有且只有一个直接后继元素。数据元素之间的关系是一对一的关系。
+
+- 序列
+    也就是说元素之间是有顺序的。
+- 有限
+    元素的个数是有限的。
+
+线性表的顺序存储结构，在存、读数据时，不管是哪个位置，时间复杂度都是O(1)；
+而插入或删除时，时间复杂度都是O(n)。
+这就说明，它比较适合元素个数不太变化，而更多是存取数据的应用。当然，它的优缺点还不只这些。。
+
+由于线性表的顺序存储结构在插入和删除的时候需要移动大量元素，为了解决这个问题，有了线性表的链式存储结构。
+又分为单链表和多链表。
+
+### 数组`(Array)`
 
 数组是一种大小固定的数据结构，对线性表的所有操作都可以通过数组来实现。数组是在内存中开辟一段连续的空间，并在此空间存放元素。就像是一排出租屋，有100个房间，从001到100每个房间都有固定编号，通过编号就可以快速找到租房子的人。虽然数组一旦创建之后，它的大小就无法改变了，但是当数组不能再存储线性表中的新元素时，我们可以创建一个新的大的数组来替换当前数组。这样就可以使用数组实现动态的数据结构。
 
@@ -33,12 +80,62 @@ int[] arr = new int[10];
 - 增删慢，插入和删除的花费开销比较大，比如当在第一个位置前插入一个元素，那么首先要把所有的元素往后移动一个位置
 - 大小固定，只能存储单一元素，
 
+### 链表
 
+链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
+链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。
+每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，链表比较方便插入和删除操作。
 
-栈`(Stack)`
----
+用一组地址任意的存储单元存放线性表中的数据元素。以元素(数据元素的映象)+指针(指示后继元素存储位置) = 结点。
+以“结点的序列”表示线性表,称作线性链表（单链表）。单链表是一种顺序存取的结构，为找第`i`个数据元素，必须先找到第`i-1`个数据元素。 
+
+链表的结点结构:    
+```
+         ┌──┬──┐──┐
+         │data│next│
+         └──┴──┘──┘
+```         
+`data`域:存放结点值的数据域 　　 
+`next`域:存放结点的直接后继的地址（位置）的指针域（链域）。
+
+
+链表又分为很多种： 静态链表、循环链表、单链表、双向链表
+
+注意:    
+
+- 链表通过每个结点的链域将线性表的n个结点按其逻辑顺序链接在一起的。 　　
+- 每个结点只有一个链域的链表称为单链表`(Single Linked List)`
+
+所谓的链表就好像火车车厢一样，从火车头开始，每一节车厢之后都连着后一节车厢。
+
+
+单链表插入和删除算法，它们其实都是由两部分组成：
+第一部分就是遍历查找第i个元素；
+第二部分就是插入和删除元素。
+从整个算法来说，我们很容易推导出：它们的时间复杂度都是O(n)。
+如果在我们不知道第i个元素的指针位置，单链表数据结构在插入和删除操作上，与线性表的顺序存储结构是没有太大优势的。
+但如果，我们希望从第i个位置，插入10个元素，对于顺序存储结构意味着，每一次插入都需要移动n－i个元素，每次都是O(n)。
+而单链表，我们只需要在第一次时，找到第i个位置的指针，此时为O(n)，接下来只是简单地通过赋值移动指针而已，时间复杂度都是O(1)。
+显然，对于插入或删除数据越频繁的操作，单链表的效率优势就越是明显。
+
+
+优点:   
+
+- 和数组相比，链表的优势在于长度不受限制，也不需要连续的内存空间。
+- 在进行插入和删除操作时，不需要移动数据项，故尽管某些操作的时间复杂度与数组想同，实际效率上还是比数组要高很多,所以插入快，删除快
+
+缺点:   
+
+- 劣势在于随机访问，无法像数组那样直接通过下标找到特定的数据项 
+- 查找慢
+- 相对数组只存储元素，链表的元素还要存储其他元素地址，内存开销相对增大
 
 
+### 栈`(Stack)`
+
+栈是限定仅在表尾进行插入和删除操作的线性表。
+我们把允许插入和删除的一端称为栈顶（top），另一端称为栈底（bottom），不含任何数据元素的栈称为空栈。栈又称为后进先出（Last In First Out）的线性表，简称LIFO结构。
+
 > The Stack class represents a last-in-first-out (LIFO) stack of objects. It extends class Vector with five operations that allow a vector to be treated as a stack. The usual push and pop operations are provided, as well as a method to peek at the top item on the stack, a method to test for whether the stack is empty, and a method to search the stack for an item and discover how far it is from the top.
 When a stack is first created, it contains no items.
 
@@ -55,72 +152,57 @@ When a stack is first created, it contains no items.
 - 存取其他项很慢
 
 
-队列`(Queue)`
----
-
+### 链栈
 
-队列是一种特殊的线性表，特殊之处在于它只允许在表的前端`(front)`进行删除操作，而在表的后端`(rear)`进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。先进先出，简单暴力的理解就是吃进去拉出来   
+栈的顺序存储结构，我们现在来看看栈的链式存储结构，简称为链栈。
+对于链栈来说，基本不存在栈满的情况，除非内存已经没有可以使用的空间，如果真的发生，那此时的计算机操作系统已经面临死机崩溃的情况，而不是这个链栈是否溢出的问题。
+对比一下顺序栈与链栈，它们在时间复杂度上是一样的，均为O(1)。对于空间性能，顺序栈需要事先确定一个固定的长度，可能会存在内存空间浪费的问题，但它的优势是存取时定位很方便，而链栈则要求每个元素都有指针域，这同时也增加了一些内存开销，但对于栈的长度无限制。所以它们的区别和线性表中讨论的一样，如果栈的使用过程中元素变化不可预料，有时很小，有时非常大，那么最好是用链栈，反之，如果它的变化在可控范围内，建议使用顺序栈会更好一些。
 
 
-优点:    
+#### 栈的应用-递归
 
-- 提供了先进先出的存取方式   
 
-缺点:    
+把一个直接调用自己或通过一系列的调用语句间接地调用自己的函数，称做递归函数。
+当然，写递归程序最怕的就是陷入永不结束的无穷递归中，所以，每个递归定义必须至少有一个条件，满足时递归不再进行，即不再引用自身而是返回值退出。
 
-- 存取其他项很慢   
+那么我们讲了这么多递归的内容，和栈有什么关系呢？这得从计算机系统的内部说起。前面我们已经看到递归是如何执行它的前行和退回阶段的。递归过程退回的顺序是它前行顺序的逆序。在退回过程中，可能要执行某些动作，包括恢复在前行过程中存储起来的某些数据。这种存储某些数据，并在后面又以存储的逆序恢复这些数据，以提供之后使用的需求，显然很符合栈这样的数据结构，因此，编译器使用栈实现递归就没什么好惊讶的了。简单的说，就是在前行阶段，对于每一层递归，函数的局部变量、参数值以及返回地址都被压入栈中。在退回阶段，位于栈顶的局部变量、参数值和返回地址被弹出，用于返回调用层次中执行代码的其余部分，也就是恢复了调用的状态。
 
 
+### 队列`(Queue)`
 
+队列是只允许在一端进行插入操作、而在另一端进行删除操作的线性表。
+队列是一种先进先出（First In First Out）的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为队头。
 
+队列是一种特殊的线性表，特殊之处在于它只允许在表的前端`(front)`进行删除操作，而在表的后端`(rear)`进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。先进先出，简单暴力的理解就是吃进去拉出来   
 
 
+优点:    
 
-链表`(LinkedList)`
----
+- 提供了先进先出的存取方式   
 
-链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
-链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。
-每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，链表比较方便插入和删除操作。
+缺点:    
 
-用一组地址任意的存储单元存放线性表中的数据元素。以元素(数据元素的映象)+指针(指示后继元素存储位置) = 结点。
-以“结点的序列”表示线性表,称作线性链表（单链表）。单链表是一种顺序存取的结构，为找第`i`个数据元素，必须先找到第`i-1`个数据元素。 
+- 存取其他项很慢   
 
-链表的结点结构:    
-```
-         ┌──┬──┐──┐
-         │data│next│
-         └──┴──┘──┘
-```         
-`data`域:存放结点值的数据域 　　 
-`next`域:存放结点的直接后继的地址（位置）的指针域（链域）。
+### 链队列
+队列的链式存储结构，其实就是线性表的单链表，只不过它只能尾进头出而已，我们把它简称为链队列。
 
-注意:    
 
-- 链表通过每个结点的链域将线性表的n个结点按其逻辑顺序链接在一起的。 　　
-- 每个结点只有一个链域的链表称为单链表`(Single Linked List)`
+### 串
+串（string）是由零个或多个字符组成的有限序列，又名叫字符串。
 
-所谓的链表就好像火车车厢一样，从火车头开始，每一节车厢之后都连着后一节车厢。
 
-优点:   
-
-- 和数组相比，链表的优势在于长度不受限制，也不需要连续的内存空间。
-- 在进行插入和删除操作时，不需要移动数据项，故尽管某些操作的时间复杂度与数组想同，实际效率上还是比数组要高很多,所以插入快，删除快
 
-缺点:   
-
-- 劣势在于随机访问，无法像数组那样直接通过下标找到特定的数据项 
-- 查找慢
-- 相对数组只存储元素，链表的元素还要存储其他元素地址，内存开销相对增大
+### 树`(Tree)`
 
 
-树`(Tree)`
----
+树（Tree）是n（n≥0）个结点的有限集。n=0时称为空树。在任意一棵非空树中：（1）有且仅有一个特定的称为根（Root）的结点；（2）当n＞1时，其余结点可分为m（m＞0）个互不相交的有限集T1、T2、……、Tm，其中每一个集合本身又是一棵树，并且称为根的子树（SubTree）。
 
 
 树是由`n（n>=1）`个有限节点组成一个具有层次关系的集合。       
 它具有以下特点:每个节点有零个或多个子节点；没有父节点的节点称为根节点；每一个非根节点有且只有一个父节点；除了根节点外，每个子节点可以分为多个不相交的子树。
 
+树中结点的最大层次称为树的深度（Depth）。如果将树中结点的各子树看成从左至右是有次序的，不能互换的，则称该树为有序树，否则称为无序树。
 
 
 #### 二叉树
@@ -131,6 +213,25 @@ When a stack is first created, it contains no items.
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/binary_tree.jpg?raw=true)
 
 
+二叉树每个结点最多有两个孩子，所以为它设计一个数据域和两个指针域是比较自然的想法，我们称这样的链表叫做二叉链表。
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/alg_ercha_list.png?raw=true)   
+其中data是数据域，lchild和rchild都是指针域，分别存放只想左孩子和右孩子的指针。 
+如果有需要，还可以再增加一个指向其双亲的指针域，那样就称之为三叉链表
+   
+二叉树的遍历（traversing binary tree）是指从根结点出发，按照某种次序依次访问二叉树中所有结点，使得每个结点被访问一次且仅被访问一次。
+##### 二叉树遍历方法
+- 前序遍历
+    规则是若二叉树为空，则空操作返回，否则先访问根结点，然后前序遍历左子树，再前序遍历右子树。
+- 中序遍历
+    规则是若树为空，则空操作返回，否则从根结点开始（注意并不是先访问根结点），中序遍历根结点的左子树，然后是访问根结点，最后中序遍历右子树。
+- 后序遍历
+    规则是若树为空，则空操作返回，否则从左到右先叶子后结点的方式遍历访问左右子树，最后是访问根结点。
+- 层序遍历
+    规则是若树为空，则空操作返回，否则从树的第一层，也就是根结点开始访问，从上而下逐层遍历，在同一层中，按从左到右的顺序对结点逐个访问。
+
+
+
 #### 满二叉树和完全二叉树
 
 满二叉树:除最后一层无任何子节点外，每一层上的所有结点都有两个子结点。也可以这样理解，除叶子结点外的所有结点均有两个子结点。节点数达到最大值，所有叶子结点必须在同一层上。
@@ -227,6 +328,19 @@ private boolean isRed(Node x){
 }
 ```
 
+
+
+
+
+
+
+
+
+
+
+
+
+
 哈希表`(Hash)`
 ---
 
@@ -274,6 +388,8 @@ private boolean isRed(Node x){
 
 
 图是一种较线性表和树更为复杂的数据结构，在线性表中，数据元素之间仅有线性关系，在树形结构中，数据元素之间有着明显的层次关系，而在图形结构中，节点之间的关系可以是任意的，图中任意两个数据元素之间都可能相关。图的应用相当广泛，特别是近年来的迅速发展，已经渗入到诸如语言学、逻辑学、物理、化学、电讯工程、计算机科学以及数学的其他分支中。
+图（Graph）是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G（V,E），其中，G表示一个图，V是图G中顶点的集合，E是图G中边的集合。
+
 
 
 优点:   
diff --git "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\347\256\227\346\263\225.md" "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\347\256\227\346\263\225.md"
new file mode 100644
index 00000000..b57a2d11
--- /dev/null
+++ "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\347\256\227\346\263\225.md"
@@ -0,0 +1,320 @@
+算法
+===
+
+算法(Algorithm)是解决特定问题求解步骤的描述，在计算机中表现为指令的有限序列，并且每条指令表示一个或多个操作。
+
+
+算法具有五个基本特性：
+- 输入
+    算法具有零个或多个输入
+- 输出
+    算法至少有一个或多个输出
+- 有穷性
+    指算法在执行有限的步骤之后，自动结束而不会出现无限循环，并且每一个步骤在可接受的时间内完成。
+- 确定性
+    算法的每一步骤都具有确定的含义，不会出现二义性
+- 可行性
+    算法的每一步都必须是可行的，也就是说，每一步都能够通过执行有限次数完成
+
+
+### 算法时间复杂度
+在进行算法分析时，语句总的执行次数T（n）是关于问题规模n的函数，进而分析T（n）随n的变化情况并确定T（n）的数量级。算法的时间复杂度，也就是算法的时间量度，记作：T（n）=O(f(n))。它表示随问题规模n的增大，算法执行时间的增长率和f（n）的增长率相同，称作算法的渐近时间复杂度，简称为时间复杂度。其中f（n）是问题规模n的某个函数。
+
+这样用大写O( )来体现算法时间复杂度的记法，我们称之为大O记法。
+一般情况下，随着n的增大，T(n)增长最慢的算法为最优算法。
+显然，由此算法时间复杂度的定义可知，我们的三个求和算法的时间复杂度分别为O(n)，O(1)，O(n²)。
+我们分别给它们取了非官方的名称，O(1)叫常数阶、O(n)叫线性阶、O(n²)叫平方阶。
+
+
+
+#### 推导大O阶方法
+
+推导大O阶：
+1. 用常数1取代运行时间中的所有加法常数。
+2. 在修改后的运行次数函数中，只保留最高阶项。
+3. 如果最高阶项存在且不是1，则去除与这个项相乘的常数。
+得到的结果就是大O阶。
+
+##### 常数阶
+
+顺序结构的时间复杂度。
+
+下面这个算法，也就是刚才的第二种算法（高斯算法），为什么时间复杂度不是O(3)，而是O(1)。
+```
+int sum = 0, n = 100;  // 执行一次
+sum = (1 + n) * n / 2; // 执行一次
+printf("%d", sum);     // 执行一次
+```
+这个算法的运行次数函数是f（n）=3。
+根据我们推导大O阶的方法，第一步就是把常数项3改为1。
+在保留最高阶项时发现，它根本没有最高阶项，所以这个算法的时间复杂度为O(1)。
+那假设是这样:  
+
+```
+int sum = 0, n = 100;  // 执行一次
+sum = (1 + n) * n / 2; // 执行一次
+sum = (1 + n) * n / 2; // 执行一次
+sum = (1 + n) * n / 2; // 执行一次
+sum = (1 + n) * n / 2; // 执行一次
+sum = (1 + n) * n / 2; // 执行一次
+sum = (1 + n) * n / 2; // 执行一次
+sum = (1 + n) * n / 2; // 执行一次
+sum = (1 + n) * n / 2; // 执行一次
+sum = (1 + n) * n / 2; // 执行一次
+sum = (1 + n) * n / 2; // 执行一次
+sum = (1 + n) * n / 2; // 执行一次
+printf("%d", sum);     // 执行一次
+```
+事实上无论n为多少，上面的两段代码就是3次和12次执行的差异。这种与问题的大小无关（n的多少），执行时间恒定的算法，我们称之为具有O(1)的时间复杂度，又叫常数阶。注意：不管这个常数是多少，我们都记作O(1)，而不能是O(3)、O(12)等其他任何数字，这是初学者常常犯的错误。
+
+
+##### 线性阶
+
+循环结构的时间复杂度。
+
+下面这段代码，它的循环的时间复杂度为O(n)，因为循环体中的代码须要执行n次。
+```java
+int i;
+for (i = 0; i < n; i++) {
+    // 下面省略时间复杂度为O(1)的程序步骤
+    ...
+}
+
+```
+##### 对数阶
+下面的这段代码，时间复杂度是多少呢？ 
+```java
+int count = 1;
+while (count < n) {
+    count = count * 2;
+    // 下面省略时间复杂度为O(1)的程序步骤
+    ...
+}
+```
+由于每次count乘以2之后，就距离n更近了一分。
+也就是说，有多少个2相乘后大于n，则会退出循环。
+由2^x = n得到 x = ㏒(2)N。所以这个循环的时间复杂度为O(㏒n)
+
+
+##### 平方阶
+
+下面的例子是一个循环嵌套，它的内循环上面已经分析过，时间复杂度为O(n)。
+```java
+int i, j;
+for (i = 0; i < n; i ++ ) {
+    for (j = 0; j < n; j ++) {
+        // 下面省略时间复杂度为O(1)的程序步骤
+        ...
+    }
+}
+```
+
+而对于外层的循环，不过是内部这个时间复杂度为O(n)的语句，再循环n次。所以这段代码的时间复杂度为O(n2)。
+
+如果外循环的循环次数改为了m，时间复杂度就变为O(m×n)，如下：
+```java
+int i, j;
+for (i = 0; i < m; i ++ ) {
+    for (j = 0; j < n; j ++) {
+        // 下面省略时间复杂度为O(1)的程序步骤
+        ...
+    }
+}
+```
+所以我们可以总结得出，循环的时间复杂度等于循环体的复杂度乘以该循环运行的次数。那么下面这个循环嵌套，它的时间复杂度是多少呢？
+```java
+int i, j;
+for(i = 0; i < n; i ++) {
+    for (j = i; j < n; j ++) { // 注意j = i 而不是0
+        // 下面省略时间复杂度为O(1)的程序步骤
+        ...   
+    }
+}
+```
+由于当i=0时，内循环执行了n次，当i=1时，执行了n－1次，……当i=n－1时，执行了1次。所以总的执行次数为：
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/alg_1.png?raw=true)   
+用我们推导大O阶的方法: 
+- 第一条，没有加法常数不予考虑
+- 第二条，只保留最高阶项，因此保留n2/2
+- 第三条，去除这个项相乘的常数，也就是去除1/2
+最终这段代码的时间复杂度为O(n2)。
+
+##### 常见的时间复杂度
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/alg_2.png?raw=true)   
+
+
+
+### 算法空间复杂度
+
+我们在写代码时，完全可以用空间来换取时间，比如说，要判断某某年是不是闰年，你可能会花一点心思写了一个算法，而且由于是一个算法，也就意味着，每次给一个年份，都是要通过计算得到是否是闰年的结果。还有另一个办法就是，事先建立一个有2 050个元素的数组（年数略比现实多一点），然后把所有的年份按下标的数字对应，如果是闰年，此数组项的值就是1，如果不是值为0。这样，所谓的判断某一年是否是闰年，就变成了查找这个数组的某一项的值是多少的问题。此时，我们的运算是最小化了，但是硬盘上或者内存中需要存储这2050个0和1。这是通过一笔空间上的开销来换取计算时间的小技巧。到底哪一个好，其实要看你用在什么地方。
+
+算法的空间复杂度通过计算算法所需的存储空间实现，算法空间复杂度的计算公式记作：S(n)=O(f(n))，其中，n为问题的规模，f(n)为语句关于n所占存储空间的函数。
+
+一般情况下，一个程序在机器上执行时，除了需要存储程序本身的指令、常数、变量和输入数据外，还需要存储对数据操作的存储单元。若输入数据所占空间只取决于问题本身，和算法无关，这样只需要分析该算法在实现时所需的辅助单元即可。若算法执行时所需的辅助空间相对于输入数据量而言是个常数，则称此算法为原地工作，空间复杂度为O(1)。
+
+
+算法的空间复杂度并不是计算实际占用的空间，而是计算整个算法的辅助空间单元的个数，与问题的规模没有关系。算法的空间复杂度`S(n)`定义为该算法所耗费空间的数量级。     
+`S(n)=O(f(n))`若算法执行时所需要的辅助空间相对于输入数据量`n`而言是一个常数，则称这个算法的辅助空间为`O(1)`;      
+递归算法的空间复杂度:递归深度`N*`每次递归所要的辅助空间， 如果每次递归所需的辅助空间是常数，则递归的空间复杂度是`O(N)`.     
+
+空间复杂度的分析方法:      
+
+- 一个算法的空间复杂度`S(n)`定义为该算法所耗费的存储空间，它也是问题规模`n`的函数。空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度。
+- 一个算法在计算机存储器上所占用的存储空间，包括存储算法本身所占用的存储空间，算法的输入输出数据所占用的存储空间和算法在运行过程中临时占用的存储空间这三个方面。
+- 一个算法的空间复杂度只考虑在运行过程中为局部变量分配的存储空间的大小，它包括为参数表中形参变量分配的存储空间和为在函数体中定义的局部变量分配的存储空间两个部分。
+
+　　算法的空间复杂度一般也以数量级的形式给出。如当一个算法的空间复杂度为一个常量，即不随被处理数据量`n`的大小而改变时，可表示为`O(1)`；      
+　　当一个算法的空间复杂度与以2为底的`n`的对数成正比时，可表示为`O(log2n)`；      
+　　当一个算法的空间复杂度与`n`成线性比例关系时，可表示为`O(n)`。若形参为数组，则只需要为它分配一个存储由实参传送来的一个地址指针的空间，即一个机器字长空间；若形参为引用方式，则也只需要为其分配存储一个地址的空间，用它来存储对应实参变量的地址，以便由系统自动引用实参变量。      
+
+空间复杂度补充:       
+
+一个程序的空间复杂度是指运行完一个程序所需内存的大小。利用程序的空间复杂度，可以对程序的运行所需要的内存多少有个预先估计。      
+一个程序执行时除了需要存储空间和存储本身所使用的指令、常数、变量和输入数据外，还需要一些对数据进行操作的工作单元和存储一些为现实计算所需信息的辅助空间。       
+程序执行时所需存储空间包括以下两部分:      　　
+
+- 固定部分。这部分空间的大小与输入/输出的数据的个数多少、数值无关。主要包括指令空间（即代码空间）、数据空间（常量、简单变量）等所占的空间。这部分属于静态空间。
+- 可变空间，这部分空间的主要包括动态分配的空间，以及递归栈所需的空间等。这部分的空间大小与算法有关。一个算法所需的存储空间用`f(n)`表示。`S(n)=O(f(n))`其中`n`为问题的规模，`S(n)`表示空间复杂度。
+
+
+时间与空间复杂度比较
+---
+
+对于一个算法，其时间复杂度和空间复杂度往往是相互影响的。当追求一个较好的时间复杂度时，可能会使空间复杂度的性能变差，
+即可能导致占用较多的存储空间；反之，当追求一个较好的空间复杂度时，可能会使时间复杂度的性能变差，即可能导致占用较长的运行时间。
+另外，算法的所有性能之间都存在着或多或少的相互影响。因此，当设计一个算法（特别是大型算法）时，要综合考虑算法的各项性能，算法的使用频率，算法处理的数据量的大小，算法描述语言的特性，算法运行的机器系统环境等各方面因素，才能够设计出比较好的算法。
+
+
+通常，我们都使用“时间复杂度”来指运行时间的需求，使用“空间复杂度”指空间需求。
+
+当不用限定词地使用“复杂度”时，通常都是指时间复杂度。
+
+
+
+
+## 顺序查找算法
+
+顺序查找（Sequential Search）又叫线性查找，是最基本的查找技术，它的查找过程是：从表中第一个（或最后一个）记录开始，逐个进行记录的关键字和给定值比较，若某个记录的关键字和给定值相等，则查找成功，找到所查的记录；如果直到最后一个（或第一个）记录，其关键字和给定值比较都不等时，则表中没有所查的记录，查找不成功。
+
+
+
+
+
+
+算法（Algorithm）是一系列解决问题的清晰指令，也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。如果一个算法有缺陷，或不适合于某个问题，
+执行这个算法将不会解决这个问题。不同的算法可能用不同的时间、空间或效率来完成同样的任务。一个算法的优劣可以用空间复杂度与时间复杂度来衡量。         
+算法可以理解为有基本运算及规定的运算顺序所构成的完整的解题步骤。或者看成按照要求设计好的有限的确切的计算序列，并且这样的步骤和序列可以解决一类问题。
+```java
+/**
+ * 1到100所有素数的和
+ * 素数就是只能够被1和自身整除的数
+ */
+public class dd {
+    public static void main(String[] args) {
+        int i = 2; // i 即为所求素数
+        System.out.println("i= " + i);
+        for (i = 3; i <= 100; i = i + 2) {
+            boolean f = true;
+            Label: for (int j = 2; j < i; j++) {
+                if (i % j == 0) { // if(true)时，i为非素数
+                    f = false;
+                    break Label; // 加了Label貌似只是起到提高效率
+                }
+            }
+            if (f) {// 当f=true时，i为素数。
+                System.out.println("i= " + i);
+            }
+        }
+    }
+}
+
+/**
+ *古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第四个月后每个月又生一对兔子，假如兔子都不死，
+ *问每个月的兔子总数为多少？ 
+ *
+ */
+public class aa{
+    public static void main(String[] args) {
+        int i = 0;
+        for (i = 1; i < 20; i++) {
+            System.out.println(f(i));
+        }
+    }
+    
+    public static int f(int x) {
+        if(x==1||x==2) {
+            return 1;
+        }else {
+            return f(x-1)+f(x-2);
+        }
+    }
+}
+```
+
+3.有两个有序数组`a`,`b`,现需要将其合并成一个新的有序数组。
+
+简单的思路就是先放到一个新的数组中，再排序。但是这样的没体现任何算法，这里考的不是快速排序等排序算法。关键应该是如何利用`有序` 已知这个条件。可以这样想，假设两个源数组的长度不一样，那么假设其中短的数组用完了，即全部放入到新数组中去了，那么长数组中剩下的那一段就可以直接拿来放入到新数组中去了。
+
+其中用到的思想是:归并排序思想
+
+```java
+public static int[] merge(int[] a, int[] b) {
+    int lengthA = a.length;
+    int lengthB = b.length;
+    int[] result = new int[lengthA + lengthB];
+
+    //aIndex:用于标示a数组    bIndex：用来标示b数组  resultIndex：用来标示传入的数组
+    int aIndex = 0, bIndex = 0, resultIndex = 0;
+
+    while (aIndex < lengthA && bIndex < lengthB) {
+        if (a[aIndex] < b[bIndex]) {
+            result[resultIndex++] = a[aIndex];
+            aIndex++;
+        } else {
+            result[resultIndex++] = b[bIndex];
+            bIndex++;
+        }
+    }
+
+    // a有剩余
+    while (aIndex < lengthA) {
+        result[resultIndex++] = a[aIndex];
+        aIndex++;
+    }
+
+    // b有剩余
+    while (bIndex < lengthB) {
+        result[resultIndex++] = b[bIndex];
+        bIndex++;
+    }
+    return result;
+}
+````
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+		
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/JavaKnowledge/\347\256\227\346\263\225\347\232\204\345\244\215\346\235\202\345\272\246.md" "b/JavaKnowledge/\347\256\227\346\263\225\347\232\204\345\244\215\346\235\202\345\272\246.md"
deleted file mode 100644
index 341bdff2..00000000
--- "a/JavaKnowledge/\347\256\227\346\263\225\347\232\204\345\244\215\346\235\202\345\272\246.md"
+++ /dev/null
@@ -1,179 +0,0 @@
-算法的复杂度
-===
-
-
-何为算法
----
-
-算法是对特定问题求解步骤的一种描述，是独立存在的一种解决问题的方法和思想。它是指令的有限序列，其中每一条指令表示一个或多个操作；
-
-此外，成为一个算法需要满足以下条件或特性:    
-
-- 有穷性。一个算法必须总是在执行有穷步之后结束，且每一步都可在有穷时间内完成。
-- 确定性。算法中每一条指令必须有确切的含义读者理解时不会产生二义性。并且，在任何条件下，算法只有唯一的一条执行路径，即对于相同的输入只能得出相同的输出。
-- 可行性。一个算法是能行的，即算法中描述的操作都是可以通过已经实现的基本运算执行有限次来实现的。
-- 输入。零个或多个的输入。
-- 输出。一个或多个的输出。
-
-
-算法的设计要求
----
-
-通常设计一个好的算法应考虑达到以下目标:    
-
-- 正确性:对于合法输入能够得到满足的结果；算法能够处理非法处理，并得到合理结果；算法对于边界数据和压力数据都能得到满足的结果。
-- 可读性。算法要方便阅读，理解和交流，只有自己能看得懂，其它人都看不懂，谈和好算法。
-- 健壮性。算法不应该产生莫名其妙的结果，一会儿正确，一会儿又是其它结果。
-- 高性价比，效率与低存储量需求。利用最少的时间和资源得到满足要求的结果，可以通过(时间复杂度和空间复杂度来判定)
-
-
-
-算法复杂度分为:   
-
-- 时间复杂度:指执行算法所需要的计算工作量
-- 空间复杂度:指执行这个算法所需要的内存空间
-
-简单来说，时间复杂度指的是语句执行次数，空间复杂度指的是算法所占的存储空间。 
-
-
-时间复杂度
----
-
-什么是时间复杂度，算法中某个函数有n次基本操作重复执行，用T(n)表示，现在有某个辅助函数f(n),使得当n趋近于无穷大时，T（n)/f(n)的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作T(n)=O(f(n)),称O(f(n)) 为算法的渐进时间复杂度，简称时间复杂度。通俗一点讲，其实所谓的时间复杂度，就是找了一个同样曲线类型的函数f(n)来表示这个算法的在n不断变大时的趋势 。当输入量n逐渐加大时，时间复杂性的极限情形称为算法的“渐近时间复杂性”。 
-
-- 时间频度         
-
-    一个算法执行所耗费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。但我们不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。并且一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为`T(n)`。（算法中的基本操作一般指算法中最深层循环内的语句）
-
-- 时间复杂度         
-
-    在刚才提到的时间频度中，`n`称为问题的规模，当`n`不断变化时，时间频度`T(n)`也会不断变化。但有时我们想知道它变化时呈现什么规律。为此，我们引入时间复杂度的概念。
-    
-    
-
-在进行算法分析时，语句总的执行次数`T(n)`是关于问题规模`n`的函数，进而分析`T(n)`随`n`的变化情况并确定`T(n)`的数量级。
-算法的时间复杂度，也就是算法的时间量度，记作`T(n) = O(f(n))`。它表示随问题规模`n`的增大，算法执行时间的增长率和`f(n)`的增长率相同，
-称为算法的渐近时间复杂度，简称为时间复杂度。其中`f(n)`是规模`n`的某个函数。
-
-
-大`O`表示法
----
-
-像前面用`O()`来体现算法时间复杂度的记法，我们称之为大O表示法。用`O()`来体现算法时间复杂度的记法，叫作大`O`记法。
-
-
-按数量级递增排列，常见的时间复杂度有:   
-常数阶`O(1)`,对数阶`O(log2n)`(以2为底`n`的对数，下同),线性阶`O(n)`,
-线性对数阶`O(nlog2n)`,平方阶`O(n^2)`，立方阶`O(n^3)`,...，
-`k`次方阶`O(n^k)`,指数阶`O(2^n)`。随着问题规模`n`的不断增大，上述时间复杂度不断增大，算法的执行效率越低。
-
-
-##### 推导大`O`阶方法
-
-- 用常数1取代运行时间中的所有加法常数。
-- 在修改后的运行次数函数中，只保留最高阶项。
-- 如果最高阶项存在且不是1，则去除与这个项相乘的常数。
-
-
-##### 常数阶
-
-`O(1)`的算法是一些运算次数为常数的算法。例如:
-```java
-temp=a;a=b;b=temp;
-```
-
-上面语句共三条操作，单条操作的频度为1，即使他有成千上万条操作，也只是个较大常数，这一类的时间复杂度为`O(1)`。
-
-##### 线性阶
-
-`O(n)`的算法是一些线性算法。例如:  
-```java
-sum=0；                 
-for(i=0;i<n;i++) {
-    sum++；
-}
-```
-
-上面代码中第一行频度1，第二行频度为`n`，第三行频度为n，所以`f(n)=n+n+1=2n+1`。所以时间复杂度`O(n)`。这一类算法中操作次数和`n`正比线性增长。
-
-##### 对数阶
-
-`O(logn)`一个算法如果能在每个步骤去掉一半数据元素，如二分检索，通常它就取`O(logn)`时间。举个栗子:  
-```java
-int i=1; 
-
-while (i<=n) {
-    i=i*2; 
-}
-```
-上面代码设第三行的频度是`f(n)`,   则：2的`f(n)`次方`<=n`;`f(n)<=log₂n`，取最大值`f(n)= log₂n`，所以`T(n)=O(log₂n )`。
-
-
-##### 平方阶
-
-`O(n²)`（n的k次方的情况）最常见的就是平时的对数组进行排序的各种简单算法都是`O(n²)`，例如直接插入排序的算法。
-
-```java
-sum=0；                
-for(i=0;i<n;i++) {
-    for(j=0;j<n;j++) {
-        sum++；
-    }
-}
-```
-第一行频度1，第二行`n`，第三行`n²`，第四行`n²`，`T(n)=2n²+n+1 =O(n²)`
-
-##### 指数阶
-
-O(2的`n`次方) 比如求具有`n`个元素集合的所有子集的算法 
-
-##### 阶乘阶
-
-`O(n!)`比如求具有`n`个元素的全排列的算法
-
-时间复杂度按n越大算法越复杂来排的话:
-
-常数阶`O(1)`、对数阶`O(logn)`、线性阶`O(n)`、线性对数阶`O(nlogn)`、平方阶`O(n²)`、立方阶`O(n³)`、……`k`次方阶`O`(`n`的`k`次方)、指数阶`O`(2的`n`次方)。
-
-
-
-空间复杂度
----
-
-算法的空间复杂度并不是计算实际占用的空间，而是计算整个算法的辅助空间单元的个数，与问题的规模没有关系。算法的空间复杂度`S(n)`定义为该算法所耗费空间的数量级。     
-`S(n)=O(f(n))`若算法执行时所需要的辅助空间相对于输入数据量`n`而言是一个常数，则称这个算法的辅助空间为`O(1)`;      
-递归算法的空间复杂度:递归深度`N*`每次递归所要的辅助空间， 如果每次递归所需的辅助空间是常数，则递归的空间复杂度是`O(N)`.     
-
-空间复杂度的分析方法:      
-
-- 一个算法的空间复杂度`S(n)`定义为该算法所耗费的存储空间，它也是问题规模`n`的函数。空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度。
-- 一个算法在计算机存储器上所占用的存储空间，包括存储算法本身所占用的存储空间，算法的输入输出数据所占用的存储空间和算法在运行过程中临时占用的存储空间这三个方面。
-- 一个算法的空间复杂度只考虑在运行过程中为局部变量分配的存储空间的大小，它包括为参数表中形参变量分配的存储空间和为在函数体中定义的局部变量分配的存储空间两个部分。
-
-　　算法的空间复杂度一般也以数量级的形式给出。如当一个算法的空间复杂度为一个常量，即不随被处理数据量`n`的大小而改变时，可表示为`O(1)`；      
-　　当一个算法的空间复杂度与以2为底的`n`的对数成正比时，可表示为`O(log2n)`；      
-　　当一个算法的空间复杂度与`n`成线性比例关系时，可表示为`O(n)`。若形参为数组，则只需要为它分配一个存储由实参传送来的一个地址指针的空间，即一个机器字长空间；若形参为引用方式，则也只需要为其分配存储一个地址的空间，用它来存储对应实参变量的地址，以便由系统自动引用实参变量。      
-
-空间复杂度补充:       
-
-一个程序的空间复杂度是指运行完一个程序所需内存的大小。利用程序的空间复杂度，可以对程序的运行所需要的内存多少有个预先估计。      
-一个程序执行时除了需要存储空间和存储本身所使用的指令、常数、变量和输入数据外，还需要一些对数据进行操作的工作单元和存储一些为现实计算所需信息的辅助空间。       
-程序执行时所需存储空间包括以下两部分:      　　
-
-- 固定部分。这部分空间的大小与输入/输出的数据的个数多少、数值无关。主要包括指令空间（即代码空间）、数据空间（常量、简单变量）等所占的空间。这部分属于静态空间。
-- 可变空间，这部分空间的主要包括动态分配的空间，以及递归栈所需的空间等。这部分的空间大小与算法有关。一个算法所需的存储空间用`f(n)`表示。`S(n)=O(f(n))`其中`n`为问题的规模，`S(n)`表示空间复杂度。
-
-
-时间与空间复杂度比较
----
-
-对于一个算法，其时间复杂度和空间复杂度往往是相互影响的。当追求一个较好的时间复杂度时，可能会使空间复杂度的性能变差，
-即可能导致占用较多的存储空间；反之，当追求一个较好的空间复杂度时，可能会使时间复杂度的性能变差，即可能导致占用较长的运行时间。
-另外，算法的所有性能之间都存在着或多或少的相互影响。因此，当设计一个算法（特别是大型算法）时，要综合考虑算法的各项性能，算法的使用频率，算法处理的数据量的大小，算法描述语言的特性，算法运行的机器系统环境等各方面因素，才能够设计出比较好的算法。
-
-
-
----
-
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
diff --git "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md" "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
index ccd54508..7014d941 100644
--- "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
+++ "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
@@ -11,6 +11,21 @@
 
 作用:它可以帮我们管理计算机的各种资源，协助我们完成各种复杂繁琐的任务。
 
+### 操作系统三要素: 
+
+- 虚拟化（virtualization）
+    操作系统将物理（physical）资源（如处理器、内存或磁盘）转换为更通用、更强大且更易于使用的虚拟形式。因此，我们有时将操作系统称为虚拟机（virtual machine）。
+    当然，为了让用户可以告诉操作系统做什么，从而利用虚拟机的功能（如运行程序、分配内存或访问文件），操作系统还提供了一些接口（API），供你调用。实际上，典型的操作系统会提供几百个系统调用（system call），让应用程序调用。由于操作系统提供这些调用来运行程序、访问内存和设备，并进行其他相关操作，我们有时也会说操作系统为应用程序提供了一个标准库（standard library）。
+    
+    最后，因为虚拟化让许多程序运行（从而共享CPU），让许多程序可以同时访问自己的指令和数据（从而共享内存），让许多程序访问设备（从而共享磁盘等），所以操作系统有时被称为资源管理器（resource manager）。每个CPU、内存和磁盘都是系统的资源（resource），因此操作系统扮演的主要角色就是管理（manage）这些资源，以做到高效或公平，或者实际上考虑其他许多可能的目标。
+    
+    - 进程，它是虚拟化的CPU；
+    - 地址空间，它是虚拟化的内存。
+
+- 并发（concurrency）
+- 持久性（persistence）
+
+操作系统实际上做了什么：它取得CPU、内存或磁盘等物理资源（resources），并对它们进行虚拟化（virtualize）。它处理与并发（concurrency）有关的麻烦且棘手的问题。它持久地（persistently）存储文件，从而使它们长期安全
 
 操作系统也是一种软件，但是操作系统是一种非常复杂的软件。操作系统提供了几种抽象模型:    
 
@@ -22,11 +37,6 @@
 
 
 
-### 操作系统三要素: 
-
-- 虚拟化（virtualization）
-- 并发（concurrency）
-- 持久性（persistence）
 
 
 ### 以现代标准而言，一个标准PC的操作系统应该提供以下功能
@@ -149,6 +159,11 @@
     - 用户程序的长度是多少？
     - 装载完用户程序后，应该跳转到哪里，即用户程序的执行入口在哪里？
 
+    理器在上电时自动把程序计数器设置为处理器厂商设计的某个固定值，对于ARM64处理器，这个固定值是0。处理器的内存管理单元（Memory Management Unit, MMU）负责把虚拟地址转换为物理地址，ARM64处理器刚上电的时候没有开启内存管理单元，物理地址和虚拟地址相同，所以ARM64处理器到物理地址0取第一条指令。嵌入式设备通常使用NOR闪存作为只读存储器来存放引导程序。NOR闪存的容量比较小，最小读写单位是字节，程序可以直接在芯片内执行。从物理地址0开始的一段物理地址空间被分配给NOR闪存。综上所述，ARM64处理器到虚拟地址0取指令，就是到物理地址0取指令，也就是到NOR闪存的起始位置取指令。
+    嵌入式设备通常使用U-Boot作为引导程序。U-Boot（Universal Boot Loader）是德国DENX软件工程中心开发的引导程序，是遵循GPL条款的开源项目。
+    U-Boot分为SPL和正常的U-Boot程序两个部分，如果想要编译为SPL，需要开启配置宏CONFIG_SPL_BUILD。SPL是“Secondary Program Loader”的简称，即第二阶段程序加载器，第二阶段是相对于处理器里面的只读存储器中的固化程序来说的，处理器启动时最先执行的是只读存储器中的固化程序。固化程序通过检测启动方式来加载第二阶段程序加载器。为什么需要第二阶段程序加载器？原因是：一些处理器内部集成的静态随机访问存储器比较小，无法装载一个完整的U-Boot镜像，此时需要第二阶段程序加载器，它主要负责初始化内存和存储设备驱动，然后把正常的U-Boot镜像从存储设备读到内存中执行。
+
+
 - 操作系统内核初始化
 
     执行内核程序，这一步所说的内核程序在上一步中指的就是”用户程序“。因为从CPU的角度来看，除了Bootloader之外的所有程序都是用户程序，只是从软件的角度来看，用户程序被分为”内核程序“和”应用程序“，而本步执行的是内核程序。
@@ -249,6 +264,8 @@ CPU(中央处理器)是计算机的大脑，它主要和内存进行交互，从
 
 为了驱动CPU运转，称为“时钟信号”的电信号必不可少。这种电信号就好像带有一个时钟，滴答滴答地每隔一定时间就变换一次电压的高低。输出时钟信号的元件叫作“时钟发生器”。时钟发生器中带有晶振，根据其自身的频率（振动的次数）产生时钟信号。时钟信号的频率可以衡量CPU的运转速度。这里使用的是2.5MHz（兆赫兹）的时钟发生器。最大时钟频率(maximum clock speed)，也称主频，是影响处理器速度的决定性因素之一。时钟频率决定了执行一条指令所需要的时间，处理器的数据位宽也影响处理器的速度。
 
+操作系统通过虚拟化（virtualizing）CPU来提供这种假象。通过让一个进程只运行一个时间片，然后切换到其他进程，操作系统提供了存在多个虚拟CPU的假象。这就是时分共享（time sharing）CPU技术，允许用户如愿运行多个并发进程。潜在的开销就是性能损失，因为如果CPU必须共享，每个进程的运行就会慢一点。
+要实现CPU的虚拟化，要实现得好，操作系统就需要一些低级机制以及一些高级智能。我们将低级机制称为机制（mechanism）。机制是一些低级方法或协议，实现了所需的功能。例如，我们稍后将学习如何实现上下文切换（context switch），它让操作系统能够停止运行一个程序，并开始在给定的CPU上运行另一个程序。所有现代操作系统都采用了这种分时机制。
 
 CPU 的内部由**寄存器、控制器、运算器和时钟**四部分组成，各部分之间通过电信号连通。
 
diff --git "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md" "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
index a273dd1f..6a10819b 100644
--- "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
+++ "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
@@ -14,6 +14,10 @@
 
 为了虚拟化CPU，操作系统需要以某种方式让许多任务共享物理CPU，让它们看起来像是同时运行。基本思想很简单：运行一个进程一段时间，然后运行另一个进程，如此轮换。通过以这种方式时分共享（time sharing）CPU，就实现了虚拟化。然而，在构建这样的虚拟化机制时存在一些挑战。第一个是性能：如何在不增加系统开销的情况下实现虚拟化？第二个是控制权：如何有效地运行进程，同时保留对CPU的控制？控制权对于操作系统尤为重要，因为操作系统负责资源管理。如果没有控制权，一个进程可以简单地无限制运行并接管机器，或访问没有权限的信息。因此，在保持控制权的同时获得高性能，这是构建操作系统的主要挑战之一。
 
+抽象：进程概念
+操作系统为正在运行的程序提供的抽象，就是所谓的进程（process）。正如我们上面所说的，一个进程只是一个正在运行的程序。在任何时刻，我们都可以清点它在执行过程中访问或影响的系统的不同部分，从而概括一个进程。
+
+
 #### 多道程序系统与分时操作系统
 - 所谓多道程序设计指的是允许多个程序同时进入一个计算机系统的主存储器并启动进行计算的方法。也就是说，计算机内存中可以同时存放多道（两个以上相互独立的）程序，它们都处于开始和结束之间。从宏观上看是并行的，多道程序都处于运行中，并且都没有运行结束；从微观上看是串行的，各道程序轮流使用CPU，交替执行。引入多道程序设计技术的根本目的是为了提高CPU的利用率，充分发挥计算机系统部件的并行性，现代计算机系统都采用了多道程序设计技术。
 - 分时操作系统是使一台计算机同时为几个、几十个甚至几百个用户服务的一种操作系统。把计算机与许多终端用户连接起来，分时操作系统将系统处理机时间与内存空间按一定的时间间隔，轮流地切换给各终端用户的程序使用。由于时间间隔很短，每个用户的感觉就像他独占计算机一样。分时操作系统的特点是可有效增加资源的使用率。例如UNIX系统就采用剥夺式动态优先的CPU调度，有力地支持分时操作。
@@ -27,14 +31,21 @@
 
 广义定义：进程是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是[操作系统](https://baike.baidu.com/item/操作系统/192)动态执行的[基本单元](https://baike.baidu.com/item/基本单元)，在传统的[操作系统](https://baike.baidu.com/item/操作系统)中，进程既是基本的[分配单元](https://baike.baidu.com/item/分配单元)，也是基本的执行单元。
 
+
 进程的概念主要有两点：    
-- 第一，进程是一个实体。每一个进程都有它自己的地址空间，一般情况下，包括[文本](https://baike.baidu.com/item/文本)区域（text region）、数据区域（data region）和[堆栈](https://baike.baidu.com/item/堆栈)（stack region）。文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分配的内存；堆栈区域存储着活动过程调用的指令和本地变量。
+- 第一，进程是一个实体。每一个进程都有它自己的地址空间，一般情况下，包括[文本](https://baike.baidu.com/item/文本)区域（text region）、数据区域（data region）和[堆栈](https://baike.baidu.com/item/堆栈)（stack region）。文本区域存储处理器执行的代码；数据区域存储变量和进程执行期间使用的动态分配的内存；堆栈区域存储着活动过程调用的指令和本地变量。每个进程访问自己的私有虚拟地址空间（virtual address space）（有时称为地址空间，address space），操作系统以某种方式映射到机器的物理内存上。一个正在运行的程序中的内存引用不会影响其他进程（或操作系统本身）的地址空间。对于正在运行的程序，它完全拥有自己的物理内存。
 - 第二，进程是一个“执行中的程序”。程序是一个没有生命的实体，只有[处理](https://baike.baidu.com/item/处理)器赋予程序生命时（操作系统执行之），它才能成为一个活动的实体，我们称其为[进程](https://baike.baidu.com/item/进程)。可以简单的理解为：进程 = 资源 + 指令执行序列。
 
 进程是60年代初首先由[麻省理工学院](https://baike.baidu.com/item/麻省理工学院)的[MULTICS系统](https://baike.baidu.com/item/MULTICS系统)和IBM公司的[CTSS](https://baike.baidu.com/item/CTSS)/360系统引入的。
 
 进程是一个具有独立功能的程序关于某个数据集合的一次运行活动。它可以申请和拥有系统资源，是一个动态的概念，是一个活动的实体。它不只是程序的[代码](https://baike.baidu.com/item/代码)，还包括当前的活动，通过[程序计数器](https://baike.baidu.com/item/程序计数器)的值和处理[寄存器](https://baike.baidu.com/item/寄存器)的内容来表示。
 
+
+为了理解构成进程的是什么，我们必须理解它的机器状态（machine state）：程序在运行时可以读取或更新的内容。在任何时刻，机器的哪些部分对执行该程序很重要？
+进程的机器状态有一个明显组成部分，就是它的内存。指令存在内存中。正在运行的程序读取和写入的数据也在内存中。因此进程可以访问的内存（称为地址空间，address space）是该进程的一部分。
+进程的机器状态的另一部分是寄存器。许多指令明确地读取或更新寄存器，因此显然，它们对于执行该进程很重要。
+
+
 进程由三部分组成: 
 
 - 一段可执行的程序
@@ -530,6 +541,16 @@ Android使用的进程有些不同。活动管理器是Android负责正在运行
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/thread_heap.png?raw=true)  
 
+#### 线程和进程的区别
+
+单个线程的状态与进程状态非常类似。线程有一个程序计数器（PC），记录程序从哪里获取指令。每个线程有自己的一组用于计算的寄存器。所以，如果有两个线程运行在一个处理器上，从运行一个线程（T1）切换到另一个线程（T2）时，必定发生上下文切换（context switch）。线程之间的上下文切换类似于进程间的上下文切换。对于进程，我们将状态保存到进程控制块（Process Control Block，PCB）。现在，我们需要一个或多个线程控制块（Thread Control Block，TCB），保存每个线程的状态。但是，与进程相比，线程之间的上下文切换有一点主要区别：地址空间保持不变（即不需要切换当前使用的页表）。
+
+线程和进程之间的另一个主要区别在于栈。在简单的传统进程地址空间模型 [我们现在可以称之为单线程（single-threaded）进程] 中，只有一个栈，通常位于地址空间的底部，然而，在多线程的进程中，每个线程独立运行，当然可以调用各种例程来完成正在执行的任何工作。不是地址空间中只有一个栈，而是每个线程都有一个栈。假设有一个多线程的进程，它有两个线程，结果地址空间看起来不同。如下图： 
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/thread_process_memory_diff.png?raw=true)   
+
+在图中，可以看到两个栈跨越了进程的地址空间。因此，所有位于栈上的变量、参数、返回值和其他放在栈上的东西，将被放置在有时称为线程本地（thread-local）存储的地方，即相关线程的栈。你可能注意到，多个栈也破坏了地址空间布局的美感。以前，堆和栈可以互不影响地增长，直到空间耗尽。多个栈就没有这么简单了。幸运的是，通常栈不会很大（除了大量使用递归的程序）。
+
+
 #### 线程系统调用
 
 进程通常会从当前的某个单线程开始，然后这个线程通过调用一个库函数（比如 `thread_create`）创建新的线程。线程创建的函数会要求指定新创建线程的名称。创建的线程通常都返回一个线程标识符，该标识符就是新线程的名字。
diff --git "a/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md" "b/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
index 8088adec..9caa1e04 100644
--- "a/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
+++ "b/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
@@ -1,7 +1,10 @@
 # 3. 内存管理
 
+
 内存管理机制负责对内存架构进行管理，使程序在内存架构的任何一个层次上的存放对于用户来说都是一样的。用户无须担心自己的程序是存储在缓存、主存、磁盘还是磁带上，反正运行、计算、输出的结果都一样。而内存管理实现这种媒介透明的手段就是虚拟内存。用我们多次讲过的“抽象”来说，虚拟内存就是操作系统提供给用户的另一个“幻象”。这个幻象构建在内存架构的顶端，给用户提供一个比物理主存空间大许多的地址空间。
 
+虚拟内存系统负责为程序提供一个巨大的、稀疏的、私有的地址空间的假象，其中保存了程序的所有指令和数据。操作系统在专门硬件的帮助下，通过每一个虚拟内存的索引，将其转换为物理地址，物理内存根据获得的物理地址去获取所需的信息。操作系统会同时对许多进程执行此操作，并且确保程序之间互相不会受到影响，也不会影响操作系统。整个方法需要大量的机制（很多底层机制）和一些关键的策略。
+
 常用概念: 
 
 - 页框：内存中固定长度的块
@@ -30,15 +33,26 @@
 - BSS段(bss segment)：存储未初始化的全局变量和未初始化的static变量。bss段中数据的生存期随进程持续性。bss段中的数据一般默认为0.这里很奇怪，一般的书上都会说全局变量和静态变量是会自动初始化的，怎么突然来了个未初始化的变量？其实变量的初始化可以分为显式初始化和隐式初始化，全局变量和静态变量如果程序员自己不初始化的话也会被初始化，那就是不管什么类型都初始化为默认值，这种没有显示初始化的就是这里所说的未初始化。例如整数型的全局变量未初始化的默认隐式初始化的值为0，都是0就没必要把每个0都存储起来，从而节省磁盘空间，这是BSS的主要作用）。BSS的全称是Block Started by Symbol，它属于静态内存分配。BSS节不包含任何数据，只是简单的维护开始和结束的地址，即总大小，以便内存能在运行时分配并被有效的清零。BSS节在应用程序的二进制映像文件中并不存在，既不占用磁盘空间，而只在运行的时候占用内存空间，所以如果全局变量和静态变量未初始化那么其可执行文件要小很多。
 - rodata段(read only data):常量区，存放只读数据。比如程序中定义为const的全局变量，“Hello Word”的字符串常量。有些系统中rodata段是多个进程共享的，目的是为了提高空间利用率。在有的嵌入式系统中，rodata放在ROM中，运行时直接读取，不须加载到RAM内存中。所以在嵌入式开发中，常将已知的常量系数，表格数据等加以const关键字。存放在ROM中，避免占用RAM空间。
 
-- 堆(heap)：堆是用于存放进程运行中被动态分配的内存段，它的大小并不固定，可动态扩张或缩减。当进程调用malloc、realloc等函数分配内存时，新分配的内存就被动态添加到堆上（堆被扩张）；当利用free等函数释放内存时，被释放的内存从堆中被剔除（堆被缩减）
+- 堆(heap)：
+    其中所有的申请和释放操作都由程序员显式地完成。
+    堆是用于存放进程运行中被动态分配的内存段，它的大小并不固定，可动态扩张或缩减。当进程调用malloc、realloc等函数分配内存时，新分配的内存就被动态添加到堆上（堆被扩张）；当利用free等函数释放内存时，被释放的内存从堆中被剔除（堆被缩减）
 
-- 栈(stack):栈是用户存放程序临时创建的局部变量，也就是说我们函数括弧“{}”中定义的变量（但不包括static声明的变量，static意味着在数据段中存放变量）。栈的生存期随代码块持续性，代码块运行就给你分配空间，代码块结束就自动回收空间。除此以外，在函数被调用时，其参数也会被压入发起调用的进程栈中，并且待到调用结束后，函数的返回值也会被存放回栈中。由于栈的先进先出特点，所以栈特别方便用来保存/恢复调用现场。从这个意义上讲，我们可以把堆栈看成一个寄存、交换临时数据的内存区。
+- 栈(stack):
+    它的申请和释放操作是编译器来隐式管理的，所以有时也称为自动（automatic）内存。
+    栈是用户存放程序临时创建的局部变量，也就是说我们函数括弧“{}”中定义的变量（但不包括static声明的变量，static意味着在数据段中存放变量）。栈的生存期随代码块持续性，代码块运行就给你分配空间，代码块结束就自动回收空间。除此以外，在函数被调用时，其参数也会被压入发起调用的进程栈中，并且待到调用结束后，函数的返回值也会被存放回栈中。由于栈的先进先出特点，所以栈特别方便用来保存/恢复调用现场。从这个意义上讲，我们可以把堆栈看成一个寄存、交换临时数据的内存区。
 
 上述几种内存区域中数据段、BSS和堆通常是被连续存储的——内存位置上是连续的，而代码段和栈往往会被独立存放。有趣的是，堆和栈两个区域关系很“暧昧”，他们一个向下“长”（i386体系结构中栈向下、堆向上），一个向上“长”，相对而生。但你不必担心他们会碰头，因为他们之间间隔很大（到底大到多少，你可以从下面的例子程序计算一下），绝少有机会能碰到一起。
 
 ## 内存的演变
 
-在早些的操作系统中，并没有引入内存抽象的概念。程序直接访问和操作的都是物理内存，内存的管理也非常简单，除去操作系统所用的内存之外，全部给用户程序使用，想怎么折腾都行，只要别超出最大的容量。这种内存操作方式使得操作系统中存在多进程变得完全不可能，比如MS-DOS，你必须执行完一条指令后才能接着执行下一条。如果是多进程的话，由于直接操作物理内存地址，当一个进程给内存地址1000赋值后，另一个进程也同样给内存地址赋值，那么第二个进程对内存的赋值会覆盖第一个进程所赋的值，这回造成两条进程同时崩溃。随着计算机技术发展，要求操作系统支持多进程的需求，所谓多进程，并不需要同时运行这些进程，只要它们都处于ready 状态，操作系统快速地在它们之间切换，就能达到同时运行的假象。每个进程都需要内存，Context Switch时，之前内存里的内容怎么办？简单粗暴的方式就是先dump到磁盘上，然后再从磁盘上restore之前dump的内容（如果有的话），但效果并不好，太慢了！那怎么才能不慢呢？把进程对应的内存依旧留在物理内存中，需要的时候就切换到特定的区域。这就涉及到了内存的保护机制，毕竟进程之间可以随意读取、写入内容就乱套了，非常不安全。因此操作系统需要对物理内存做一层抽象，也就是「地址空间」(Address Space)，一个进程的地址空间包含了该进程所有相关内存，比如code/stack/heap。一个16KB的地址空间可能长这样：
+在早些的操作系统中，并没有引入内存抽象的概念。程序直接访问和操作的都是物理内存，内存的管理也非常简单，除去操作系统所用的内存之外，全部给用户程序使用，想怎么折腾都行，只要别超出最大的容量。这种内存操作方式使得操作系统中存在多进程变得完全不可能，比如MS-DOS，你必须执行完一条指令后才能接着执行下一条。如果是多进程的话，由于直接操作物理内存地址，当一个进程给内存地址1000赋值后，另一个进程也同样给内存地址赋值，那么第二个进程对内存的赋值会覆盖第一个进程所赋的值，这回造成两条进程同时崩溃。随着计算机技术发展，要求操作系统支持多进程的需求，所谓多进程，并不需要同时运行这些进程，只要它们都处于ready 状态，操作系统快速地在它们之间切换，就能达到同时运行的假象。每个进程都需要内存，Context Switch时，之前内存里的内容怎么办？简单粗暴的方式就是先dump到磁盘上，然后再从磁盘上restore之前dump的内容（如果有的话），但效果并不好，太慢了！那怎么才能不慢呢？把进程对应的内存依旧留在物理内存中，需要的时候就切换到特定的区域。这就涉及到了内存的保护机制，毕竟进程之间可以随意读取、写入内容就乱套了，非常不安全。
+
+
+操作系统需要提供一个易用（easy to use）的物理内存抽象。这个抽象叫作地址空间（address space），是运行的程序看到的系统中的内存。
+一个进程的地址空间包含运行的程序的所有内存状态。比如：程序的代码（code，指令）必须在内存中，因此它们在地址空间里。当程序在运行的时候，利用栈（stack）来保存当前的函数调用信息，分配空间给局部变量，传递参数和函数返回值。最后，堆（heap）用于管理动态分配的、用户管理的内存，就像你从C语言中调用malloc()或面向对象语言（如C ++或Java）中调用new 获得内存。当然，还有其他的东西（例如，静态初始化的变量），但现在假设只有这3个部分：代码、栈和堆。
+
+一个16KB的地址空间可能长这样：
+
 
 ![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/memory_1.jpg?raw=true)
 
@@ -132,7 +146,8 @@ Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自
 
 程序所在区域的起始地址≤有效地址≤程序所在区域的起始地址+程序长度
 
-由此可见，我们只需要设置两个端值：基址和变址，即可达到地址翻译和地址保护的目的。这两个端值可以由两个寄存器来存放，分别称为基址寄存器和变址寄存器。在固定分区下，基址就是固定内存分区中各个区域的起始内存地址，而变址则是所加载程序的长度（记住，不是内存各个分区的上限）。
+由此可见，我们只需要设置两个端值：基址和变址，即可达到地址翻译和地址保护的目的。
+这两个端值可以由两个寄存器来存放，分别称为基址寄存器和变址寄存器。在固定分区下，基址就是固定内存分区中各个区域的起始内存地址，而变址则是所加载程序的长度（记住，不是内存各个分区的上限）。
 
 这样，每次程序发出的地址需要和极限比较大小；如果大于极限，则属非法访问。在这个时候我们将陷入内核，终止进程（在个别操作系统上，也可能进入一个异常处理的过程）；否则将基址加上偏移获得物理地址，就可以合法访问这个物理地址。
 
@@ -143,7 +158,10 @@ Linux操作系统采用虚拟内存管理技术，使得每个进程都有各自
 
 每当进程引用内存以获取指令或读取、写入数据时，CPU 都会自动将`基址值`添加到进程生成的地址中，然后再将其发送到内存总线上。同时，它检查程序提供的地址是否大于或等于`变址寄存器` 中的值。如果程序提供的地址要超过变址寄存器的范围，那么会产生错误并中止访问。
 
-
+在动态重定位的过程中，只有很少的硬件参与，但获得了很好的效果。
+一个基址寄存器将虚拟地址转换为物理地址。
+一个界限寄存器确保这个地址在进程地址空间的范围内。
+它们一起提供了既简单又高效的虚拟内存机制。这种基址寄存器配合界限寄存器的硬件结构是芯片中的（每个CPU一对）。有时我们将CPU的这个负责地址转换的部分统称为内存管理单元（Memory Management Unit，MMU）。
 
 ### 分页
 
@@ -426,6 +444,8 @@ void func() {
 
 ***补充：***为什么在你的进程退出时没有内存泄露当你编写一个短时间运行的程序时，可能会使用malloc()分配一些空间。程序运行并即将完成：是否需要在退出前调用几次free()？虽然不释放似乎不对，但在真正的意义上，没有任何内存会“丢失”。原因很简单：系统中实际存在两级内存管理。第一级是由操作系统执行的内存管理，操作系统在进程运行时将内存交给进程，并在进程退出（或以其他方式结束）时将其回收。第二级管理在每个进程中，例如在调用malloc()和free()时，在堆内管理。即使你没有调用free()（并因此泄露了堆中的内存），操作系统也会在程序结束运行时，收回进程的所有内存（包括用于代码、栈，以及相关堆的内存页）。无论地址空间中堆的状态如何，操作系统都会在进程终止时收回所有这些页面，从而确保即使没有释放内存，也不会丢失内存。因此，对于短时间运行的程序，泄露内存通常不会导致任何操作问题（尽管它可能被认为是不好的形式）。如果你编写一个长期运行的服务器（例如Web服务器或数据库管理系统，它永远不会退出），泄露内存就是很大的问题，最终会导致应用程序在内存不足时崩溃。当然，在某个程序内部泄露内存是一个更大的问题：操作系统本身。这再次向我们展示：编写内核代码的人，工作是辛苦的...
 
+### 内存耗尽杀手
+当内存严重不足的时候，页分配器在多次尝试直接页回收失败以后，就会调用内存耗尽杀手（OOM killer, OOM是“Out of Memory”的缩写），选择进程杀死，释放内存。
 
 
 ## Android内存管理
diff --git a/README.md b/README.md
index e3db9d51..f269bd95 100644
--- a/README.md
+++ b/README.md
@@ -238,8 +238,8 @@ Android学习笔记
     - [OOM问题分析][215]
 
 - [Java基础及算法][53]
+    - [数据结构和算法][192]
 	- [八种排序算法][189]
-    - [算法复杂度][192]
 	- [线程池的原理][190]
 	- [设计模式][191]
     - [动态代理][193]
@@ -253,7 +253,7 @@ Android学习笔记
     - [生产者消费者][92]
     - [数据加密及解密][93]
     - [死锁][94]
-    - [常见算法][95]
+    - [算法][95]
     - [网络请求相关内容总结][96]
     - [线程池的原理][97]
     - [Java并发编程之原子性、可见性以及有序性][98]
diff --git "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/\351\237\263\350\247\206\351\242\221\345\234\272\346\231\257.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/\351\237\263\350\247\206\351\242\221\345\234\272\346\231\257.md"
new file mode 100644
index 00000000..8f1d9c49
--- /dev/null
+++ "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/\351\237\263\350\247\206\351\242\221\345\234\272\346\231\257.md"
@@ -0,0 +1,98 @@
+音视频场景
+===
+
+#### 视频点播
+
+视频点播(Video On Demand, VOD)是个人用户最常用的功能之一，也是许多媒体平台的支柱业务，如国外的Netflix、Hulu和国内的爱奇艺、优酷、腾讯视频、B站等。视频点播的核心在于将媒体传输内容的选择权交给用户，将用户选择的音视频媒体内容通过网络传输到用户的播放器进行播放。视频点播的内容可能来源于专业生产内容(PGC)、用户生产内容(UGC)或直播回放内容等，在通过云端服务器转码处理后保存。当用户向平台网站请求某个音视频节目时，媒体流信息通过内容分发网络(CDN)加速后发送至用户的播放客户端。
+一个典型的视频点播系统结构如下：  
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/ffmpeg_vod.png?raw=true)   
+
+
+#### 视频直播
+
+视频直播产生的历史实际上比视频点播更加久远，在早期的有线电视中，几乎所有的节目都只能通过直播的方式呈现给观众。随着网络流媒体的兴起，各种直播平台经历了如“千播大战”的爆发式增长，最后兼并整合为几大巨头平台，如国内的斗鱼、虎牙和B站，以及国外的Twich等。视频直播的整体结构与视频点播有一定的相似性，如都依赖音视频转码服务和内容分发网络进行数据的标准化和加速传输等，它们之间最主要的区别在于，视频直播的内容来自主播端通过采集端实时获取的数据，而视频点播的内容来自内容发布方预先制作的节目内容。
+一个典型的视频直播系统结构如下: 
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/ffmpeg_live.png?raw=true)   
+
+
+#### 安防监控
+
+安防监控是音视频领域的重要应用场景，也是最具商业价值的业务之一。在一个典型的安防监控系统中，通过监控摄像机采集的视频流信息会经由网络视频录像服务器进行录制存储或转发。客户端通过管理服务器控制媒体流转发或录制的逻辑，并可以请求某一路实时流或录像文件的播放。
+一个典型的安防监控系统结构如下:  
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/ffmpeg_anfang.png?raw=true)   
+
+#### 视频会议
+
+视频会议是近年来蓬勃发展的新兴领域之一。2020年，在许多行业均因新冠肺炎疫情遭到重创的情况下，视频会议逆流而上，创造了自诞生以来最为迅速的增长。许多基于公网的视频会议系统都以WebRTC为基础，以尽可能低的延迟提供高质量的音频和视频实时通信服务。
+一个典型的视频会议系统结构如下: 
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/ffmpeg_meeting.png?raw=true)   
+
+
+
+### 常用分辨率
+- 4CIF/SD：
+    图像分辨率为720像素×576像素，也称为标准清晰度（Standard Definition，SD）视频，常用于标清数字电视广播和数字视盘（DVD）。
+- HD/720P：
+    图像分辨率为1280像素×720像素，也称为高清晰度（High Definition，HD）视频，常用于高清晰度数字电视广播和蓝光数字视盘（蓝光DVD）。
+- FHD/1080P：
+    图像分辨率为1920像素×1080像素，也称为全高清晰度（Full High Definition，FHD）视频，与HD视频一样，也常用于高清晰度数字电视广播和蓝光DVD视盘。
+- UHD：
+    分辨率比FHD视频更高的视频格式，也称为超高清（Ultra High Definition，UHD）视频。常用格式有4K和8K等，分辨率分别为3840像素×2160像素（4K）和7680像素×4320像素（8K），常用于超高清数字电视和高端数字娱乐系统。
+
+### 视频压缩编码的基本原理
+
+#### 视频数据中的冗余信息
+像素格式的视频数据之所以能被压缩，其根本原因在于视频中存在冗余信息。我们可以通过多种不同的算法去除冗余信息，从而对数据进行压缩。视频数据中的冗余信息主要有：
+- 时间冗余：视频中相邻两帧之间的内容相似，存在运动关系。
+- 空间冗余：视频中某一帧内部的相邻像素存在相似性。
+- 编码冗余：视频中不同数据出现的概率不同。
+- 视觉冗余：观众的视觉系统对视频中的不同部分敏感度不同。
+
+针对不同类型的冗余信息，在各视频编码的标准算法中都有专门的技术应对，以通过不同的角度提高压缩比率。
+
+#### 预测编码
+
+
+预测编码是数据压缩中最常用的方法之一，例如，在脉冲编码调制（Differential Pulse Code Modulation，DPCM）中，就是用当前采样值与预测采样值的差进行编码的，即通过这种方式减少输出数据的体积。在视频压缩中，预测编码作为最核心的算法之一起到了重要作用。在视频编码中，预测编码主要有两种方法： 
+- 帧内预测：帧内预测是根据当前帧已编码的数据进行预测，利用图像内相邻像素之间的相关性去除视频中的空间冗余。
+- 帧间预测：帧间预测是将部分已编码的图像作为参考帧，利用前后帧之间的时间相关性去除视频中的时间冗余。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/VideoDevelopment/FFmpeg/FFmpeg\345\210\207\347\211\207.md" "b/VideoDevelopment/FFmpeg/FFmpeg\345\210\207\347\211\207.md"
new file mode 100644
index 00000000..6edec0c0
--- /dev/null
+++ "b/VideoDevelopment/FFmpeg/FFmpeg\345\210\207\347\211\207.md"
@@ -0,0 +1,12 @@
+FFmpeg常用命令行
+===
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/VideoDevelopment/FFmpeg/FFmpeg\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214.md" "b/VideoDevelopment/FFmpeg/FFmpeg\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214.md"
index 48913990..5452d9a1 100644
--- "a/VideoDevelopment/FFmpeg/FFmpeg\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214.md"
+++ "b/VideoDevelopment/FFmpeg/FFmpeg\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214.md"
@@ -2,149 +2,146 @@ FFmpeg常用命令行
 ===
 ### ffmpeg
 
-1.分离视频音频流
-
+1. 分离视频音频流
+```
 ffmpeg -i input_file -vcodec copy -an output_file_video　　//分离视频流
 ffmpeg -i input_file -acodec copy -vn output_file_audio　　//分离音频流
+```
 
-2.视频解复用
-
+2. 视频解复用
+```
 ffmpeg –i test.mp4 –vcodec copy –an –f m4v test.264
 ffmpeg –i test.avi –vcodec copy –an –f m4v test.264
+```
 
-3.视频转码
-
+3. 视频转码
+```
 ffmpeg –i test.mp4 –vcodec h264 –s 352*278 –an –f m4v test.264              //转码为码流原始文件
 ffmpeg –i test.mp4 –vcodec h264 –bf 0 –g 25 –s 352*278 –an –f m4v test.264  //转码为码流原始文件
 ffmpeg –i test.avi -vcodec mpeg4 –vtag xvid –qsame test_xvid.avi            //转码为封装文件
 //-bf B帧数目控制，-g 关键帧间隔控制，-s 分辨率控制
-
-4.视频封装
-
+```
+4. 视频封装
+```
 ffmpeg –i video_file –i audio_file –vcodec copy –acodec copy output_file
-
-5.视频剪切
-
+```
+5. 视频剪切
+```
 ffmpeg –i test.avi –r 1 –f image2 image-%3d.jpeg        //提取图片
 ffmpeg -ss 0:1:30 -t 0:0:20 -i input.avi -vcodec copy -acodec copy output.avi    //剪切视频
 //-r 提取图像的频率，-ss 开始时间，-t 持续时间
-
-6.视频录制
-
+```
+6. 视频录制
+```
 ffmpeg –i rtsp://192.168.3.205:5555/test –vcodec copy out.avi
-
-7.YUV序列播放
-
+```
+7. YUV序列播放
+```
 ffplay -f rawvideo -video_size 1920x1080 input.yuv
-
-8.YUV序列转AVI
-
+```
+8. YUV序列转AVI
+```
 ffmpeg –s w*h –pix_fmt yuv420p –i input.yuv –vcodec mpeg4 output.avi
-
+```
 常用参数说明：
 
-主要参数： -i 设定输入流 -f 设定输出格式 -ss 开始时间 视频参数： -b 设定视频流量，默认为200Kbit/s -r 设定帧速率，默认为25 -s 设定画面的宽与高 -aspect 设定画面的比例 -vn 不处理视频 -vcodec 设定视频编解码器，未设定时则使用与输入流相同的编解码器 音频参数： -ar 设定采样率 -ac 设定声音的Channel数 -acodec 设定声音编解码器，未设定时则使用与输入流相同的编解码器 -an 不处理音频
-
-------------------------------------------------------------------------
-
-----------------------------------------------------------------------------------------------------------
+主要参数：-i 设定输入流 -f 设定输出格式 -ss 开始时间
+视频参数：-b 设定视频流量，默认为200Kbit/s -r 设定帧速率，默认为25 -s 设定画面的宽与高 -aspect 设定画面的比例 -vn 不处理视频 -vcodec 设定视频编解码器，未设定时则使用与输入流相同的编解码器
+音频参数：-ar 设定采样率 -ac 设定声音的Channel数 -acodec 设定声音编解码器，未设定时则使用与输入流相同的编解码器 -an 不处理音频
 
-------------------------------------------------------------------------
-
-0.压缩转码mp4文件
 
+9. 压缩转码mp4文件
+```
 ffmpeg -i input.avi -s 640x480 output.avi
 
 ffmpeg -i input.avi -s vga output.avi
-
- 
-
-1、将文件当做直播送至live
-
+```
+10. 将文件当做直播送至live
+```
 ffmpeg -re -i localFile.mp4 -c copy -f flv rtmp://server/live/streamName
-
-2、将直播媒体保存至本地文件
-
- 
-
+```
+11. 将直播媒体保存至本地文件
+```
 ffmpeg -i rtmp://server/live/streamName -c copy dump.flv
+```
+12. 将其中一个直播流，视频改用h264压缩，音频不变，送至另外一个直播服务流
 
-3、将其中一个直播流，视频改用h264压缩，音频不变，送至另外一个直播服务流
-
- 
-
+```
 ffmpeg -i rtmp://server/live/originalStream -c:a copy -c:v libx264 -vpre slow -f flv rtmp://server/live/h264Stream
-
- 
-
-4、将其中一个直播流，视频改用h264压缩，音频改用faac压缩，送至另外一个直播服务流
-
+```
+13. 将其中一个直播流，视频改用h264压缩，音频改用faac压缩，送至另外一个直播服务流
+```
 ffmpeg -i rtmp://server/live/originalStream -c:a libfaac -ar 44100 -ab 48k -c:v libx264 -vpre slow -vpre baseline -f flv rtmp://server/live/h264Stream
-
-5、将其中一个直播流，视频不变，音频改用faac压缩，送至另外一个直播服务流
-
+```
+14. 将其中一个直播流，视频不变，音频改用faac压缩，送至另外一个直播服务流
+```
 ffmpeg -i rtmp://server/live/originalStream -acodec libfaac -ar 44100 -ab 48k -vcodec copy -f flv rtmp://server/live/h264_AAC_Stream
-
-6、将一个高清流，复制为几个不同视频清晰度的流重新发布，其中音频不变
-
+```
+15. 将一个高清流，复制为几个不同视频清晰度的流重新发布，其中音频不变
+```
 ffmpeg -re -i rtmp://server/live/high_FMLE_stream -acodec copy -vcodec x264lib -s 640×360 -b 500k -vpre medium -vpre baseline rtmp://server/live/baseline_500k -acodec copy -vcodec x264lib -s 480×272 -b 300k -vpre medium -vpre baseline rtmp://server/live/baseline_300k -acodec copy -vcodec x264lib -s 320×200 -b 150k -vpre medium -vpre baseline rtmp://server/live/baseline_150k -acodec libfaac -vn -ab 48k rtmp://server/live/audio_only_AAC_48k
+```
 
-7、功能一样，只是采用-x264opts选项
-
-ffmpeg -re -i rtmp://server/live/high_FMLE_stream -c:a copy -c:v x264lib -s 640×360 -x264opts bitrate=500:profile=baseline:preset=slow rtmp://server/live/baseline_500k -c:a copy -c:v x264lib -s 480×272 -x264opts bitrate=300:profile=baseline:preset=slow rtmp://server/live/baseline_300k -c:a copy -c:v x264lib -s 320×200 -x264opts bitrate=150:profile=baseline:preset=slow rtmp://server/live/baseline_150k -c:a libfaac -vn -b:a 48k rtmp://server/live/audio_only_AAC_48k
-
-8、将当前摄像头及音频通过DSSHOW采集，视频h264、音频faac压缩后发布
-
-ffmpeg -r 25 -f dshow -s 640×480 -i video=”video source name”:audio=”audio source name” -vcodec libx264 -b 600k -vpre slow -acodec libfaac -ab 128k -f flv rtmp://server/application/stream_name
-
-9、将一个JPG图片经过h264压缩循环输出为mp4视频
-
+16. 将一个JPG图片经过h264压缩循环输出为mp4视频
+```
 ffmpeg.exe -i INPUT.jpg -an -vcodec libx264 -coder 1 -flags +loop -cmp +chroma -subq 10 -qcomp 0.6 -qmin 10 -qmax 51 -qdiff 4 -flags2 +dct8x8 -trellis 2 -partitions +parti8x8+parti4x4 -crf 24 -threads 0 -r 25 -g 25 -y OUTPUT.mp4
-
-10、将普通流视频改用h264压缩，音频不变，送至高清流服务(新版本FMS live=1)
-
+```
+17. 将普通流视频改用h264压缩，音频不变，送至高清流服务(新版本FMS live=1)
+```
 ffmpeg -i rtmp://server/live/originalStream -c:a copy -c:v libx264 -vpre slow -f flv “rtmp://server/live/h264Stream live=1〃
+```
 
-
-------------------------------------------------------------------------
-
-----------------------------------------------------------------------------------------------------------
-
-------------------------------------------------------------------------
-
- 
-
-1.采集usb摄像头视频命令：
-
+18. 采集usb摄像头视频命令：
+```
 ffmpeg -t 20 -f vfwcap -i 0 -r 8 -f mp4 cap1111.mp4
-
- 
-
 ./ffmpeg -t 10 -f vfwcap -i 0 -r 8 -f mp4 cap.mp4
+```
+具体说明如下：
+我们采集10秒，采集设备为vfwcap类型设备，第0个vfwcap采集设备（如果系统有多个vfw的视频采集设备，可以通过-i num来选择），每秒8帧，输出方式为文件，格式为mp4。
 
-具体说明如下：我们采集10秒，采集设备为vfwcap类型设备，第0个vfwcap采集设备（如果系统有多个vfw的视频采集设备，可以通过-i num来选择），每秒8帧，输出方式为文件，格式为mp4。
+19. 最简单的抓屏：
+```
+ffmpeg -f gdigrab -i desktop out.mpg
+```
 
- 
+20. 从屏幕的（10,20）点处开始，抓取640x480的屏幕，设定帧率为5 ：
+```
+ffmpeg -f gdigrab -framerate 5 -offset_x 10 -offset_y 20 -video_size 640x480 -i desktop out.mpg
+```
 
-2.最简单的抓屏：
+21. ffmpeg从视频中生成gif图片：
+```
+ffmpeg -i capx.mp4 -t 10 -s 320x240 -pix_fmt rgb24 jidu1.gif
+```
 
-ffmpeg -f gdigrab -i desktop out.mpg 
+22. 视频文件切片
+```
+// 将一个MP4文件切割为MP4切片，切出来的切片文件的时间戳与上一个MP4的结束时间戳是连续的
+ffmpeg -re -i input.mp4 -c copy -f segment -segment_format mp4 test_output-%d.mp4
+```
 
- 
+23. moov前置
+当使用ffmpeg的默认参数输出为MP4格式时，moov会在所有数据转封装完成后生成，然后添加在文件的末尾。由于获取moov相对较为复杂，因此MP4格式对流媒体播放等场景并不友好。为了解决该问题，在使用ffmpeg进行转封装操作时，可以在选项-movflags中加入参数faststart。
+```
+ffmpeg -i input.avi -c copy -movflags faststart output.mp4
+```
+在加入参数faststart后，ffmpeg在完成转封装操作后会进行一次附加操作——将moov置于文件头部。
 
-3.从屏幕的（10,20）点处开始，抓取640x480的屏幕，设定帧率为5 ：
+24. 设置视频帧率
+滤镜fps可以设置输入视频的帧率。当输入视频的帧率与设置帧率不一致时，ffmpeg将通过丢帧或复制当前帧的方式确保输出视频帧率的稳定性。滤镜fps支持的参数如下。◎ fps：指定输出视频的帧率，默认为25。◎ start_time：指定起始时间戳。◎ round：时间戳近似方法。◎ eof_action：末尾帧的处理方法。通过以下命令可以将输入视频的帧率设置为30。
+```
+ffmpeg -i input.mp4 -vf fps=fps=30 -y output.mp4
+```
 
-ffmpeg -f gdigrab -framerate 5 -offset_x 10 -offset_y 20 -video_size 640x480 -i desktop out.mpg 
 
- 
 
-4.ffmpeg从视频中生成gif图片：
 
-ffmpeg -i capx.mp4 -t 10 -s 320x240 -pix_fmt rgb24 jidu1.gif
+### ffplay
 
+ffplay是以FFmpeg框架为基础，外加渲染音视频的库libSDL构建的媒体文件播放器。ffplay不仅仅是播放器，同时也是测试ffmpeg的codec引擎、format引擎以及filter引擎的工具。并且还可以进行媒体参数分析，可以通过ffplay --help进行查看。 
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/ffmpeg_ffplay.png?raw=true)
 
-### ffplay
-ffplay是以FFmpeg框架未基础，外加渲染音视频的库libSDL构建的媒体文件播放器。
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/ffmpeg_ffplay1.png?raw=true)
 
 ffplay [选项] [输入文件]
 
@@ -186,6 +183,11 @@ ffplay http://219.151.31.38/liveplay-kk.rtxapp.com/live/program/live/hnwshd/4000
 如果希望从视频的第30秒开始播放，播放10秒钟的文件，则可以使用如下命令 
 `ffplay -ss 30 -t 10 /Users/xxx/Desktop/111.mp4`
 
+
+使用ffplay除了可以播放视频流媒体文件之外，还可以作为可视化的视频流媒体分析工具，例如播放音频文件时，如果不确定文件的声音是否正常，则可以直接使用ffplay播放音频文件，播放的时候其将会把解码后的音频数据以音频波形的形式显示出来，命令行执行后的效果如图2-8所示，命令如下：
+`ffplay -showmode 1 output.mp3`
+
+
 ##### 音画同步
 
 ffplay也是一个视频播放器，所以不得不提出来的一个问题是：音画同步。
@@ -210,7 +212,7 @@ ffplay的音画同步的实现方式其实有三种，分别是：
 
 
 ### ffprobe
-ffprobe是ffmpeg命令行中用来查看媒体文件格式的工具。 
+ffprobe是ffmpeg命令行中用来查看媒体文件格式的工具。 ffprobe常用的参数比较多，可以通过ffprobe --help来查看详细的帮助信息。
 
 命令格式: 
 `ffprobe [文件名]`
@@ -250,8 +252,8 @@ Input #0, mov,mp4,m4a,3gp,3g2,mj2, from '/Users/xuchuanren/Desktop/111.mp4':
       vendor_id       : [0][0][0][0]
 ```
 
-查看流的格式信息
-ffprobe -show_format -i /Users/xxx/Desktop/111.mp4 
+查看流的多媒体封装格式
+ffprobe -show_format /Users/xxx/Desktop/111.mp4 
 
 ```
 [FORMAT]
@@ -272,11 +274,224 @@ TAG:encoder=Multimedia Cloud Transcode (cloud.baidu.com)
 TAG:comment=Content Adaptive Encoding 3.0
 [/FORMAT]
 ```
+这个文件的格式有可能是MOV、MP4、M4A、3GP、3G2或者MJ2，之所以ffprobe会这么输出，是因为这几种封装格式在ffmpeg中所识别的标签基本相同，所以才会有这么多种显示方式
+format字段说明
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/ffmpeg_format.png?raw=true)
+
 查看每一帧信息
-ffprobe -show_frames -i /Users/xxx/Desktop/111.mp4 
+`ffprobe -show_frames /Users/xxx/Desktop/111.mp4` 
+```
+[FRAME]
+media_type=video
+stream_index=0
+key_frame=0
+pkt_pts=530432
+pkt_pts_time=41.440000
+pkt_dts=N/A
+pkt_dts_time=N/A
+best_effort_timestamp=530432
+best_effort_timestamp_time=41.440000
+pkt_duration=512
+pkt_duration_time=0.040000
+pkt_pos=846850
+pkt_size=41
+width=1280
+height=720
+pix_fmt=yuv420p
+sample_aspect_ratio=1:1
+pict_type=P
+coded_picture_number=1033
+display_picture_number=0
+interlaced_frame=0
+top_field_first=0
+repeat_pict=0
+color_range=unknown
+color_space=unknown
+color_primaries=unknown
+color_transfer=unknown
+chroma_location=left
+[/FRAME]
+```
+frame字段说明
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/ffmpeg_frame.png?raw=true)
 
 查看包信息
-ffprobe -show_packets -i /Users/xxx/Desktop/111.mp4 
+`ffprobe -show_packets /Users/xxx/Desktop/111.mp4`
+```
+[PACKET]
+codec_type=audio
+stream_index=1
+pts=1827840
+pts_time=41.447619
+dts=1827840
+dts_time=41.447619
+duration=1024
+duration_time=0.023220
+size=176
+pos=848485
+flags=K_
+[/PACKET]
+[PACKET]
+codec_type=audio
+stream_index=1
+pts=1828864
+pts_time=41.470839
+dts=1828864
+dts_time=41.470839
+duration=1021
+duration_time=0.023152
+size=234
+pos=848661
+flags=K_
+[/PACKET]
+```
+
+packet字段说明
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/ffmpeg_packet.png?raw=true)
+
+
+
+查看流信息
+`ffprobe -show_streams /Users/xxx/Desktop/111.mp4`
+```
+ffprobe version 4.4 Copyright (c) 2007-2021 the FFmpeg developers
+  built with Apple clang version 12.0.5 (clang-1205.0.22.9)
+  configuration: --prefix=/usr/local/Cellar/ffmpeg/4.4_2 --enable-shared --enable-pthreads --enable-version3 --cc=clang --host-cflags= --host-ldflags= --enable-ffplay --enable-gnutls --enable-gpl --enable-libaom --enable-libbluray --enable-libdav1d --enable-libmp3lame --enable-libopus --enable-librav1e --enable-librubberband --enable-libsnappy --enable-libsrt --enable-libtesseract --enable-libtheora --enable-libvidstab --enable-libvorbis --enable-libvpx --enable-libwebp --enable-libx264 --enable-libx265 --enable-libxml2 --enable-libxvid --enable-lzma --enable-libfontconfig --enable-libfreetype --enable-frei0r --enable-libass --enable-libopencore-amrnb --enable-libopencore-amrwb --enable-libopenjpeg --enable-libspeex --enable-libsoxr --enable-libzmq --enable-libzimg --disable-libjack --disable-indev=jack --enable-avresample --enable-videotoolbox
+  libavutil      56. 70.100 / 56. 70.100
+  libavcodec     58.134.100 / 58.134.100
+  libavformat    58. 76.100 / 58. 76.100
+  libavdevice    58. 13.100 / 58. 13.100
+  libavfilter     7.110.100 /  7.110.100
+  libavresample   4.  0.  0 /  4.  0.  0
+  libswscale      5.  9.100 /  5.  9.100
+  libswresample   3.  9.100 /  3.  9.100
+  libpostproc    55.  9.100 / 55.  9.100
+Input #0, mov,mp4,m4a,3gp,3g2,mj2, from '/Users/xuchuanren/Desktop/111.mp4':
+  Metadata:
+    major_brand     : isom
+    minor_version   : 512
+    compatible_brands: isomiso2avc1mp41
+    encoder         : Multimedia Cloud Transcode (cloud.baidu.com)
+    comment         : Content Adaptive Encoding 3.0
+  Duration: 00:00:41.52, start: 0.000000, bitrate: 163 kb/s
+  Stream #0:0(und): Video: h264 (High) (avc1 / 0x31637661), yuv420p, 1280x720 [SAR 1:1 DAR 16:9], 91 kb/s, 25 fps, 25 tbr, 12800 tbn, 50 tbc (default)
+    Metadata:
+      handler_name    : VideoHandler
+      vendor_id       : [0][0][0][0]
+  Stream #0:1(und): Audio: aac (LC) (mp4a / 0x6134706D), 44100 Hz, stereo, fltp, 65 kb/s (default)
+    Metadata:
+      handler_name    : SoundHandler
+      vendor_id       : [0][0][0][0]
+[STREAM]
+index=0
+codec_name=h264
+codec_long_name=H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10
+profile=High
+codec_type=video
+codec_tag_string=avc1
+codec_tag=0x31637661
+width=1280
+height=720
+coded_width=1280
+coded_height=720
+closed_captions=0
+has_b_frames=2
+sample_aspect_ratio=1:1
+display_aspect_ratio=16:9
+pix_fmt=yuv420p
+level=31
+color_range=unknown
+color_space=unknown
+color_transfer=unknown
+color_primaries=unknown
+chroma_location=left
+field_order=unknown
+refs=1
+is_avc=true
+nal_length_size=4
+id=N/A
+r_frame_rate=25/1
+avg_frame_rate=25/1
+time_base=1/12800
+start_pts=0
+start_time=0.000000
+duration_ts=530944
+duration=41.480000
+bit_rate=91747
+max_bit_rate=N/A
+bits_per_raw_sample=8
+nb_frames=1037
+nb_read_frames=N/A
+nb_read_packets=N/A
+DISPOSITION:default=1
+DISPOSITION:dub=0
+DISPOSITION:original=0
+DISPOSITION:comment=0
+DISPOSITION:lyrics=0
+DISPOSITION:karaoke=0
+DISPOSITION:forced=0
+DISPOSITION:hearing_impaired=0
+DISPOSITION:visual_impaired=0
+DISPOSITION:clean_effects=0
+DISPOSITION:attached_pic=0
+DISPOSITION:timed_thumbnails=0
+TAG:language=und
+TAG:handler_name=VideoHandler
+TAG:vendor_id=[0][0][0][0]
+[/STREAM]
+[STREAM]
+index=1
+codec_name=aac
+codec_long_name=AAC (Advanced Audio Coding)
+profile=LC
+codec_type=audio
+codec_tag_string=mp4a
+codec_tag=0x6134706d
+sample_fmt=fltp
+sample_rate=44100
+channels=2
+channel_layout=stereo
+bits_per_sample=0
+id=N/A
+r_frame_rate=0/0
+avg_frame_rate=0/0
+time_base=1/44100
+start_pts=0
+start_time=0.000000
+duration_ts=1829885
+duration=41.493991
+bit_rate=65031
+max_bit_rate=N/A
+bits_per_raw_sample=N/A
+nb_frames=1788
+nb_read_frames=N/A
+nb_read_packets=N/A
+DISPOSITION:default=1
+DISPOSITION:dub=0
+DISPOSITION:original=0
+DISPOSITION:comment=0
+DISPOSITION:lyrics=0
+DISPOSITION:karaoke=0
+DISPOSITION:forced=0
+DISPOSITION:hearing_impaired=0
+DISPOSITION:visual_impaired=0
+DISPOSITION:clean_effects=0
+DISPOSITION:attached_pic=0
+DISPOSITION:timed_thumbnails=0
+TAG:language=und
+TAG:handler_name=SoundHandler
+TAG:vendor_id=[0][0][0][0]
+[/STREAM]
+```
+
+stream字段说明： 
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/ffmpeg_stream.png?raw=true)
+
+
+
+
+
 
 
 
diff --git "a/VideoDevelopment/FFmpeg/FFmpeg\347\256\200\344\273\213.md" "b/VideoDevelopment/FFmpeg/FFmpeg\347\256\200\344\273\213.md"
index 5e5d1c78..e70b702b 100644
--- "a/VideoDevelopment/FFmpeg/FFmpeg\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/FFmpeg/FFmpeg\347\256\200\344\273\213.md"
@@ -3,15 +3,23 @@ FFmpeg简介
 
 FFmpeg是一个开源免费跨平台的视频和音频流方案，属于自由软件，采用LGPL或GPL许可证（依据你选择的组件）。它提供了录制、转换以及流化音视频的完整解决方案。它包含了非常先进的音频/视频编解码库libavcodec，为了保证高可移植性和编解码质量，libavcodec里很多codec都是从头开发的。
 
-主要的开发库：
+FFmpeg框架的基本组成包含： 
+- AVFormat
+    AVFormat中实现了目前多媒体领域中的绝大多数媒体封装格式，包括封装和解封装，如MP4、FLV、KV、TS等文件封装格式，RTMP、RTSP、MMS、HLS等网络协议封装格式。FFmpeg是否支持某种媒体封装格式，取决于编译时是否包含了该格式的封装库。根据实际需求，可进行媒体封装格式的扩展，增加自己定制的封装格式，即在AVFormat中增加自己的封装处理模块。
+- AVCodec
+    AVCodec中实现了目前多媒体领域绝大多数常用的编解码格式，既支持编码，也支持解码。AVCodec除了支持MPEG4、AAC、MJPEG等自带的媒体编解码格式之外，还支持第三方的编解码器，如H.264（AVC）编码，需要使用x264编码器；H.265（HEVC）编码，需要使用x265编码器；MP3（mp3lame）编码，需要使用libmp3lame编码器。如果希望增加自己的编码格式，或者硬件编解码，则需要在AVCodec中增加相应的编解码模块
+- AVFilter
+    AVFilter库提供了一个通用的音频、视频、字幕等滤镜处理框架。在AVFilter中，滤镜框架可以有多个输入和多个输出。
+- AVDevice
+    读取电脑（或者其他设备上）的多媒体设备的数据 或者输出数据到指定的多媒体设备上；
+- AVUtil
+    包含一些公共的工具函数，包括随机数生成、数据结构、核心多媒体工具等；
+- swscale
+    swscale模块提供了高级别的图像转换API，例如它允许进行图像缩放和像素格式转换，常见于将图像从1080p转换成720p或者480p等的缩放，或者将图像数据从YUV420P转换成YUYV，或者YUV转RGB等图像格式转换。
+- swresample
+    用于音频采样采样数据（PCM）转换的库,提供了高级别的音频重采样API。
+
 
-- libavutil：包含一些公共的工具函数，包括随机数生成、数据结构、核心多媒体工具等；
-- libavcodec：用于各种类型声音/图像encode/decode编解码库；
-- libavformat：用于各种音视频封装格式（mp4/AVI/Flv等）的生成和解析muxer/demuxer，包括获取解码所需信息以生成解码上下文结构和读取音视频帧等功能；
-- libavdevice:读取电脑（或者其他设备上）的多媒体设备的数据 或者输出数据到指定的多媒体设备上；
-- libswresample: 用于音频采样采样数据（PCM）转换的库；
-- libswscale：用于视频场景比例缩放、色彩映射转换的库；
-- libavfilter: 包含媒体滤波器的库
 
 主要的工具集：
 
@@ -21,6 +29,28 @@ FFmpeg是一个开源免费跨平台的视频和音频流方案，属于自由
 - ffprobe : 一个多媒体流分析工具。 它从多媒体流中收集信息 并且以人类和机器可读的形式打印出来。
 
 
+ffmpeg的主要工作流程相对比较简单，具体如下： 
+- 解封装（Demuxing）
+- 解码（Decoding）
+- 编码（Encoding）
+- 封装（Muxing）
+
+其中需要经过6个步骤，具体如下： 
+- 读取输入源
+- 进行音视频的解封装
+- 解码每一帧音视频数据
+- 编码每一帧音视频数据
+- 进行音视频的重新封装
+- 输出到目标
+
+
+ffmpeg整体处理的工作流程与步骤为： 
+读取文件 → 解封装 → 解码 → 转换参数 → 新编码 → 封装 → 写入文件
+ffmpeg首先读取输入源；然后通过Demuxer将音视频包进行解封装，这个动作通过调用libavformat中的接口即可实现；接下来通过Decoder进行解码，将音视频通过Decoder解包成为YVU或者PCM这样的数据，Decoder通过libavcodec中的接口即可实现；然后通过Encoder将对应的数据进行编码，编码可以通过libavcodec中的接口来实现；接下来将编码后的音视频数据包通过Muxer进行封装，Muxer封装通过libavformat中的接口即可实现，输出成为输出流。
+
+
+
+
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/FLV.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/FLV.md"
index fc651d43..0eae8fdf 100644
--- "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/FLV.md"
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/FLV.md"
@@ -1,6 +1,7 @@
 FLV
 ===
 
+在网络的直播与点播场景中，FLV也是一种常见的格式，FLV是Adobe发布的一种可以作为直播也可以作为点播的封装格式，其封装格式非常简单，均以FLVTAG的形式存在，并且每一个TAG都是独立存在的.
 
 FLV封装格式是由一个文件头（FLV header）和很多tag组成的（FLV body）二进制文件。
 Tag中包含了音频数据以及视频数据，每个Tag又有一个preTagSize字段，标记着前面一个Tag的大小，FLV的结构如下图所示。
@@ -40,60 +41,55 @@ tag结构图：
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_body_tag.png?raw=true)   
 
 tag header：
+- 第1个byte为记录着tag的类型，音频（0x8），视频（0x9），脚本（0x12）；
+- 第2到4bytes是数据区的长度，也就是tag data的长度；
+- 再后面3个bytes是时间戳，单位是毫秒，类型为0x12则时间戳为0，时间戳控制着文件播放的速度，可以根据音视频的帧率类设置；
+- 时间戳后面一个byte是扩展时间戳，时间戳不够长的时候用；
+- 最后3bytes是streamID，但是总为0，再后面就是数据区了（tag data），也即是h264的裸流；
+- tag header 长度为1+3+3+1+3=11。
 
-１）第1个byte为记录着tag的类型，音频（0x8），视频（0x9），脚本（0x12）；
-
-２）第2到4bytes是数据区的长度，也就是tag data的长度；
-
-３）再后面3个bytes是时间戳，单位是毫秒，类型为0x12则时间戳为0，时间戳控制着文件播放的速度，可以根据音视频的帧率类设置；
-
-４）时间戳后面一个byte是扩展时间戳，时间戳不够长的时候用；
-
-５）最后3bytes是streamID，但是总为0，再后面就是数据区了（tag data），也即是h264的裸流；
-
-６）tag header 长度为1+3+3+1+3=11。
-
-音频TagData结构分析：
+##### 音频TagData结构分析：
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_audio_tag.png?raw=true)   
 
 音频参数中各字段的值及其意义如下表所示：
 
-
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_audio_tag2.png?raw=true)   
 
-音频参数对照表
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_audio_tag3.png?raw=true)   
 
-视频TagData结构：
 
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_video_tag.png?raw=true)   
+##### 视频TagData结构：
 
-Script TagData结构
-
-Script Tag通常被称为Metadata Tag，会放一些关于FLV视频和音频的元数据信息如：duration、width、height等。通常此类型Tag会跟在File Header后面作为第一个Tag出现，而且只有一个。
-
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_script_tag.png?raw=true)   
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_video_tag.png?raw=true)   
 
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_video_tag2.png?raw=true)   
 
 
-第一个AMF包：
+##### Script TagData结构
 
-第1个字节表示AMF包类型，一般总是0x02，表示字符串。第2-3个字节为UI16类型值，标识字符串的长度，一般总是 0x000A（“onMetaData”长度）。后面字节为具体的字符串，一般  为“onMetaData”（6F,6E,4D,65,74,61,44,61,74,61）。
+Script Tag通常被称为Metadata Tag，会放一些关于FLV视频和音频的元数据信息如：duration、width、height等。通常此类型Tag会跟在File Header后面作为第一个Tag出现，而且只有一个。
 
-所以第一个AMF包总共占13字节。
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_script_tag.png?raw=true)   
 
-第二个AMF包结构图：
+- 第一个AMF包：
+    第1个字节表示AMF包类型，一般总是0x02，表示字符串。第2-3个字节为UI16类型值，标识字符串的长度，一般总是 0x000A（“onMetaData”长度）。后面字节为具体的字符串，一般  为“onMetaData”（6F,6E,4D,65,74,61,44,61,74,61）。
+    所以第一个AMF包总共占13字节。
 
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_awf_tag.png?raw=true)   
+- 第二个AMF包结构图：
+    ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_awf_tag.png?raw=true)   
 
- 第二个AMF包结构图
+     第二个AMF包结构图
 
-第1个字节表示AMF包类型，一般总是0x08，表示数组。第2-5个字节为UI32类型值，表示数组元素的个数，后面即为各数组元素的封装。数组元素为元素名称和值组成的对。“数组元素结构”部分是推测，已经确认适用于duration、width、height等常见元素，但并不确认适用于所有元素。常见的数组元素如下表所示。
+    第1个字节表示AMF包类型，一般总是0x08，表示数组。第2-5个字节为UI32类型值，表示数组元素的个数，后面即为各数组元素的封装。数组元素为元素名称和值组成的对。“数组元素结构”部分是推测，已经确认适用于duration、width、height等常见元素，但并不确认适用于所有元素。常见的数组元素如下表所示。
 
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_amf_tag.jpg?raw=true)   
+    ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_amf_tag.jpg?raw=true)   
 
 
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_script_tag_2.png?raw=true)   
 
+可以使用FFmpeg中的ffprobe来解析FLV文件，并且其还能够将关键帧索引的相关信息打印出来： 
+`ffprobe -v trace -i output.flv`
 
 
 参考: 
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/M3U8.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/M3U8.md"
new file mode 100644
index 00000000..474c93db
--- /dev/null
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/M3U8.md"
@@ -0,0 +1,84 @@
+M3U8
+===
+
+M3U8是一种常见的流媒体格式，主要以文件列表的形式存在，既支持直播又支持点播，尤其在Android、iOS等平台最为常用，下面就来看一下M3U8的最简单的例子：
+```
+#EXTM3U    // m3u8文件头
+#EXT-X-VERSION:3
+#EXT-X-TARGETDURATION:4
+#EXT-X-MEDIA-SEQUENCE:0
+#EXTINF:3.760000,
+out0.ts
+#EXTINF:1.880000,
+out1.ts
+#EXTINF:1.760000,
+out2.ts
+#EXTINF:1.040000,
+out3.ts
+#EXTINF:1.560000,
+out4.ts
+```
+
+从这个例子中可以看到如下几个字段，其含义具体如下: 
+- EXTM3U
+
+M3U8文件必须包含的标签，并且必须在文件的第一行，所有的M3U8文件中必须包含这个标签。
+- EXT-X-VERSION
+
+M3U8文件的版本，常见的是3，其实版本已经发展了很多了，直至截稿时，已经发布到了版本7，经历了这么多版本，期间也对不少标记进行了增删。例如在版本2以后支持了EXT-X-KEY标签，在版本3以后支持了浮点EXTINF的duration值，在版本4以后支持了EXT-X-BYTERAGE标签与EXT-X-I-FRAMES-ONLY标签，在版本5以后支持了EXT-X-KEY的格式说明KEYFORMAT与KEYFORMATVE-RSION标签以及EXT-X-MAP标签，在版本6以后支持了EXT-X-MAP标签里面不包含EXT-X-I-FRAMES-ONLY标签。当然，也在一些版本中删除了一些标签，例如版本6中删掉了EXT-X-STREAM-INF标签与EXT-X-I-FRAME-STREAM-INF标签，版本7中删除掉了EXT-X-ALLOW-CACHE标签等信息。
+
+- EXT-X-TARGETDURATION
+
+每一个分片都会有一个分片自己的duration，这个标签是最大的那个分片的浮点数四舍五入后的整数值，例如1.02四舍五入后的整数为1,2.568四舍五入后的整数为3，如果在M3U8分片列表中的最大的duration的数值为5.001，那么这个EXT-X-TARGETDURATION值为5。
+
+- EXT-X-MEDIA-SEQUENCE
+
+M3U8直播时的直播切片序列，当播放打开M3U8时，以这个标签的值为参考，播放对应的序列号的切片。当然关于客户端播放M3U8的标准还有更多的讲究，下面就来逐项进行介绍。分片必须是动态改变的，序列不能相同，并且序列必须是增序的。当M3U8列表中没有出现EXT-X-ENDLIST标签时，无论这个M3U8列表中有多少片分片，播放分片都是从倒数第三片开始播放，如果不满三片则不应该播放。当然，如果有些播放器特别定制了的话，则可以不遵照这个原则。如果前一片分片与后一片分片有不连续的时候播放可能会出错，那么需要使用EXT-X-DISCONTINUITY标签来解决这个错误。
+以播放当前分片的duration时间刷新M3U8列表，然后做对应的加载动作。如果播放列表在刷新之后与之前的列表相同，那么在播放当前分片duration一半的时间内再刷新一次。
+
+- EXTINF
+EXTINF为M3U8列表中每一个分片的duration，如上面例子输出信息中的第一个分片的duration为4.120000秒；在EXTINF标签中除了duration值，还可以包含可选的描述信息，主要为标注切片信息，使用逗号分隔开。EXTINF下面的信息为具体的分片信息，分片存储路径可以为相对路径，也可以为绝对路径，也可以为互联网的URL链接地址。除了以上的这些标签之外，还有一些标签同样是常用的标签，具体如下。
+
+- EXT-X-ENDLIST
+若出现EXT-X-ENDLIST标签，则表明该M3U8文件不会再产生更多的切片，可以理解为该M3U8已停止更新，并且播放分片到这个标签后结束。M3U8不仅仅是可以作为直播，也可以作为点播存在，在M3U8文件中保留所有切片信息最后使用EXT-X-ENDLIST结尾，这个M3U8即为点播M3U8。
+
+- EXT-X-STREAM-INF
+EXT-X-STREAM-INF标签出现在M3U8中时，主要是出现在多级M3U8文件中时，例如M3U8中包含子M3U8列表，或者主M3U8中包含多码率M3U8时；该标签后需要跟一些属性，下面就来逐一说明这些属性。
+    - BANDWIDTH
+        BANDWIDTH的值为最高码率值，当播放EXT-X-STREAM-INF下对应的M3U8时占用的最大码率，这个参数是EXT-X-STREAM-INF标签中必须要包含的属性。
+    - AVERAGE-BANDWIDTH
+        AVERAGE-BANDWIDTH的值为平均码率值，当播放EXT-X-STREAM-INF下对应的M3U8时占用的平均码率，这个参数是一个可选参数。
+    - CODECS
+        CODECS的值用于声明EXT-X-STREAM-INF下面对应M3U8里面的音频编码、视频编码的信息，例如，若AAC-LC的音频与视频为H.264 Main Profile、Level 3.0的话，则CODECS值为“mp4a.40.2, avc1.4d401e”，这个属性应该出现在EXT-X-STREAM-INF标签里，但是并不是所有的M3U8中都可以看到，仅供参考。
+    - RESOLUTION
+        M3U8中视频的宽高信息描述，这个属性是一个可选属性。
+    - FRAME-RATE
+        子M3U8中的视频帧率，这个属性依然是一个可选属性。        
+    下面针对EXT-X-STREAM-INF举一个实际的例子：
+    ```
+    #EXTM3U
+    #EXT-X-STREAM-INF:BANDWIDTH=1280000, AVERAGE-BANDWIDTH=1000000
+    http://example.com/low.m3u8
+    #EXT-X-STREAM-INF:BANDWIDTH=2560000, AVERAGE-BANDWIDTH=2000000
+    http://example.com/mid.m3u8
+    #EXT-X-STREAM-INF:BANDWIDTH=7680000, AVERAGE-BANDWIDTH=6000000
+    http://example.com/hi.m3u8
+    #EXT-X-STREAM-INF:BANDWIDTH=65000, CODECS="mp4a.40.5"
+    http://example.com/audio-only.m3u8
+    ```    		
+    在这个M3U8文件中，使用了4个EXT-X-STREAM-INF标签来标注子M3U8的属性：最高码率为1.28M、平均码率为1M的M3U8，最高码率为2.56M、平均码率为2M的M3U8，最高码率为7.68M、平均码率为6M的M3U8，以及只有65K的音频编码的M3U8。    
+
+
+FFmpeg中自带HLS的封装参数，使用HLS格式即可进行HLS的封装，但是生成HLS的时候有各种参数可以进行参考，例如设置HLS列表中切片的前置路径、生成HLS的TS切片时设置TS的分片参数、生成HLS时设置M3U8列表中保存的TS个数等: 
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/ffmpeg_hls.jpg?raw=true)   
+
+`ffmpeg -re -i input.mp4 -c copy -f hls-bsf:v h264_mp4toannexb output.m3u8`
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/MP4\346\240\274\345\274\217\350\257\246\350\247\243.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/MP4\346\240\274\345\274\217\350\257\246\350\247\243.md"
index f5021cd2..2778296c 100644
--- "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/MP4\346\240\274\345\274\217\350\257\246\350\247\243.md"
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/MP4\346\240\274\345\274\217\350\257\246\350\247\243.md"
@@ -6,16 +6,11 @@ MP4是一套用于音频、视频信息的压缩编码标准，由国际标准
 MP4的格式稍微比FLV复杂一些，它是通过嵌的方式来实现整个数据的携带。换句话说，它的每一段内容，都可以变成一个对象，如果需要播放的话，只要得到相应的对象即可。
 
 
-
 MP4视频文件封装格式是基于QuickTime容器格式定义的，因此参考QuickTime的格式定义对理解MP4文件格式很有帮助。MP4文件格式是一个十分开放的容器，几乎可以用来描述所有的媒体结构，MP4文件中的媒体描述与媒体数据是分开的，并且媒体数据的组织也很自由，不一定要按照时间顺序排列，甚至媒体数据可以直接引用其他文件。同时，MP4也支持流媒体。MP4目前被广泛用于封装h.264视频和AAC音频，是高清视频的代表。
 
- 
-
-  现在我们就来看看MP4文件格式到底是什么样的。
-
 **1、概述**
 
-  MP4文件中的所有数据都装在box（QuickTime中为atom）中，也就是说MP4文件由若干个box组成，每个box有类型和长度，可以将box理解为一个数据对象块。box中可以包含另一个box，这种box称为container  box。一个MP4文件首先会有且只有一个“ftyp”类型的box，作为MP4格式的标志并包含关于文件的一些信息；之后会有且只有一个“moov”类型的box（Movie Box），它是一种container  box，子box包含了媒体的metadata信息；MP4文件的媒体数据包含在“mdat”类型的box（Midia Data  Box）中，该类型的box也是container  box，可以有多个，也可以没有（当媒体数据全部引用其他文件时），媒体数据的结构由metadata进行描述。
+MP4文件中的所有数据都装在box（QuickTime中为atom）中，也就是说MP4文件由若干个box组成，每个box有类型和长度，可以将box理解为一个数据对象块。box中可以包含另一个box，这种box称为container  box。一个MP4文件首先会有且只有一个“ftyp”类型的box，作为MP4格式的标志并包含关于文件的一些信息；之后会有且只有一个“moov”类型的box（Movie Box），它是一种container  box，子box包含了媒体的metadata信息；MP4文件的媒体数据包含在“mdat”类型的box（Midia Data  Box）中，该类型的box也是container  box，可以有多个，也可以没有（当媒体数据全部引用其他文件时），媒体数据的结构由metadata进行描述。
 
 
 

From 5dc1b322ee94e976e5f422daf227bbf078961a93 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 14 Dec 2022 20:30:13 +0800
Subject: [PATCH 087/213] add notes

---
 ...\222\345\272\217\347\256\227\346\263\225.md" |  0
 README.md                                       | 17 ++++++++++++-----
 .../Android WebRTC\347\256\200\344\273\213.md"  |  0
 .../AudioTrack\347\256\200\344\273\213.md"      |  0
 .../DLNA\347\256\200\344\273\213.md"            |  0
 ...\200\201MediaCodec\343\200\201MediaMuxer.md" |  0
 .../SurfaceView\344\270\216TextureView.md"      |  0
 ...\247\350\203\275\344\274\230\345\214\226.md" |  0
 ...\243\344\270\216\347\241\254\350\247\243.md" |  0
 .../FFmpeg/1.FFmpeg\347\256\200\344\273\213.md" |  2 +-
 ...\250\345\221\275\344\273\244\350\241\214.md" |  2 +-
 .../FFmpeg/3.FFmpeg\345\210\207\347\211\207.md" |  2 +-
 12 files changed, 15 insertions(+), 8 deletions(-)
 rename "JavaKnowledge/\345\205\253\347\247\215\346\216\222\345\272\217\347\256\227\346\263\225.md" => "JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\345\205\253\347\247\215\346\216\222\345\272\217\347\256\227\346\263\225.md" (100%)
 rename "VideoDevelopment/Android WebRTC\347\256\200\344\273\213.md" => "VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/Android WebRTC\347\256\200\344\273\213.md" (100%)
 rename "VideoDevelopment/AudioTrack\347\256\200\344\273\213.md" => "VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/AudioTrack\347\256\200\344\273\213.md" (100%)
 rename "VideoDevelopment/DLNA\347\256\200\344\273\213.md" => "VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/DLNA\347\256\200\344\273\213.md" (100%)
 rename "VideoDevelopment/MediaExtractor\343\200\201MediaCodec\343\200\201MediaMuxer.md" => "VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/MediaExtractor\343\200\201MediaCodec\343\200\201MediaMuxer.md" (100%)
 rename "VideoDevelopment/SurfaceView\344\270\216TextureView.md" => "VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/SurfaceView\344\270\216TextureView.md" (100%)
 rename "VideoDevelopment/\346\222\255\346\224\276\345\231\250\346\200\247\350\203\275\344\274\230\345\214\226.md" => "VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/\346\222\255\346\224\276\345\231\250\346\200\247\350\203\275\344\274\230\345\214\226.md" (100%)
 rename "VideoDevelopment/\350\247\206\351\242\221\350\247\243\347\240\201\344\271\213\350\275\257\350\247\243\344\270\216\347\241\254\350\247\243.md" => "VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/\350\247\206\351\242\221\350\247\243\347\240\201\344\271\213\350\275\257\350\247\243\344\270\216\347\241\254\350\247\243.md" (100%)
 rename "VideoDevelopment/FFmpeg/FFmpeg\347\256\200\344\273\213.md" => "VideoDevelopment/FFmpeg/1.FFmpeg\347\256\200\344\273\213.md" (99%)
 rename "VideoDevelopment/FFmpeg/FFmpeg\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214.md" => "VideoDevelopment/FFmpeg/2.FFmpeg\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214.md" (99%)
 rename "VideoDevelopment/FFmpeg/FFmpeg\345\210\207\347\211\207.md" => "VideoDevelopment/FFmpeg/3.FFmpeg\345\210\207\347\211\207.md" (74%)

diff --git "a/JavaKnowledge/\345\205\253\347\247\215\346\216\222\345\272\217\347\256\227\346\263\225.md" "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\345\205\253\347\247\215\346\216\222\345\272\217\347\256\227\346\263\225.md"
similarity index 100%
rename from "JavaKnowledge/\345\205\253\347\247\215\346\216\222\345\272\217\347\256\227\346\263\225.md"
rename to "JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\345\205\253\347\247\215\346\216\222\345\272\217\347\256\227\346\263\225.md"
diff --git a/README.md b/README.md
index f269bd95..fdb60c8b 100644
--- a/README.md
+++ b/README.md
@@ -46,7 +46,7 @@ Android学习笔记
     - [搭建nginx+rtmp服务器][18]
     - [视频播放相关内容总结][19]
     - [视频解码之软解与硬解][20]
-    - [音视频基础知识][21]
+    - [Android音视频开发][21]
     - [Android WebRTC简介][22]
     - [DNS及HTTPDNS][23]
     - [DLNA简介][24]
@@ -70,6 +70,7 @@ Android学习笔记
         - [fMP4 vs ts][254]
         - [fMP4格式详解][255]
         - [视频封装格式][256]
+        - [M3U8][321]
     - [视频编码][257]
         - [AV1][258]
         - [H264][259]
@@ -96,6 +97,10 @@ Android学习笔记
         - [11.OpenGL ES滤镜][242]
     - [弹幕][243]
         - [Android弹幕实现][244]
+    - [FFmpeg][322]    
+        - [1.FFmpeg简介][323]
+        - [2.FFmpeg常用命令行][324]
+        - [1.FFmpeg切片][325]
 - [操作系统][263]
     - [1.操作系统简介][264]
     - [2.进程与线程][265]
@@ -366,7 +371,7 @@ Android学习笔记
 [18]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%90%AD%E5%BB%BAnginx%2Brtmp%E6%9C%8D%E5%8A%A1%E5%99%A8.md   "搭建nginx+rtmp服务器"
 [19]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E8%A7%86%E9%A2%91%E6%92%AD%E6%94%BE%E7%9B%B8%E5%85%B3%E5%86%85%E5%AE%B9%E6%80%BB%E7%BB%93.md   "视频播放相关内容总结"
 [20]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E8%A7%86%E9%A2%91%E8%A7%A3%E7%A0%81%E4%B9%8B%E8%BD%AF%E8%A7%A3%E4%B8%8E%E7%A1%AC%E8%A7%A3.md   "视频解码之软解与硬解"
-[21]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E9%9F%B3%E8%A7%86%E9%A2%91%E5%9F%BA%E7%A1%80%E7%9F%A5%E8%AF%86.md   "音视频基础知识"
+[21]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/Android%E9%9F%B3%E8%A7%86%E9%A2%91%E5%BC%80%E5%8F%91   "Android音视频开发"
 [22]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/Android%20WebRTC%E7%AE%80%E4%BB%8B.md   "Android WebRTC简介"
 [23]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/DNS%E5%8F%8AHTTPDNS.md   "DNS及HTTPDNS"
 [24]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/DLNA%E7%AE%80%E4%BB%8B.md   "DLNA简介"
@@ -432,7 +437,7 @@ Android学习笔记
 [84]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/RecyclerView%E4%B8%93%E9%A2%98.md   "RecyclerView专题"
 [85]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E5%B8%B8%E7%94%A8%E5%91%BD%E4%BB%A4%E8%A1%8C%E5%A4%A7%E5%85%A8.md   "常用命令行大全"
 [86]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E5%8D%95%E4%BE%8B%E7%9A%84%E6%9C%80%E4%BD%B3%E5%AE%9E%E7%8E%B0%E6%96%B9%E5%BC%8F.md   "单例的最佳实现方式"
-[87]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84.md   "数据结构"
+[87]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E5%92%8C%E7%AE%97%E6%B3%95/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84.md   "数据结构"
 [88]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E8%8E%B7%E5%8F%96%E4%BB%8A%E5%90%8E%E5%A4%9A%E5%B0%91%E5%A4%A9%E5%90%8E%E7%9A%84%E6%97%A5%E6%9C%9F.md   "获取今后多少天后的日期"
 [89]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E5%89%91%E6%8C%87Offer(%E4%B8%8A).md   "剑指Offer(上)"
 [90]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/剑指Offer(下).md   "剑指Offer(下)"
@@ -440,7 +445,7 @@ Android学习笔记
 [92]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E7%94%9F%E4%BA%A7%E8%80%85%E6%B6%88%E8%B4%B9%E8%80%85.md   "生产者消费者"
 [93]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E6%95%B0%E6%8D%AE%E5%8A%A0%E5%AF%86%E5%8F%8A%E8%A7%A3%E5%AF%86.md   "数据加密及解密"
 [94]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E6%AD%BB%E9%94%81.md   "死锁"
-[95]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E5%B8%B8%E8%A7%81%E7%AE%97%E6%B3%95.md   "算法"
+[95]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E5%92%8C%E7%AE%97%E6%B3%95/%E7%AE%97%E6%B3%95.md   "算法"
 [96]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E7%BD%91%E7%BB%9C%E8%AF%B7%E6%B1%82%E7%9B%B8%E5%85%B3%E5%86%85%E5%AE%B9%E6%80%BB%E7%BB%93.md   "网络请求相关内容总结"
 [97]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E7%BA%BF%E7%A8%8B%E6%B1%A0%E7%9A%84%E5%8E%9F%E7%90%86.md   "线程池的原理"
 [98]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/Java并发编程之原子性、可见性以及有序性.md  "Java并发编程之原子性、可见性以及有序性"
@@ -539,7 +544,7 @@ Android学习笔记
 [189]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E5%85%AB%E7%A7%8D%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95.md "八种排序算法"
 [190]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E7%BA%BF%E7%A8%8B%E6%B1%A0%E7%AE%80%E4%BB%8B.md "线程池简介"
 [191]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F.md "设计模式"
-[192]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E7%AE%97%E6%B3%95%E7%9A%84%E5%A4%8D%E6%9D%82%E5%BA%A6.md "算法复杂度"
+[192]: https://github.com/CharonChui/AndroidNote/tree/master/JavaKnowledge/%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E5%92%8C%E7%AE%97%E6%B3%95 "数据结构和算法"
 [193]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E5%8A%A8%E6%80%81%E4%BB%A3%E7%90%86.md "动态代理"
 [194]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/ConstraintLaayout%E7%AE%80%E4%BB%8B.md "ConstraintLaayout简介"
 [195]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/Http%E4%B8%8EHttps%E7%9A%84%E5%8C%BA%E5%88%AB.md "Http与Https的区别"
@@ -674,6 +679,8 @@ Android学习笔记
 [318]: https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/behavior/1.%E7%AE%80%E4%BB%8B.md "1.简介"
 [319]: https://github.com/CharonChui/AndroidNote/blob/master/Gradle%26Maven/Composing%20builds%E7%AE%80%E4%BB%8B.md  "Composing builds简介"
 [320]: https://github.com/CharonChui/AndroidNote/blob/master/ImageLoaderLibrary/Coil%E7%AE%80%E4%BB%8B.md "Coil简介"
+[321]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E8%A7%86%E9%A2%91%E5%B0%81%E8%A3%85%E6%A0%BC%E5%BC%8F/M3U8.md "M3U8"
+
 
 
 
diff --git "a/VideoDevelopment/Android WebRTC\347\256\200\344\273\213.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/Android WebRTC\347\256\200\344\273\213.md"
similarity index 100%
rename from "VideoDevelopment/Android WebRTC\347\256\200\344\273\213.md"
rename to "VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/Android WebRTC\347\256\200\344\273\213.md"
diff --git "a/VideoDevelopment/AudioTrack\347\256\200\344\273\213.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/AudioTrack\347\256\200\344\273\213.md"
similarity index 100%
rename from "VideoDevelopment/AudioTrack\347\256\200\344\273\213.md"
rename to "VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/AudioTrack\347\256\200\344\273\213.md"
diff --git "a/VideoDevelopment/DLNA\347\256\200\344\273\213.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/DLNA\347\256\200\344\273\213.md"
similarity index 100%
rename from "VideoDevelopment/DLNA\347\256\200\344\273\213.md"
rename to "VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/DLNA\347\256\200\344\273\213.md"
diff --git "a/VideoDevelopment/MediaExtractor\343\200\201MediaCodec\343\200\201MediaMuxer.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/MediaExtractor\343\200\201MediaCodec\343\200\201MediaMuxer.md"
similarity index 100%
rename from "VideoDevelopment/MediaExtractor\343\200\201MediaCodec\343\200\201MediaMuxer.md"
rename to "VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/MediaExtractor\343\200\201MediaCodec\343\200\201MediaMuxer.md"
diff --git "a/VideoDevelopment/SurfaceView\344\270\216TextureView.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/SurfaceView\344\270\216TextureView.md"
similarity index 100%
rename from "VideoDevelopment/SurfaceView\344\270\216TextureView.md"
rename to "VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/SurfaceView\344\270\216TextureView.md"
diff --git "a/VideoDevelopment/\346\222\255\346\224\276\345\231\250\346\200\247\350\203\275\344\274\230\345\214\226.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/\346\222\255\346\224\276\345\231\250\346\200\247\350\203\275\344\274\230\345\214\226.md"
similarity index 100%
rename from "VideoDevelopment/\346\222\255\346\224\276\345\231\250\346\200\247\350\203\275\344\274\230\345\214\226.md"
rename to "VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/\346\222\255\346\224\276\345\231\250\346\200\247\350\203\275\344\274\230\345\214\226.md"
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\350\247\243\347\240\201\344\271\213\350\275\257\350\247\243\344\270\216\347\241\254\350\247\243.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/\350\247\206\351\242\221\350\247\243\347\240\201\344\271\213\350\275\257\350\247\243\344\270\216\347\241\254\350\247\243.md"
similarity index 100%
rename from "VideoDevelopment/\350\247\206\351\242\221\350\247\243\347\240\201\344\271\213\350\275\257\350\247\243\344\270\216\347\241\254\350\247\243.md"
rename to "VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/\350\247\206\351\242\221\350\247\243\347\240\201\344\271\213\350\275\257\350\247\243\344\270\216\347\241\254\350\247\243.md"
diff --git "a/VideoDevelopment/FFmpeg/FFmpeg\347\256\200\344\273\213.md" "b/VideoDevelopment/FFmpeg/1.FFmpeg\347\256\200\344\273\213.md"
similarity index 99%
rename from "VideoDevelopment/FFmpeg/FFmpeg\347\256\200\344\273\213.md"
rename to "VideoDevelopment/FFmpeg/1.FFmpeg\347\256\200\344\273\213.md"
index e70b702b..16e0c81b 100644
--- "a/VideoDevelopment/FFmpeg/FFmpeg\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/FFmpeg/1.FFmpeg\347\256\200\344\273\213.md"
@@ -1,4 +1,4 @@
-FFmpeg简介
+1.FFmpeg简介
 ===
 
 FFmpeg是一个开源免费跨平台的视频和音频流方案，属于自由软件，采用LGPL或GPL许可证（依据你选择的组件）。它提供了录制、转换以及流化音视频的完整解决方案。它包含了非常先进的音频/视频编解码库libavcodec，为了保证高可移植性和编解码质量，libavcodec里很多codec都是从头开发的。
diff --git "a/VideoDevelopment/FFmpeg/FFmpeg\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214.md" "b/VideoDevelopment/FFmpeg/2.FFmpeg\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214.md"
similarity index 99%
rename from "VideoDevelopment/FFmpeg/FFmpeg\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214.md"
rename to "VideoDevelopment/FFmpeg/2.FFmpeg\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214.md"
index 5452d9a1..4ee12b4e 100644
--- "a/VideoDevelopment/FFmpeg/FFmpeg\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214.md"
+++ "b/VideoDevelopment/FFmpeg/2.FFmpeg\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214.md"
@@ -1,4 +1,4 @@
-FFmpeg常用命令行
+2.FFmpeg常用命令行
 ===
 ### ffmpeg
 
diff --git "a/VideoDevelopment/FFmpeg/FFmpeg\345\210\207\347\211\207.md" "b/VideoDevelopment/FFmpeg/3.FFmpeg\345\210\207\347\211\207.md"
similarity index 74%
rename from "VideoDevelopment/FFmpeg/FFmpeg\345\210\207\347\211\207.md"
rename to "VideoDevelopment/FFmpeg/3.FFmpeg\345\210\207\347\211\207.md"
index 6edec0c0..d03ed441 100644
--- "a/VideoDevelopment/FFmpeg/FFmpeg\345\210\207\347\211\207.md"
+++ "b/VideoDevelopment/FFmpeg/3.FFmpeg\345\210\207\347\211\207.md"
@@ -1,4 +1,4 @@
-FFmpeg常用命令行
+3.FFmpeg切片
 ===
 
 

From 82dee50eaa99e9538acd42e83e8b602025f89f03 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 14 Dec 2022 20:46:33 +0800
Subject: [PATCH 088/213] update README.md

---
 README.md                  |  46 +++++++++++++++++++++++--------------
 VideoDevelopment/.DS_Store | Bin 6148 -> 0 bytes
 2 files changed, 29 insertions(+), 17 deletions(-)
 delete mode 100644 VideoDevelopment/.DS_Store

diff --git a/README.md b/README.md
index fdb60c8b..890fcd12 100644
--- a/README.md
+++ b/README.md
@@ -45,12 +45,20 @@ Android学习笔记
 - [音视频开发][44]
     - [搭建nginx+rtmp服务器][18]
     - [视频播放相关内容总结][19]
-    - [视频解码之软解与硬解][20]
     - [Android音视频开发][21]
-    - [Android WebRTC简介][22]
+        - [Android WebRTC简介][22]    
+        - [DLNA简介][24]
+        - [AudioTrack简介][214]
+        - [播放器性能优化][230]
+        - [MediaExtractor、MediaCodec、MediaMuxer][245]
+        - [SurfaceView与TextureView][226]
+        - [视频解码之软解与硬解][20]
+        - [音视频同步原理][326]
+        - [音视频场景][327]
+        - [1.音视频基础知识][328]
+        - [2.系统播放器MediaPlayer][329]
+        - [11.播放器组件封装][330]
     - [DNS及HTTPDNS][23]
-    - [DLNA简介][24]
-    - [AudioTrack简介][214]
     - [流媒体协议][224]
         - [流媒体协议][246]
         - [HLS][247]
@@ -75,14 +83,11 @@ Android学习笔记
         - [AV1][258]
         - [H264][259]
         - [H265][260]
-    - [SurfaceView与TextureView][226]
     - [关键帧][227]
     - [CDN及PCDN][228]
     - [P2P技术][229]
         - [P2P][261]
         - [P2P原理_NAT穿透][262]
-    - [播放器性能优化][230]
-    - [MediaExtractor、MediaCodec、MediaMuxer][245]
     - [OpenGL][231]
         - [1.OpenGL简介][232]
         - [2.GLSurfaceView简介][233]
@@ -370,11 +375,11 @@ Android学习笔记
 [17]: https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/Netowork/Retrofit%E8%AF%A6%E8%A7%A3(%E4%B8%8B).md   "Retrofit详解(下)"
 [18]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%90%AD%E5%BB%BAnginx%2Brtmp%E6%9C%8D%E5%8A%A1%E5%99%A8.md   "搭建nginx+rtmp服务器"
 [19]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E8%A7%86%E9%A2%91%E6%92%AD%E6%94%BE%E7%9B%B8%E5%85%B3%E5%86%85%E5%AE%B9%E6%80%BB%E7%BB%93.md   "视频播放相关内容总结"
-[20]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E8%A7%86%E9%A2%91%E8%A7%A3%E7%A0%81%E4%B9%8B%E8%BD%AF%E8%A7%A3%E4%B8%8E%E7%A1%AC%E8%A7%A3.md   "视频解码之软解与硬解"
+[20]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/Android%E9%9F%B3%E8%A7%86%E9%A2%91%E5%BC%80%E5%8F%91/%E8%A7%86%E9%A2%91%E8%A7%A3%E7%A0%81%E4%B9%8B%E8%BD%AF%E8%A7%A3%E4%B8%8E%E7%A1%AC%E8%A7%A3.md   "视频解码之软解与硬解"
 [21]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/Android%E9%9F%B3%E8%A7%86%E9%A2%91%E5%BC%80%E5%8F%91   "Android音视频开发"
-[22]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/Android%20WebRTC%E7%AE%80%E4%BB%8B.md   "Android WebRTC简介"
+[22]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/Android%E9%9F%B3%E8%A7%86%E9%A2%91%E5%BC%80%E5%8F%91/Android%20WebRTC%E7%AE%80%E4%BB%8B.md   "Android WebRTC简介"
 [23]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/DNS%E5%8F%8AHTTPDNS.md   "DNS及HTTPDNS"
-[24]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/DLNA%E7%AE%80%E4%BB%8B.md   "DLNA简介"
+[24]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/Android%E9%9F%B3%E8%A7%86%E9%A2%91%E5%BC%80%E5%8F%91/DLNA%E7%AE%80%E4%BB%8B.md   "DLNA简介"
 [25]: https://github.com/CharonChui/AndroidNote/blob/master/ImageLoaderLibrary/Glide%E7%AE%80%E4%BB%8B(%E4%B8%8A).md   "Glide简介(上)"
 [26]: https://github.com/CharonChui/AndroidNote/blob/master/ImageLoaderLibrary/Glide%E7%AE%80%E4%BB%8B(%E4%B8%8B).md   "Glide简介(下)"
 [27]: https://github.com/CharonChui/AndroidNote/blob/master/ImageLoaderLibrary/%E5%9B%BE%E7%89%87%E5%8A%A0%E8%BD%BD%E5%BA%93%E6%AF%94%E8%BE%83.md   "图片加载库比较"
@@ -567,7 +572,7 @@ Android学习笔记
 [211]: https://github.com/CharonChui/AndroidNote/blob/master/RxJavaPart/6.RxJava%E8%AF%A6%E8%A7%A3%E4%B9%8B%E7%BA%BF%E7%A8%8B%E8%B0%83%E5%BA%A6%E5%8E%9F%E7%90%86(%E5%85%AD).md  "6.RxJava详解之线程调度原理(六)"
 [212]: https://github.com/CharonChui/AndroidNote/blob/master/Dagger2/9.Dagger2%E5%8E%9F%E7%90%86%E5%88%86%E6%9E%90(%E4%B9%9D).md "9.Dagger2原理分析(九)"
 [213]: https://github.com/CharonChui/AndroidNote/blob/master/Tools%26Library/%E8%B0%83%E8%AF%95%E5%B9%B3%E5%8F%B0Sonar.md "调试平台Sonar"
-[214]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/AudioTrack%E7%AE%80%E4%BB%8B.md   "AudioTrack简介"
+[214]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/Android%E9%9F%B3%E8%A7%86%E9%A2%91%E5%BC%80%E5%8F%91/AudioTrack%E7%AE%80%E4%BB%8B.md   "AudioTrack简介"
 [215]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/OOM%E9%97%AE%E9%A2%98%E5%88%86%E6%9E%90.md  "OOM问题分析"
 [216]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/ExoPlayer  "ExoPlayer"
 [217]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/ExoPlayer/1.%20ExoPlayer%E7%AE%80%E4%BB%8B.md  "1. ExoPlayer简介"
@@ -579,11 +584,11 @@ Android学习笔记
 [223]: https://github.com/CharonChui/AndroidNote/blob/master/Tools%26Library/Icon%E5%88%B6%E4%BD%9C.md "Icon制作"
 [224]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE "流媒体协议"
 [225]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/%E8%A7%86%E9%A2%91%E5%B0%81%E8%A3%85%E6%A0%BC%E5%BC%8F "视频封装格式"
-[226]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/SurfaceView%E4%B8%8ETextureView.md "SurfaceView与TextureView"
+[226]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/Android%E9%9F%B3%E8%A7%86%E9%A2%91%E5%BC%80%E5%8F%91/SurfaceView%E4%B8%8ETextureView.md "SurfaceView与TextureView"
 [227]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E5%85%B3%E9%94%AE%E5%B8%A7.md "关键帧"
 [228]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/CDN%E5%8F%8APCDN.md "CDN及PCDN"
 [229]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/P2P%E6%8A%80%E6%9C%AF "P2P"
-[230]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%92%AD%E6%94%BE%E5%99%A8%E6%80%A7%E8%83%BD%E4%BC%98%E5%8C%96.md "播放器性能优化"
+[230]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/Android%E9%9F%B3%E8%A7%86%E9%A2%91%E5%BC%80%E5%8F%91/%E6%92%AD%E6%94%BE%E5%99%A8%E6%80%A7%E8%83%BD%E4%BC%98%E5%8C%96.md "播放器性能优化"
 [231]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/OpenGL  "OpenGL"
 [232]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/1.OpenGL%E7%AE%80%E4%BB%8B.md  "1.OpenGL简介"
 [233]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/2.GLSurfaceView%E7%AE%80%E4%BB%8B.md "2.GLSurfaceView简介"
@@ -599,7 +604,7 @@ Android学习笔记
 [242]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/11.OpenGL%20ES%E6%BB%A4%E9%95%9C.md "11.OpenGL ES滤镜"
 [243]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/Danmaku "弹幕"
 [244]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/Danmaku/Android%E5%BC%B9%E5%B9%95%E5%AE%9E%E7%8E%B0.md "Android弹幕实现"
-[245]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/MediaExtractor%E3%80%81MediaCodec%E3%80%81MediaMuxer.md "MediaExtractor、MediaCodec、MediaMuxer"
+[245]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/Android%E9%9F%B3%E8%A7%86%E9%A2%91%E5%BC%80%E5%8F%91/MediaExtractor%E3%80%81MediaCodec%E3%80%81MediaMuxer.md "MediaExtractor、MediaCodec、MediaMuxer"
 [246]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE.md  "流媒体协议"
 [247]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE/HLS.md "HLS"
 [248]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE/DASH.md "DASH"
@@ -680,9 +685,16 @@ Android学习笔记
 [319]: https://github.com/CharonChui/AndroidNote/blob/master/Gradle%26Maven/Composing%20builds%E7%AE%80%E4%BB%8B.md  "Composing builds简介"
 [320]: https://github.com/CharonChui/AndroidNote/blob/master/ImageLoaderLibrary/Coil%E7%AE%80%E4%BB%8B.md "Coil简介"
 [321]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E8%A7%86%E9%A2%91%E5%B0%81%E8%A3%85%E6%A0%BC%E5%BC%8F/M3U8.md "M3U8"
-
-
-
+[322]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/FFmpeg "FFmpeg"
+[323]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/FFmpeg/1.FFmpeg%E7%AE%80%E4%BB%8B.md "1.FFmpeg简介"
+[324]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/FFmpeg/2.FFmpeg%E5%B8%B8%E7%94%A8%E5%91%BD%E4%BB%A4%E8%A1%8C.md "2.FFmpeg常用命令行"
+[325]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/FFmpeg/3.FFmpeg%E5%88%87%E7%89%87.md "3.FFmpeg切片"
+[326]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/Android%E9%9F%B3%E8%A7%86%E9%A2%91%E5%BC%80%E5%8F%91/%E9%9F%B3%E8%A7%86%E9%A2%91%E5%90%8C%E6%AD%A5%E5%8E%9F%E7%90%86.md "音视频同步原理"
+[327]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/Android%E9%9F%B3%E8%A7%86%E9%A2%91%E5%BC%80%E5%8F%91/%E9%9F%B3%E8%A7%86%E9%A2%91%E5%9C%BA%E6%99%AF.md "音视频场景"
+[328]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/Android%E9%9F%B3%E8%A7%86%E9%A2%91%E5%BC%80%E5%8F%91/1.%E9%9F%B3%E8%A7%86%E9%A2%91%E5%9F%BA%E7%A1%80%E7%9F%A5%E8%AF%86.md "1.音视频基础知识"
+[329]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/Android%E9%9F%B3%E8%A7%86%E9%A2%91%E5%BC%80%E5%8F%91/2.%E7%B3%BB%E7%BB%9F%E6%92%AD%E6%94%BE%E5%99%A8MediaPlayer.md "2.系统播放器MediaPlayer"
+[330]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/Android%E9%9F%B3%E8%A7%86%E9%A2%91%E5%BC%80%E5%8F%91/11.%E6%92%AD%E6%94%BE%E7%BB%84%E4%BB%B6%E5%B0%81%E8%A3%85.md "11.播放器组件封装"
+      
 
 
 Developed By
diff --git a/VideoDevelopment/.DS_Store b/VideoDevelopment/.DS_Store
deleted file mode 100644
index 63369ec8e7e79eeeaf351066160344353fa5fe36..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6148
zcmeHKOHRWu5S@X7BC+X`rLWK%m@06Atk|Ja6c$MxA%VosH{k$WgEO(_jb~VxMq*PT
zRLxZO8_&<llWJ#(h}X~C715H28Vo@eWk$q2>pHREGa#2557ZC+s=H6)G*jq5n&jEf
z=?1@%CYpc#%0H&I-3)1iyymlezkPlCxcXUROxs^$rpG;=s(oI%r`?ctJ!*qn7iYj3
za0Z+KXW(EA*uBzR9IT=jat54%V_`tfhkzj%4YOi7Ixv+M0Jwm;2z2QsBqta~!>kAo
zgf$hYscbC<YdY+~;-X<z)O2ENKG=5tZeF<Tj{2d56Gug#odIW{X5dtpOS%8A@t2ux
z^6L~|IRnnXkukuFwrkgTDZ5+uUQh1YfN_T*B5_$12=wYB01G)sE{jwBL3G4L!>lM(
T#9q>Y{vl8Z@yQwZ0|veT^o=pd


From 43ba39dbadad6b0f473f9db99257749f2a3e36cb Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Fri, 16 Dec 2022 18:26:07 +0800
Subject: [PATCH 089/213] update

---
 ...41\345\274\217\350\257\246\350\247\243.md" |  17 +++
 ...76\350\256\241\346\250\241\345\274\217.md" | 120 +++++++++++++++---
 ...&\347\261\273&\346\216\245\345\217\243.md" |  40 ++++++
 ...05\350\201\224\345\207\275\346\225\260.md" |  10 ++
 ...2\344\270\276&\345\247\224\346\211\230.md" |  19 +++
 ...5\345\260\204&\346\211\251\345\261\225.md" |   2 +
 6 files changed, 193 insertions(+), 15 deletions(-)

diff --git "a/AdavancedPart/Android\345\220\257\345\212\250\346\250\241\345\274\217\350\257\246\350\247\243.md" "b/AdavancedPart/Android\345\220\257\345\212\250\346\250\241\345\274\217\350\257\246\350\247\243.md"
index 25d0e1be..6c5ef656 100644
--- "a/AdavancedPart/Android\345\220\257\345\212\250\346\250\241\345\274\217\350\257\246\350\247\243.md"
+++ "b/AdavancedPart/Android\345\220\257\345\212\250\346\250\241\345\274\217\350\257\246\350\247\243.md"
@@ -29,6 +29,7 @@ Android启动模式详解
     - 如果设置了`singleTask`启动模式的`Activity`不是在新的任务中启动时，它会在已有的任务中查看是否已经存在相应的`Activity`实例，如果存在，就会把位于这个`Activity`实例上面的`Activity`全部结束掉，
 	即最终这个Activity实例会位于任务的堆栈顶端中。以`A`启动`B`来说,当`A`和`B`的`taskAffinity`不同时：第一次创建`B`的实例时，会启动新的`task`，然后将`B`添加到新建的`task`中；否则，将`B`所在`task`中位于`B`之上的全部`Activity`都删除，然后跳转到`B`中。
 - `singleInstance`
+
 顾名思义，是单一实例的意思，即任意时刻只允许存在唯一的`Activity`实例，而且该`Activity`所在的`task`不能容纳除该`Activity`之外的其他`Activity`实例！               
 它与`singleTask`有相同之处，也有不同之处。          
 相同之处：任意时刻，最多只允许存在一个实例。            
@@ -38,6 +39,22 @@ Android启动模式详解
     - 当跳转到`singleTask`类型的`Activity`，并且该`Activity`实例已经存在时，会删除该`Activity`所在`task`中位于该`Activity`之上的全部`Activity`实例；而跳转到`singleInstance`类型的`Activity`，并且该`Activity`已经存在时，
 	不需要删除其他`Activity`，因为它所在的`task`只有该`Activity`唯一一个`Activity`实例。
 
+
+假设我们的程序中有一个Activity是允许其他程序调用的，如果想实现其他程序和我们的程序可以共享这个Activity的实例，应该如何实现呢？使用前面3种启动模式肯定是做不到的，因为每个应用程序都会有自己的返回栈，同一个Activity在不同的返回栈中入栈时必然创建了新的实例。而使用singleInstance模式就可以解决这个问题，在这种模式下，会有一个单独的返回栈来管理这个Activity，不管是哪个应用程序来访问这个Activity，都共用同一个返回栈，也就解决了共享Activity实例的问题。
+
+假设现在有FirstActivity、SecondActivity、ThirdActivity三个Activity， SecondActivity的启动模式是SingleInstance。 
+现在FirstActivity 启动SecondActivity，SecondActivity再启动ThirdActivity。 
+
+然后我们按下Back键进行返回，你会发现ThirdActivity竟然直接返回到了FirstActivity，再按下Back键又会返回到SecondActivity，再按下Back键才会退出程序，这是为什么呢？其实原理很简单，由于FirstActivity和ThirdActivity是存放在同一个返回栈里的，当在ThirdActivity的界面按下Back键时，ThirdActivity会从返回栈中出栈，那么FirstActivity就成为了栈顶Activity显示在界面上，因此也就出现了从ThirdActivity直接返回到FirstActivity的情况。然后在FirstActivity界面再次按下Back键，这时当前的返回栈已经空了，于是就显示了另一个返回栈的栈顶Activity，即SecondActivity。最后再次按下Back键，这时所有返回栈都已经空了，也就自然退出了程序。
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/activity_launch_mode_singleinstance.png?raw=true)     
+
+
+
+
+
+
     
 ---
 
diff --git "a/JavaKnowledge/\350\256\276\350\256\241\346\250\241\345\274\217.md" "b/JavaKnowledge/\350\256\276\350\256\241\346\250\241\345\274\217.md"
index 4b2d8e72..a499894c 100644
--- "a/JavaKnowledge/\350\256\276\350\256\241\346\250\241\345\274\217.md"
+++ "b/JavaKnowledge/\350\256\276\350\256\241\346\250\241\345\274\217.md"
@@ -22,6 +22,7 @@
 - 开闭原则`(Open Close Principle)`             
     开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是:
     为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。
+    当系统升级时，如果为了增强系统功能而需要进行大量的代码修改，则说明这个系统的设计是失败的，是违反开闭原则的。反之，对系统的扩展应该只需添加新的软件模块，系统模式一旦确立就不再修改现有代码，这才是符合开闭原则的优雅设计。其实开闭原则在各种设计模式中都有体现，对抽象的大量运用奠定了系统可复用性、可扩展性的基础，也增加了系统的稳定性。
 
 - 里氏代换原则`（Liskov Substitution Principle）`        
     里氏代换原则面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 `LSP`是继承复用的基石，只有当衍生类可以替换掉基类，
@@ -29,23 +30,35 @@
     里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。
 
 - 依赖倒转原则`（Dependence Inversion Principle）`      
-    这个是开闭原则的基础，具体内容：真对接口编程，依赖于抽象而不依赖于具体。
+    我们知道，面向对象中的依赖是类与类之间的一种关系，如H（高层）类要调用L（底层）类的方法，我们就说H类依赖L类。依赖倒置原则(Dependency InversionPrinciple)指高层模块不依赖底层模块，也就是说高层模块只依赖上层抽象，而不直接依赖具体的底层实现，从而达到降低耦合的目的。如上面提到的H与L的依赖关系必然会导致它们的强耦合，也许L任何细枝末节的变动都可能影响H，这是一种非常死板的设计。而依赖倒置的做法则是反其道而行，我们可以创建L的上层抽象A，然后H即可通过抽象A间接地访问L，那么高层H不再依赖底层L，而只依赖上层抽象A。这样一来系统会变得更加松散，这也印证了我们在“里氏替换原则”中所提到的“面向接口编程”，以达到替换底层实现的目的。
+    举个例子，公司总经理制订了下一年度的目标与计划，为了提高办公效率，总经理决定年底要上线一套全新的办公自动化软件。那么总经理作为发起方该如何实施这个计划呢？直接发动基层程序员并调用他们的研发方法吗？我想世界上没有以这种方式管理公司的领导吧。公司高层一定会发动IT部门的上层抽象去执行，调用IT部门经理的work方法并传入目标即可，至于这个work方法的具体实现者也许是架构师甲，也可能是程序员乙，总经理也许根本不认识他们，这就达到了公司高层与底层员工实现解耦的目的。这就是将“高层依赖底层”倒置为“底层依赖高层”的好处。
+
+- 接口隔离原则`（Interface Segregation Principle）`      
+    接口隔离原则(Interface Segregation Principle)指的是对高层接口的独立、分化，客户端对类的依赖基于最小接口，而不依赖不需要的接口。简单来说，就是切勿将接口定义成全能型的，否则实现类就必须神通广大，这样便丧失了子类实现的灵活性，降低了系统的向下兼容性。反之，定义接口的时候应该尽量拆分成较小的粒度，往往一个接口只对应一个职能。
 
-- 接口隔离原则`（Interface Segregation Principle）`        
     这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，
     从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。
 
-- 迪米特法则（最少知道原则）`（Demeter Principle）`        
-    为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。
+
+- 迪米特法则（最少知识原则）`（Demeter Principle）`        
+    迪米特法则(law of Demeter)也被称为最少知识原则，它提出一个模块对其他模块应该知之甚少，或者说模块之间应该彼此保持陌生，甚至意识不到对方的存在，以此最小化、简单化模块间的通信，并达到松耦合的目的。反之，模块之间若存在过多的关联，那么一个很小的变动则可能会引发蝴蝶效应般的连锁反应，最终会波及大范围的系统变动。我们说，缺乏良好封装性的系统模块是违反迪米特法则的，牵一发动全身的设计使系统的扩展与维护变得举步维艰。举个例子，我们买了一台游戏机，主机内部集成了非常复杂的电路及电子元件，这些对外部来说完全是不可见的，就像一个黑盒子。虽然我们看不到黑盒子的内部构造与工作原理，但它向外部开放了控制接口，让我们可以接上手柄对其进行访问，这便构成了一个完美的封装。
+    之前我们学过的“门面模式”就是极好的范例。例如我们去某单位办理一项业务，来到业务大厅一脸茫然，各种填表、盖章等复杂的办理流程让人一头雾水，有可能来回折腾几个小时。假若有一个提供快速通道服务的“门面”办理窗口，那么我们只需简单地把材料递交过去就可以了，“办理人“与“门面”保持最简单的通信，对于门面里面发生的事情，办理人则知之甚少，更没有必要去亲力亲为。要设计出符合迪米特法则的软件，切勿跨越红线，干涉他人内务。系统模块一定要最大程度地隐藏内部逻辑，大门一定要紧锁，防止陌生人随意访问，而对外只适可而止地暴露最简单的接口，让模块间的通信趋向“简单化”“傻瓜化”。
+
 
 - 合成复用原则`（Composite Reuse Principle）`          
     原则是尽量使用合成/聚合的方式，而不是使用继承。
 
+- 单一职责原则(Single Responsibility Principle)    
+    我们知道，一套功能完备的软件系统可能是非常复杂的。既然要利用好面向对象的思想，那么对一个大系统的拆分、模块化是不可或缺的软件设计步骤。面向对象以“类”来划分模块边界，再以“方法”来分隔其功能。我们可以将某业务功能划归到一个类中，也可以拆分为几个类分别实现，但是不管对其负责的业务范围大小做怎样的权衡与调整，这个类的角色职责应该是单一的，或者其方法所完成的功能也应该是单一的。总之，不是自己分内之事绝不该负责，这就是单一职责原则(SingleResponsibility Principle)。
+    以最典型的“责任链模式”为例，其环环相扣的每个节点都“各扫门前雪”，这种清晰的职责范围划分就是单一职责原则的最佳实践。符合单一职责原则的设计能使类具备“高内聚性”，让单个模块变得“简单”“易懂”，如此才能增强代码的可读性与可复用性，并提高系统的易维护性与易测试性。
 
 
 1.工厂方法模式`(Factory Method)`
 ---
 
+制造业是一个国家工业经济发展的重要支柱，而工厂则是其根基所在。程序设计中的工厂类往往是对对象构造、实例化、初始化过程的封装，而工厂方法(Factory Method)则可以升华为一种设计模式，它对工厂制造方法进行接口规范化，以允许子类工厂决定具体制造哪类产品的实例，最终降低系统耦合，使系统的可维护性、可扩展性等得到提升。
+工厂内部封装的生产逻辑对外部来说像一个黑盒子，外部不需要关心工厂内部细节，外部类只管调用即可。
+
 工厂方法模式分为三种:      
 
 - 普通工厂模式:就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。
@@ -134,7 +147,12 @@
 ---
 
 
-工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。因为抽象工厂不太好理解，我们先看看图，然后就和代码，就比较容易理解。
+工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。
+
+抽象工厂模式(Abstract Factory)是对工厂的抽象化，而不只是制造方法。我们知道，为了满足不同用户对产品的多样化需求，工厂不会只局限于生产一类产品，但是系统如果按工厂方法那样为每种产品都增加一个新工厂又会造成工厂泛滥。所以，为了调和这种矛盾，抽象工厂模式提供了另一种思路，将各种产品分门别类，基于此来规划各种工厂的制造接口，最终确立产品制造的顶级规范，使其与具体产品彻底脱钩。抽象工厂是建立在制造复杂产品体系需求基础之上的一种设计模式，在某种意义上，我们可以将抽象工厂模式理解为工厂方法模式的高度集群化升级版。
+针对这种情况，我们就需要进行产业规划与整合，对现有工厂进行重构。例如，我们可以基于产品品牌与系列进行生产线规划，按品牌划分A工厂与B工厂。具体以汽车工厂举例，A品牌汽车有轿车、越野车、跑车3个系列的产品，同样地，B品牌汽车也包括以上3个系列的产品，如此便形成了两个产品族，分别由A工厂和B工厂负责生产，每个工厂都有3条生产线，分别生产这3个系列的汽车，如图5-1所示。
+
+
 
 
 还是用上面的例子，只是在工厂类这里需要改一下，提供两个不同的工厂类，他们要实现同一个接口:    
@@ -235,7 +253,8 @@ public class SingleTon {
 }
 ```
 
-似乎解决了之前提到的问题，将`synchronized`关键字加在了内部，也就是说当调用的时候是不需要加锁的，只有在`instance`为`null`，并创建对象的时候才需要加锁，性能有一定的提升。         但是，这样的情况，还是有可能有问题的，看下面的情况：在`Java`指令中创建对象和赋值操作是分开进行的，也就是说`instance = new Singleton();`语句是分两步执行的。但是JVM并不保证这两个操作的先后顺序，也就是说有可能`JVM`会为新`的Singleton`实例分配空间，然后直接赋值给`instance`成员，然后再去初始化这个`Singleton`实例。这样就可能出错了。     
+似乎解决了之前提到的问题，将`synchronized`关键字加在了内部，也就是说当调用的时候是不需要加锁的，只有在`instance`为`null`，并创建对象的时候才需要加锁，性能有一定的提升。         
+但是，这样的情况，还是有可能有问题的，看下面的情况：在`Java`指令中创建对象和赋值操作是分开进行的，也就是说`instance = new Singleton();`语句是分两步执行的。但是JVM并不保证这两个操作的先后顺序，也就是说有可能`JVM`会为新`的Singleton`实例分配空间，然后直接赋值给`instance`成员，然后再去初始化这个`Singleton`实例。这样就可能出错了。     
 
 我们以`A`、`B`两个线程为例:      
 
@@ -275,8 +294,11 @@ public class SingleTon {
 ---
 
 
+建造者模式(Builder)所构建的对象一定是庞大而复杂的，并且一定是按照既定的制造工序将组件组装起来的，例如计算机、汽车、建筑物等。我们通常将负责构建这些大型对象的工程师称为建造者。建造者模式又称为生成器模式，主要用于对复杂对象的构建、初始化，它可以将多个简单的组件对象按顺序一步步组装起来，最终构建成一个复杂的成品对象。与工厂系列模式不同的是，建造者模式的主要目的在于把烦琐的构建过程从不同对象中抽离出来，使其脱离并独立于产品类与工厂类，最终实现用同一套标准的制造工序能够产出不同的产品。
+
 工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性，其实建造者模式就是前面抽象工厂模式和最后的`Test`测试类结合起来得到的。         
 
+
 还是前面的例子，一个`ISender`接口，两个实现类`MailSender`和`SmsSender`。最后，建造者类如下:    
 ```java
 public class SenderBuilder {
@@ -306,6 +328,15 @@ builder.produceMailSender(10);
 5.原型模式`(Prototype)`
 ---
 
+在制造业中通常是指大批量生产开始之前研发出的概念模型，并基于各种参数指标对其进行检验，如果达到了质量要求，即可参照这个原型进行批量生产。原型模式达到以原型实例创建副本实例的目的即可，并不需要知道其原始类。
+也就是说，原型模式可以用对象创建对象，而不是用类创建对象，以此达到效率的提升。
+
+构造一个对象的过程是耗时耗力的。想必大家一定有过打印和复印的经历，为了节省成本，我们通常会用打印机把电子文档打印到A4纸上（原型实例化过程），再用复印机把这份纸质文稿复制多份（原型拷贝过程），这样既实惠又高效。
+那么，对于第一份打印出来的原文稿，我们可以称之为“原型文件”，而对于复印过程，我们则可以称之为“原型拷贝”
+
+想必大家已经明白了类的实例化与克隆之间的区别，二者都是在造对象，但方法绝对是不同的。
+***原型模式的目的是从原型实例克隆出新的实例，对于那些有非常复杂的初始化过程的对象或者是需要耗费大量资源的情况，原型模式是更好的选择***
+
 该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。本小结会通过对象的复制，进行讲解。在`Java`中，复制对象是通过`clone()`实现的，先创建一个原型类:      
 
 ```java
@@ -319,6 +350,9 @@ public class Prototype implements Cloneable {
 
 很简单，一个原型类，只需要实现`Cloneable`接口，重写`clone()`方法，此处`clone()`方法可以改成任意的名称，因为`Cloneable`接口是个空接口，你可以任意定义实现类的方法名，如`cloneA`或者`cloneB`，因为此处的重点是`super.clone()`这句话，`super.clone()`调用的是`Object`的`clone()`方法，而在`Object`类中，`clone()`是`native`的。
 
+我们都知道，Java中的变量分为原始类型和引用类型，所谓浅拷贝是指只复制原始类型的值，比如横坐标x与纵坐标y这种以原始类型int定义的值，它们会被复制到新克隆出的对象中。
+而引用类型同样会被拷贝，但是请注意这个操作只是拷贝了地址引用（指针），也就是说副本与原型中的对象是同一个，因为两个同样的地址实际指向的内存对象是同一个对象。需要注意的是，克隆方法中调用父类Object的clone方法进行的是浅拷贝，所以此处的bullet并没有被真正克隆。
+
 在这儿，将结合对象的浅复制和深复制来说一下，首先需要了解对象深、浅复制的概念:    
 
 - 浅复制:将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的。
@@ -375,11 +409,15 @@ class SerializableObject implements Serializable {
 
 实现深复制，需要采用流的形式读入当前对象的二进制输入，再写出二进制数据对应的对象。
 
+从类到对象叫作“创建”，而由本体对象至副本对象则叫作“克隆”，当需要创建多个类似的复杂对象时，我们就可以考虑用原型模式。究其本质，克隆操作时Java虚拟机会进行内存操作，直接拷贝原型对象数据流生成新的副本对象，绝不会拖泥带水地触发一些多余的复杂操作（如类加载、实例化、初始化等），所以其效率远远高于“new”关键字所触发的实例化操作。看尽世间烦扰，拨开云雾见青天，有时候“简单粗暴”也是一种去繁从简、不绕弯路的解决方案。
+
 
 适配器模式`(Adapter)`
 ---
 
 适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。
+适配器模式(Adapter)通常也被称为转换器，顾名思义，它一定是进行适应与匹配工作的物件。当一个对象或类的接口不能匹配用户所期待的接口时，适配器就充当中间转换的角色，以达到兼容用户接口的目的，同时适配器也实现了客户端与接口的解耦，提高了组件的可复用性。
+
 
 主要分为三类：     
 
@@ -513,10 +551,12 @@ class SerializableObject implements Serializable {
 - 接口的适配器模式:当不希望实现一个接口中所有的方法时，可以创建一个抽象类`Adapter`，实现所有方法，我们写别的类的时候，继承抽象类即可。
 
 
-装饰模式`(Decorator)`
+装饰器模式`(Decorator)`
 ---
 
 装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。     
+装饰器模式(Decorator)能够在运行时动态地为原始对象增加一些额外的功能，使其变得更加强大。从某种程度上讲，装饰器非常类似于“继承”，它们都是为了增强原始对象的功能，区别在于方式的不同，后者是在编译时(compile-time)静态地通过对原始类的继承完成，而前者则是在程序运行时(run-time)通过对原始对象动态地“包装”完成，是对类实例（对象）“装饰”的结果。
+
 
 `Source`类是被装饰类，`Decorator`类是一个装饰类，可以为`Source`类动态的添加一些功能，代码如下:    
 
@@ -569,12 +609,15 @@ after decorator!
 代理模式`(Proxy)`
 ---
 
+代理模式(Proxy)，顾名思义，有代表打理的意思。某些情况下，当客户端不能或不适合直接访问目标业务对象时，业务对象可以通过代理把自己的业务托管起来，使客户端间接地通过代理进行业务访问。如此不但能方便用户使用，还能对客户端的访问进行一定的控制。简单来说，就是代理方以业务对象的名义，代理了它的业务。
+代理模式不仅能增强原业务功能，更重要的是还能对其进行业务管控。对用户来讲，隐藏于代理中的实际业务被透明化了，而暴露出来的是代理业务，以此避免客户端直接进行业务访问所带来的安全隐患，从而保证系统业务的可控性、安全性。
+
 代理模式就是多一个代理类出来，替原对象进行一些操作，比如我们在租房子的时候回去找中介，为什么呢？因为你对该地区房屋的信息掌握的不够全面，希望找一个更熟悉的人去帮你做，此处的代理就是这个意思。再如我们有的时候打官司，我们需要请律师，因为律师在法律方面有专长，可以替我们进行操作，表达我们的想法。也就是说把专业事情交给专业的人来做。    
 
 代理按照代理的创建时期，可以分为两种:     
 
 - 静态代理:由程序员创建代理类或特定工具自动生成源代码再对其编译。在程序运行前代理类的`.class`文件就已经存在了。   
-- 动态代理:在程序运行时运用反射机制动态创建而成。     
+- 动态代理:在程序运行时运用反射机制动态创建而成。也就是说我们不需要专门针对某个接口去编写代码实现一个代理类，而是在接口运行时动态生成。    
 
 静态代理是在编译时就将接口、实现类、代理类一股脑儿全部手动完成，但如果我们需要很多的代理，每一个都这么手动的去创建实属浪费时间，而且会有大量的重复代码，此时我们就可以采用动态代理，动态代理可以在程序运行期间根据需要动态的创建代理类及其实例，来完成具体的功能，主要用的是`JAVA`的反射机制。
 
@@ -679,11 +722,14 @@ public static void main(String[] args) {
 
 纵观静态代理与动态代理，它们都能实现相同的功能，而我们看从静态代理到动态代理的这个过程，我们会发现其实动态代理只是对类做了进一步抽象和封装，使其复用性和易用性得到进一步提升而这不仅仅符合了面向对象的设计理念，其中还有AOP的身影，这也提供给我们对类抽象的一种参考。关于动态代理与AOP的关系，个人觉得AOP是一种思想，而动态代理是一种AOP思想的实现！
 
-外观模式`(Facade)`
+外观(门面)模式`(Facade)`
 ---
 
 
-外观模式是为了解决类与类之家的依赖关系的，像`spring`一样，可以将类和类之间的关系配置到配置文件中，而外观模式就是将他们的关系放在一个`Facade`类中，降低了类类之间的耦合度，该模式中没有涉及到接口。     
+外观模式是为了解决类与类之家的依赖关系的，像`spring`一样，可以将类和类之间的关系配置到配置文件中，而外观模式就是将他们的关系放在一个`Facade`类中，降低了类类之间的耦合度，该模式中没有涉及到接口。   它可能是最简单的结构型设计模式，它能将多个不同的子系统接口封装起来，并对外提供统一的高层接口，使复杂的子系统变得更易使用。 利用门面模式，我们可以把多个子系统“关”在门里面隐藏起来，成为一个整合在一起的大系统，来自外部的访问只需通过这道“门面”（接口）来进行，而不必再关心门面背后隐藏的子系统及其如何运转。总之，无论门面内部如何错综复杂，从门面外部看来总是一目了然，使用起来也很简单。
+
+为了更形象地理解门面模式，我们先来看一个例子。早期的相机使用起来是非常麻烦的，拍照前总是要根据场景情况进行一系列复杂的操作，如对焦、调节闪光灯、调光圈等，非专业人士面对这么一大堆的操作按钮根本无从下手，拍出来的照片质量也不高。随着科技的进步，出现了一种相机，叫作“傻瓜相机”，以形容其使用起来的方便性。用户再也不必学习那些复杂的参数调节了，只要按下快门键就可完成所有操作。
+
 
 下面以计算机启动过程为例:   
 ```java
@@ -773,8 +819,7 @@ computer closed!
 桥接模式`(Bridge)`
 ---
 
-
-桥接模式就是把事物和其具体实现分开，使他们可以各自独立的变化。       
+桥接模式(Bridge)能将抽象与实现分离，使二者可以各自单独变化而不受对方约束，使用时再将它们组合起来，就像架设桥梁一样连接它们的功能，如此降低了抽象与实现这两个可变维度的耦合度，以保证系统的可扩展性。       
 
 桥接的用意是：将抽象化与实现化解耦，使得二者可以独立变化，像我们常用的`JDBC`桥`DriverManager`一样，`JDBC`进行连接数据库的时候，在各个数据库之间进行切换，基本不需要动太多的代码，甚至丝毫不用动，原因就是`JDBC`提供统一接口，每个数据库提供各自的实现，用一个叫做数据库驱动的程序来桥接就行了。        
 
@@ -850,6 +895,8 @@ this is the second sub!
 组合模式`(Composite)`
 ---
 
+组合模式(Composite)是针对由多个节点对象（部分）组成的树形结构的对象（整体）而发展出的一种结构型设计模式，它能够使客户端在操作整体对象或者其下的每个节点对象时做出统一的响应，保证树形结构对象使用方法的一致性，使客户端不必关注对象的整体或部分，最终达到对象复杂的层次结构与客户端解耦的目的。
+
 组合模式有时又叫部分-整体模式在处理类似树形结构的问题时比较方便。   
 
 ```java
@@ -1044,9 +1091,21 @@ public class StrategyTest {
 ```
 策略模式的决定权在用户，系统本身提供不同算法的实现，新增或者删除算法，对各种算法做封装。因此，策略模式多用在算法决策系统中，外部用户只需要决定用哪个算法即可
 
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/design_mode_celue.png?raw=true)     
+
+相信大家对上图中的计算机、USB接口还有各种设备之间的关系以及使用方法都非常熟悉了，这些模块组成的系统正是策略模式的最佳范例。策略接口就是图中的USB接口。
+
+我们通过对计算机USB接口的标准化，使计算机系统拥有了无限扩展外设的能力，需要什么功能只需要购买相关的USB设备。可见在策略模式中，USB接口起到了至关重要的解耦作用。如果没有USB接口的存在，我们就不得不将外设直接“焊接”在主机上，致使设备与主机高度耦合，系统将彻底丧失对外设的替换与扩展能力。
+
+变化是世界的常态，唯一不变的就是变化本身。拥有顺势而为、随机应变的能力才能立于不败之地。策略模式的运用能让系统的应变能力得到提升，适应随时变化的需求。接口的巧妙运用让一系列的策略可以脱离系统而单独存在，使系统拥有更灵活、更强大的“可插拔”扩展功能。
+
+
+
 模板方法模式`(Template Method)`
 ---
 
+模板是对多种事物的结构、形式、行为的模式化总结，而模板方法模式(Template Method)则是对一系列类行为（方法）的模式化。我们将总结出来的行为规律固化在基类中，对具体的行为实现则进行抽象化并交给子类去完成，如此便实现了子类对基类模板的套用。
+
 一个抽象类中，有一个主方法，再定义1...n个方法，可以是抽象的，也可以是实际的方法，定义一个类，继承该抽象类，重写抽象方法，通过调用抽象类，实现对子类的调用，先看个关系图:   
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/template.jpg?raw=true)   
@@ -1097,6 +1156,8 @@ public static void main(String[] args) {
 观察者模式`(Observer)`
 ---
 
+观察者模式(Observer)可以针对被观察对象与观察者对象之间一对多的依赖关系建立起一种行为自动触发机制，当被观察对象状态发生变化时主动对外发起广播，以通知所有观察者做出响应。
+
 观察者模式很好理解，类似于邮件订阅和`RSS`订阅，当我们浏览一些博客或`wiki`时，经常会看到`RSS`图标，就这的意思是，当你订阅了该文章，如果后续有更新，会及时通知你。简单的说就是当一个对象变化时，其它依赖该对象的对象都会收到通知，并且随着变化！对象之间是一种一对多的关系。
 
 在`Android`中我们常用的`Button.setOnClickListener()`其实就是用的观察者模式。大名鼎鼎的`RxJava`也是基于这种模式。  
@@ -1193,6 +1254,8 @@ observer2 has received!
 迭代器模式`(Iterator)`
 ---
 
+迭代，在程序中特指对某集合中各元素逐个取用的行为。迭代器模式(Iterator)提供了一种机制来按顺序访问集合中的各元素，而不需要知道集合内部的构造。换句话讲，迭代器满足了对集合迭代的需求，并向外部提供了一种统一的迭代方式，而不必暴露集合的内部数据结构。
+
 迭代器模式就是顺序访问聚集中的对象，一般来说，集合中非常常见，如果对集合类比较熟悉的话，理解本模式会十分轻松。这句话包含两层意思：一是需要遍历的对象，即聚集对象，二是迭代器对象，用于对聚集对象进行遍历访问。
 
 `MyCollection`中定义了集合的一些操作，`MyIterator`中定义了一系列迭代操作，且持有`Collection`实例，我们来看看实现代码:   
@@ -1298,9 +1361,15 @@ public static void main(String[] args) {
 A B C D E
 ```
 
+foreach是Java5中引入的一种for的语法增强。如果我们对class文件进行反编译就会发现，对Collection接口的各种实现类来说，foreach本质上还是通过获取迭代器(Iterator)来遍历的。
+
+对于任何类型的集合，要防止内部机制不被暴露或破坏，以及确保用户对每个元素有足够的访问权限，迭代器模式起到了至关重要的作用。迭代器巧妙地利用了内部类的形式与集合类分离，然则“藕断丝连”，迭代器依然对其内部的元素保有访问权限，如此便促成了集合的完美封装，在此基础上还提供给用户一套标准的迭代器接口，使各种繁杂的遍历方式得以统一。迭代器模式的应用，能在内部事务不受干涉的前提下，保持一定的对外部开放，让我们“鱼与熊掌兼得”。
+
 责任链模式`(Chain of Responsibility)`
 ---
 
+责任链是由很多责任节点串联起来的一条任务链条，其中每一个责任节点都是一个业务处理环节。责任链模式(Chain ofResponsibility)允许业务请求者将责任链视为一个整体并对其发起请求，而不必关心链条内部具体的业务逻辑与流程走向，也就是说，请求者不必关心具体是哪个节点起了作用，总之业务最终能得到相应的处理。在软件系统中，当一个业务需要经历一系列业务对象去处理时，我们可以把这些业务对象串联起来成为一条业务责任链，请求者可以直接通过访问业务责任链来完成业务的处理，最终实现请求者与响应者的解耦。
+
 有多个对象，每个对象持有对下一个对象的引用，这样就会形成一条链，请求在这条链上传递，直到某一对象决定处理该请求。但是发出者并不清楚到底最终那个对象会处理该请求，所以，责任链模式可以实现，在隐瞒客户端的情况下，对系统进行动态的调整。先看看关系图：
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/zerenlian.jpg?raw=true)  
@@ -1425,6 +1494,7 @@ public static void main(String[] args) {
 备忘录模式`(Memento)`
 ---
 
+备忘录用来记录曾经发生过的事情，使回溯历史变得切实可行。备忘录模式(Memento)则可以在不破坏元对象封装性的前提下捕获其在某些时刻的内部状态，并像历史快照一样将它们保留在元对象之外，以备恢复之用。
 
 主要目的是保存一个对象的某个状态，以便在适当的时候恢复对象，个人觉得叫备份模式更形象些，通俗的讲下：假设有原始类A，A中有各种属性，A可以决定需要备份的属性，备忘录类B是用来存储A的一些内部状态，类C呢，就是一个用来存储备忘录的，且只能存储，不能修改等操作。做个图来分析一下：
 
@@ -1520,6 +1590,8 @@ public static void main(String[] args) {
 状态模式`(State)`
 ---
 
+状态指事物基于所处的状况、形态表现出的不同的行为特性。状态模式(State)构架出一套完备的事物内部状态转换机制，并将内部状态包裹起来且对外部不可见，使其行为能随其状态的改变而改变，同时简化了事物的复杂的状态变化逻辑。
+
 
 核心思想就是:当对象的状态改变时，同时改变其行为，很好理解！就拿QQ来说，有几种状态，在线、隐身、忙碌等，每个状态对应不同的操作，而且你的好友也能看到你的状态，所以，状态模式就两点:       
 
@@ -1602,9 +1674,11 @@ execute the second opt!
 
 根据这个特性，状态模式在日常开发中用的挺多的，尤其是做网站的时候，我们有时希望根据对象的某一属性，区别开他们的一些功能，比如说简单的权限控制等。
 
+
+
 访问者模式`(Visitor)`
 ---
-
+访问者模式(Visitor)主要解决的是数据与算法的耦合问题，尤其是在数据结构比较稳定，而算法多变的情况下。为了不“污染”数据本身，访问者模式会将多种算法独立归类，并在访问数据时根据数据类型自动切换到对应的算法，实现数据的自动响应机制，并且确保算法的自由扩展。
 
 访问者模式把数据结构和作用于结构上的操作解耦合，使得操作集合可相对自由地演化。访问者模式适用于数据结构相对稳定算法又易变化的系统。因为访问者模式使得算法操作增加变得容易。若系统数据结构对象易于变化，经常有新的数据对象增加进来，则不适合使用访问者模式。访问者模式的优点是增加操作很容易，因为增加操作意味着增加新的访问者。访问者模式将有关行为集中到一个访问者对象中，其改变不影响系统数据结构。其缺点就是增加新的数据结构很困难。
 
@@ -1690,13 +1764,12 @@ execute the second opt!
 中介者模式`(Mediator)`
 ---
 
+中介是在事物之间传播信息的中间媒介。中介模式(Mediator)为对象构架出一个互动平台，通过减少对象间的依赖程度以达到解耦的目的。我们的生活中有各种各样的媒介，如婚介所、房产中介、门户网站、电子商务、交换机组网、通信基站、即时通软件等，这些都与人类的生活息息相关，离开它们我们将举步维艰。
 
 中介者模式也是用来降低类类之间的耦合的，因为如果类类之间有依赖关系的话，不利于功能的拓展和维护，因为只要修改一个对象，其它关联的对象都得进行修改。
 如果使用中介者模式，只需关心和`Mediator`类的关系，具体类类之间的关系及调度交给`Mediator`就行，这有点像`spring`容器的作用。
 
 
-
-
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/mediator.jpg?raw=true)  
 
 `User`类统一接口，`User1`和`User2`分别是不同的对象，二者之间有关联，如果不采用中介者模式，则需要二者相互持有引用，这样二者的耦合度很高，为了解耦，
@@ -1785,11 +1858,18 @@ public static void main(String[] args) {
     // user2 exe!
 }  
 ```
+众所周知，对象间显式的互相引用越多，意味着依赖性越强，同时独立性越弱，不利于代码的维护与扩展。中介模式很好地解决了这些问题，它能将多方互动的工作交由中间平台去完成，解除了你中有我、我中有你的相互依赖，让各个模块之间的关系变得更加松散、独立，最终增强系统的可复用性与可扩展性，同时也使系统运行效率得到提升。
+
 
 
 解释器模式`(Interpreter)`
 ---
 
+解释有拆解、释义的意思，一般可以理解为针对某段文字，按照其语言的特定语法进行解析，再以另一种表达形式表达出来，以达到人们能够理解的目的。类似地，解释器模式(Interpreter)会针对某种语言并基于其语法特征创建一系列的表达式类（包括终极表达式与非终极表达式），利用树结构模式将表达式对象组装起来，最终将其翻译成计算机能够识别并执行的语义树。例如结构型数据库对查询语言SQL的解析，浏览器对HTML语言的解析，以及操作系统Shell对命令的解析。不同的语言有着不同的语法和翻译方式，这都依靠解释器完成。以最常见的Java编程语言为例。当我们以人类能够理解的语言完成了一段程序并命名为Hello.java后，经过调用编译器会生成Hello.class的字节码文件，执行的时候则会加载此文件到内存并进行解释、执行，最终被解释的机器码才是计算机可以理解并执行的指令格式，如下图所示。从Java语言到机器语言，这个跨越语言鸿沟的翻译步骤必须由解释器来完成，这便是其存在的意义： 
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/design_mode_jieshiqi.png?raw=true)     
+
+
 解释器模式是我们暂时的最后一讲，一般主要应用在`OOP`开发中的编译器的开发中，所以适用面比较窄。
 
 
@@ -1853,6 +1933,16 @@ public static void main(String[] args) {
 ```
 基本就这样，解释器模式用来做各种各样的解释器，如正则表达式等的解释器等等！
 
+
+
+在面向对象的软件设计中，人们经常会遇到一些重复出现的问题。为降低软件模块的耦合性，提高软件的灵活性、兼容性、可复用性、可维护性与可扩展性，人们从宏观到微观对各种软件系统进行拆分、抽象、组装，确立模块间的交互关系，最终通过归纳、总结，将一些软件模式沉淀下来成为通用的解决方案，这就是设计模式的由来与发展。
+
+
+
+
+
+
+
 		
 ---
 - 邮箱 ：charon.chui@gmail.com  
diff --git "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md" "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
index d5741133..a6c78e71 100644
--- "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
+++ "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
@@ -357,6 +357,26 @@ private fun switchFragment(position: Int) {
 ```
 会报`kotlin.UninitializedPropertyAccessException: lateinit property test has not been initialized`
 
+这里想要判断是否初始化了，需要用isInitialized来判断:  
+```kotlin
+class MyService{
+    fun performAction(): String = "foo"
+}
+
+class Test{
+    private lateinit var myService: MyService
+
+    fun main(){
+        // 如果 myService 对象还未初始化，则进行初始化
+        if(!::myService.isInitialized){
+            println("hha")
+            myService = MyService()
+        }
+    }
+}
+```
+注意: :myService.isInitialized可用于判断adapter变量是否已经初始化。虽然语法看上去有点奇怪，但这是固定的写法。`::`前缀不能省
+
 除了使用`lateinit`外还可以使用`by lazy {}`效果是一样的：   
 ```kotlin
 private val test by lazy { "haha" }
@@ -627,6 +647,8 @@ class Bird(weight: Double, aget: Int, color: String) {
 
 ## 数据类:使用`data class`定义
 
+数据类通常需要重写equals()、hashCode()、toString()这几个方法。其中，equals()方法用于判断两个数据类是否相等。hashCode()方法作为equals()的配套方法，也需要一起重写，否则会导致HashMap、HashSet等hash相关的系统类无法正常工作。toString()方法用于提供更清晰的输入日志，否则一个数据类默认打印出来的就是一行内存地址。所以我们在Java中创建一个数据类时要写很多代码，但是在Kotlin中你只需要一行代码。
+
 数据类是一种非常强大的类:   
 
 ```java
@@ -810,7 +832,14 @@ class SuperPerson(num: Int) : Person(num)
 
 冒号后面的Person(num)会调用Person类的构造函数，以确保所有的初始化代码（例如给属性赋值）能够被执行。调用父类构造函数是强制性的：如果父类有主构造函数，你必须在子类头中调用它，否则代码将无法通过编译。请记住，即使你没有在父类中显式地添加构造函数，编译器也会在编译代码的时候自动创建一个空构造函数。假如我们不想为Person类添加构造函数，因此编译器在编译代码的时候创建了一个空构造函数。该构造函数通过使用Person()被调用。
 
+
+
+注意： 上面在说道继承的时候`class SuperPerson(num: Int) : Person(num)`在父类后面必须加上括号，这是为了能够调用到父类的主构造函数。Kotlin中规定，当一个类既有主构造函数又有次构造函数时，所有的次构造函数都必须调用主构造函数(包括间接调用)。
+但是如果类没有主构造函数，如果类没有主构造函数，那么每个次构造函数必须使用`super`关键字初始化其基类型，或委托给另一个构造函数做到这一点。 这里很特殊，在Kotlin
+中是允许类中只有次构造函数，没有主构造函数的。当一个类没有显式的定义主构造函数且定义了次构造函数时，它就是没有主构造函数的。
+
 如果该类有一个主构造函数，其基类必须用基类型的主构造函数参数就地初始化。
+
 如果类没有主构造函数，那么每个次构造函数必须使用`super`关键字初始化其基类型，或委托给另一个构造函数做到这一点。
 注意，在这种情况下，不同的次构造函数可以调用基类型的不同的构造函数:   
 
@@ -820,6 +849,10 @@ class MyView : View {
     constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
 }
 ```
+也就是MyView类的后面没有显式的定义主构造函数，同时又定义了次构造函数。所以现在MyView类是没有主构造函数的。那么既然没有主构造函数，继承View类的时候也就不需要再在View类后加上括号了。
+其实原因就是这么简单，只是很多人在刚开始学习Kotlin的时候没能理解这对括号的意义和规则，因此总感觉继承的写法有时候要加上括号，有时候又不要加，搞得晕头转向的，而在你真正理解了规则之后，就会发现其实还是很好懂的。
+
+另外，由于没有主构造函数，次构造函数只能直接调用父类的构造函数，上述代码也是将this关键字换成了super关键字，这部分就很好理解了。
 
 
 ### Any
@@ -1005,6 +1038,13 @@ interface Flyer {
 }
 ```
 
+一个类实现接口时： 
+```kotlin
+class Bird() : Flyer {
+    //  ...
+}
+```
+接口的后面不用加上括号，因为它没有构造函数可以去调用。
 
 
 ## 函数:通过`fun`关键字定义
diff --git "a/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md" "b/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
index e426256e..6e4ad471 100644
--- "a/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
+++ "b/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
@@ -227,6 +227,10 @@ countryApp.filterCountries(countries, {
 
 这就是Lambda表达式，它与匿名函数一样，是一种函数字面量。
 
+首先来看一下Lambda的定义，如果用最直白的语言来阐述的话，Lambda就是一小段可以作为参数传递的代码。从定义上看，这个功能就很厉害了，因为正常情况下，我们向某个函数传参时只能传入变量，而借助Lambda却允许传入一小段代码。这里两次使用了“一小段代码”这种描述，那么到底多少代码才算一小段代码呢？Kotlin对此并没有进行限制，但是通常不建议在Lambda表达式中编写太长的代码，否则可能会影响代码的可读性。
+
+
+
 Lambda的语法:  
 
 - 一个Lambda表达式必须通过{}来包裹
@@ -244,6 +248,7 @@ val foo = { x: Int ->
 
 ## Lambda表达式
 
+{参数名1: 参数类型, 参数名2: 参数类型 -> 函数体}
 
 > “Lambda 表达式”(lambda expression)其实就是匿名函数，`Lambda`表达式基于数学中的`λ`演算得名，直接对应于其中的`lambda`抽象
 > `(lambda abstraction)`，是一个匿名函数，即没有函数名的函数。`Lambda`表达式可以表示闭包。
@@ -368,6 +373,11 @@ add = { x: Int, y: Int -> x + y }
 Lambda类型也被认为是函数类型。
 
 
+当Lambda表达式的参数列表中只有一个参数时，也不必声明参数名，而是可以使用it关键字来代替.
+```kotlin
+val list = listOf("Apple", "Bnana", "Orange", "Pear")
+val maxLengthFruit = list.maxBy {it.length}
+```
 
 ### Lambda开销
 
diff --git "a/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md" "b/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
index 27224838..75599003 100644
--- "a/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
+++ "b/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
@@ -471,6 +471,25 @@ class App : Application() {
 在这例子中，创建一个继承`Application`的类，并且在`companion object`中存储它的唯一实例。     
 `lateinit`表示这个属性开始是没有值的，但是，在使用前将被赋值（否则，就会抛出异常）。     
 
+
+不过，上面companion object中的isRedpack()方法其实也并不是静态方法，companionobject这个关键字实际上会在类的内部创建一个伴生类，而isRedpack方法就是定义在这个伴生类里面的实例方法。只是Kotlin会保证类始终只会存在一个伴生类对象，因此调用Prize.isRedpack()方法实际上就是调用了Prize类中伴生对象的isRedpack()方法。由此可以看出，Kotlin确实没有直接定义静态方法的关键字，但是提供了一些语法特性来支持类似于静态方法调用的写法，这些语法特性基本可以满足我们平时的开发需求了。然而如果你确确实实需要定义真正的静态方法， Kotlin仍然提供了两种实现方式：注解和顶层方法。
+
+先来看注解，前面使用的单例类和companion object都只是在语法的形式上模仿了静态方法的调用方式，实际上它们都不是真正的静态方法。因此如果你在Java代码中以静态方法的形式去调用的话，你会发现这些方法并不存在。而如果我们给单例类或companion object中的方法加上@JvmStatic注解，那么Kotlin编译器就会将这些方法编译成真正的静态方法
+
+注意，@JvmStatic注解只能加在单例类或companion object中的方法上，如果你尝试加在一个普通方法上，会直接提示语法错误。那么现在不管是在Kotlin中还是在Java中，都可以使用Prize.isRedpack()的写法来调用了。
+
+再来看顶层方法，顶层方法指的是那些没有定义在任何类中的方法。Kotlin编译器会将所有的顶层方法全部编译成静态方法，因此只要你定义了一个顶层方法，那么它就一定是静态方法。
+如果我们新建一个Helper.kt的空文件(注意不是类，是空文件），在文件中定义一个方法: 
+```kotlin 
+fun doSomething() {
+    println("do something")
+}
+```
+刚才已经讲过了，Kotlin编译器会将所有的顶层方法全部编译成静态方法，那么这里又没有类我们要怎么调用这个doSomething()方法呢？如果是在Kotlin代码中调用的话，那就很简单了，所有的顶层方法都可以在任何位置被直接调用，不用管包名路径，也不用创建实例，直接键入doSomething()即可。
+
+但如果是在Java代码中调用，你会发现是找不到doSomething()这个方法的，因为Java中没有顶层方法这个概念，所有的方法必须定义在类中。那么这个doSomething()方法被藏在了哪里呢？我们刚才创建的Kotlin文件名叫作Helper.kt，于是Kotlin编译器会自动创建一个叫作HelperKt的Java类，doSomething()方法就是以静态方法的形式定义在HelperKt类里面的，因此在Java中使用HelperKt.doSomething()的写法来调用就可以了。
+
+
 ### 单例
 
 因为一个类的伴生对象跟一个静态类一样，全局只能有一个。这让我们联想到了什么？ 没错，就是单例对象。
diff --git "a/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md" "b/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md"
index a6a52562..50ff4d0a 100644
--- "a/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md"
+++ "b/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md"
@@ -666,6 +666,8 @@ if (name.isNullOrBlank()) {
 
 #### `with`函数
 
+with函数接收两个参数：第一个参数可以是一个任意类型的对象，第二个参数是一个Lambda表达式。with函数会在Lambda表达式中提供第一个参数对象的上下文，并使用Lambda表达式中的最后一行代码作为返回值返回。
+
 with和apply这两个方法最大的作用就是可以让那个我们在写Lambda的时候，省略需要多次书写的对象名，默认用this关键字来指向它，this可以省略。
 
 `with`是一个非常有用的函数，它包含在`Kotlin`的标准库中。它接收一个对象和一个扩展函数作为它的参数，然后使这个对象扩展这个函数。

From 0b087067af7d220f825c26a09f5ddb9edcd676fe Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 22 Dec 2022 15:55:07 +0800
Subject: [PATCH 090/213] update notes

---
 ...05\350\201\224\345\207\275\346\225\260.md" | 101 +++++++++++++++++-
 ...2\344\270\276&\345\247\224\346\211\230.md" |  86 +++++++++++++++
 2 files changed, 185 insertions(+), 2 deletions(-)

diff --git "a/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md" "b/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
index 6e4ad471..42440cd9 100644
--- "a/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
+++ "b/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
@@ -639,7 +639,7 @@ fun main() {
 
 ## 优化Lambda开销
 
-在Kotlin中每声明一个Lambda表达式，就会在字节码中产生一个匿名类。该匿名类包含了一个invoke方法，作为Lambda的调用方法，每次调用的时候，还会创建一个新的对象。可想而知，Lambda语法虽然简洁，但是额外增加的开销也不少。并且，如果Lambda捕捉了某个变量，那么每次调用的时候都会创建一个新的对象，这样导致效率较低。尤其对Kotlin这门语言来说，它当今优先要实现的目标，就是在Android这个平台上提供良好的语言特性支持。Kotlin要在Android中引入Lambda语法，必须采用某种方法来优化Lambda带来的额外开销，也就是内联函数。 
+在Kotlin中每声明一个Lambda表达式，就会在字节码中产生一个匿名类(也就是说我们一直使用的Lambda表达式在底层被转换成了匿名类的实现方式)。该匿名类包含了一个invoke方法，作为Lambda的调用方法，每次调用的时候，还会创建一个新的匿名类对象。可想而知，Lambda语法虽然简洁，但是额外增加的开销也不少。并且，如果Lambda捕捉了某个变量，那么每次调用的时候都会创建一个新的对象，这样导致效率较低。尤其对Kotlin这门语言来说，它当今优先要实现的目标，就是在Android这个平台上提供良好的语言特性支持。Kotlin要在Android中引入Lambda语法，必须采用某种方法来优化Lambda带来的额外开销，也就是内联函数。 
 
 #### 1. invokedynamic
 
@@ -655,7 +655,8 @@ fun main() {
 
 invokedynamic固然不错，但Kotlin不支持它的理由似乎也很充分，我们有足够的理由相信，其最大的原因是Kotlin在一开始就需要兼容Android最主流的Java版本SE 6，这导致它无法通过invovkedynamic来解决Android平台的Lambda开销问题。 
 
-因此，作为另一种主流的解决方案，Kotlin拥抱了内联函数，在C++、C#等语言中也支持这种特性。简单的来说，我们可以用inline关键字来修饰函数，这些函数就称为了内联函数。他们的函数体在编译期被嵌入每一个被调用的地方，以减少额外生成的匿名类数，以及函数执行的时间开销。 
+因此，作为另一种主流的解决方案，Kotlin拥抱了内联函数，在C++、C#等语言中也支持这种特性。简单的来说，我们可以用inline关键字来修饰函数，这些函数就称为了内联函数。他们的函数体在编译期被嵌入每一个被调用的地方，以减少额外生成的匿名类数，以及函数执行的时间开销。
+所以内联函数的工作原理并不复杂，就是Kotlin编译器会将内敛函数中的代码在编译的时候自动替换到调用它的地方，这样也就不存在运行时的开销了。 
 
 所以如果你想在用Kotlin开发时获得尽可能良好的性能支持，以及控制匿名类的生成数量，就有必要来学习下内联函数的相关语法。 
 
@@ -805,6 +806,7 @@ public static final void foo(@NotNull Function0 block1, @NotNull Function0 block
 
 可以看出，foo函数的block2参数在带上noinline之后，反编译后的Java代码中并没有将其函数体代码在调用处进行替换。
 
+
 #### 非局部返回
 
 Kotlin中的内联函数除了优化Lambda开销之外，还带来了其他方面的特效，典型的就是非局部返回和具体化参数类型。我们先来看下Kotlin如何支持非局部返回。 
@@ -892,6 +894,101 @@ fun hasZeros(list: List<Int>): Boolean {
 }
 ```
 
+
+##### 为什么要设计noinline 
+
+这里我已经蒙了，前面已经说了内联函数的好处，那为什么Kotlin还要提供一个noinline关键字来排除内联功能呢? 
+这是因为内联的函数类型参数在编译的时候会被进行代码替换，因此它没有真正的参数属性。
+非内联的函数类型参数可以自由地传递给其他任何函数，因为它就是一个真实的参数，而内联的函数类型参数只允许传递给另外一个内联函数，这也是它最大的局限性。
+另外，内联函数和非内联函数还有一个重要的区别，那就是内联函数所引用的Lambda表达式中是可以使用return关键字来进行函数返回的，而非内联函数只能进行局部返回。为了说明这个问题，我们来看下面的例子:  
+```kotlin
+fun printString(str: String, block: (String) -> Unit) {
+    println("printString begin")
+    block(str)
+    println("printString end")
+}
+
+fun main() {
+    println("main start")
+    val str = ""
+    printString(str) { s ->
+        println("lambda start")
+        if (s.isEmpty()) return@printString
+        println(s)
+        println("lambda end")
+    }
+    println("main end")
+}
+```
+这里定义了一个叫作printString()的高阶函数，用于在Lambda表达式中打印传入的字符串参数。但是如果字符串参数为空，那么就不进行打印。注意，Lambda表达式中是不允许直接使用return关键字的，这里使用了return@printString的写法，表示进行局部返回，并且不再执行Lambda表达式的剩余部分代码。现在我们就刚好传入一个空的字符串参数，运行程序，打印结果如下： 
+```
+main start
+printString begin
+lambda start
+printString end
+main end
+```
+
+可以看到，除了Lambda表达式中return@printString语句之后的代码没有打印，其他的日志是正常打印的，说明return@printString确实只能进行局部返回。但是如果我们将printString()函数声明成一个内联函数，那么情况就不一样了，如下所示：
+```kotlin
+inline fun printString(str: String, block: (String) -> Unit) {
+    println("printString begin")
+    block(str)
+    println("printString end")
+}
+
+fun main() {
+    println("main start")
+    val str = ""
+    printString(str) { s ->
+        println("lambda start")
+        if (s.isEmpty()) return
+        println(s)
+        println("lambda end")
+    }
+    println("main end")
+}
+```
+现在printString()函数变成了内联函数，我们就可以在Lambda表达式中使用return关键字了。此时的return代表的是返回外层的调用函数，也就是main()函数，如果想不通为什么的话，可以回顾一下在上一小节中学习的内联函数的代码替换过程。现在重新运行一下程序，打印结果如下:   
+```
+main start
+printString begin 
+lambda start
+```
+可以看到，不管是main()函数还是printString()函数，确实都在return关键字之后停止执行了，和我们所预期的结果一致。
+将高阶函数声明成内联函数是一种良好的编程习惯，事实上，绝大多数高阶函数是可以直接声明成内联函数的，但是也有少部分例外的情况。观察下面的代码示例：
+```kotlin
+inline fun runRunnable(block: () -> Unit) {
+    val runnable = Runnable {
+        block()
+    }
+    runnable.run()
+}
+```
+这段代码在没有加上inline关键字声明的时候绝对是可以正常工作的，但是在加上inline关键字之后就会提示如下:  
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/inline_noline_error.png?raw=true)        
+
+这个错误出现的原因解释起来可能会稍微有点复杂。首先，在runRunnable()函数中，我们创建了一个Runnable对象，并在Runnable的Lambda表达式中调用了传入的函数类型参数。而Lambda表达式在编译的时候会被转换成匿名类的实现方式，也就是说，上述代码实际上是在匿名类中调用了传入的函数类型参数。
+
+
+而内联函数所引用的Lambda表达式允许使用return关键字进行函数返回，但是由于我们是在匿名类中调用的函数类型参数，此时是不可能进行外层调用函数返回的，最多只能对匿名类中的函数调用进行返回，因此这里就提示了上述错误。
+也就是说，如果我们在高阶函数中创建了另外的Lambda或者匿名类的实现，并且在这些实现中调用函数类型参数，此时再将高阶函数声明成内联函数，就一定会提示错误。
+
+那么是不是在这种情况下就真的无法使用内联函数了呢？也不是，比如借助crossinline关键字就可以很好地解决这个问题：
+```kotlin
+inline fun runRunnable(crossinline block: () -> Unit) {
+    val runnable = Runnable {
+        block()
+    }
+    runnable.run()
+}
+```
+可以看到，这里在函数类型参数的前面加上了crossinline的声明，代码就可以正常编译通过了。
+那么这个crossinline关键字又是什么呢？前面我们已经分析过，之所以会提示上面所示的错误，就是因为内联函数的Lambda表达式中允许使用return关键字，和高阶函数的匿名类实现中不允许使用return关键字之间造成了冲突。而crossinline关键字就像一个契约，它用于保证在内联函数的Lambda表达式中一定不会使用return关键字，这样冲突就不存在了，问题也就巧妙地解决了。
+
+声明了crossinline之后，我们就无法在调用runRunnable函数时的Lambda表达式中使用return关键字进行函数返回了，但是仍然可以使用return@runRunnable的写法进行局部返回。总体来说，除了在return关键字的使用上有所区别之外，crossinline保留了内联函数的其他所有特性。
+
 #### crossinline
 
 值得注意的是，非局部返回虽然在某些场合下非常有用，但可能也存在危险。因为有时候，我们内联的函数所接收的Lambda参数常常来自于上下文其他地方。为了避免带有return的Lambda参数产生破坏，我们还可以使用crossinline关键字来修饰该参数，从而杜绝此类问题的发生。就像这样子: 
diff --git "a/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md" "b/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
index 75599003..9c91998e 100644
--- "a/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
+++ "b/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
@@ -30,6 +30,49 @@ val t2 = TypedClass(25)
 val t3 = TypedClass<String?>(null)
 ```
 
+#### 泛型实化
+泛型实化功能允许我们在泛型函数当中获得泛型的实际类型，这也就使得类似于a is T、T::class.java这样的语法成为了可能。而灵活运用这一特性将可以实现一些不可思议的语法结构，下面我们赶快来看一下吧。到目前为止，我们已经将Android的四大组件全部学完了，除了ContentProvider之外，你会发现其余的3个组件有一个共同的特点，它们都是要结合Intent一起使用的。比如说启动一个Activity就可以这么写：
+```kotlin
+val intent = Intent(context, TestActivity::class.java)
+context.startActivity(intent)
+```
+有没有觉得TestActivity::class.java这样的语法很难受呢？当然，如果在没有更好选择的情况下，这种写法也是可以忍受的，但是Kotlin的泛型实化功能使得我们拥有了更好的选择。新建一个reified.kt文件，然后在里面编写如下代码：
+```kotlin
+inline fun <reified T> startActivity(context: Context) {
+    val intent = Intent(context, T::class.java)
+    context.startActivity(intent)
+}
+```
+这里我们定义了一个startActivity()函数，该函数接收一个Context参数，并同时使用inline和reified关键字让泛型T成为了一个被实化的泛型。接下来就是神奇的地方了，Intent接收的第二个参数本来应该是一个具体Activity的Class类型，但由于现在T已经是一个被实化的泛型了，因此这里我们可以直接传入T::class.java。最后调用Context的startActivity()方法来完成Activity的启动。现在，如果我们想要启动TestActivity，只需要这样写就可以了：[插图]Kotlin将能够识别出指定泛型的实际类型，并启动相应的Activity。
+```kotlin
+startActivity<TestActivity>(context)
+```
+Kotlin将能够识别出指定泛型的实际类型，并启动相应的Activity。
+不过，现在的startActivity()函数其实还是有问题的，因为通常在启用Activity的时候还可能会使用Intent附带一些参数，比如下面的写法：
+```kotlin
+val intent = Intent(context, TestActivity::class.java)
+intent.putExtra("param1", "data")
+intent.putExtra("param2", 123)
+context.startActivity(intent)
+```
+而经过刚才的封装之后，我们就无法进行传参了。这个问题也不难解决，只需要借助之前在第6章学习的高阶函数就可以轻松搞定。回到reified.kt文件当中，这里添加一个新的startActivity()函数重载，如下所示：
+```kotlin
+inline fun <reified T> startActivity(context: Context, block: Intent.() -> Unit) {
+    val intent = Intent(context, T::class.java)
+    intent.block()
+    context.startActivity(intent)
+}
+```
+可以看到，这次的startActivity()函数中增加了一个函数类型参数，并且它的函数类型是定义在Intent类当中的。在创建完Intent的实例之后，随即调用该函数类型参数，并把Intent的实例传入，这样调用startActivity()函数的时候就可以在Lambda表达式中为Intent传递参数了，如下所示：
+```kotlin
+startActivity<TestActivity>(context) {
+    putExtra("param1", "data")
+    putExtra("param2", 123)
+}
+```
+不得不说，这种启动Activity的代码写起来实在是太舒服了，泛型实化和高阶函数使这种语法结构成为了可能.
+
+
 
 ##### 类型擦除 
 
@@ -46,6 +89,10 @@ com.study.jcking.weatherkotlin.exec.Data
 声明了一个泛型类`Data<T>`，并实现了两种不同类型的实例。但是在获取类名是，却发现得到了同样的结果
 `com.study.jcking.weatherkotlin.exec.Data`，这其实是在编译期擦除了泛型类型声明。
 
+
+
+
+
 ### 嵌套类
 
 嵌套类顾名思义，就是嵌套在其他类中的类。而嵌套类外部的类一般被称为包装类或者外部类。
@@ -804,6 +851,45 @@ void test(){
 
 如果你指定的参数为`LazyThreadSafetyMode.SYNCHRONIZED`,则可以省略，因为`lazy`默认就是使用的`LazyThreadSafetyMode.SYNCHRONIZED`。
 
+
+
+那么学习了Kotlin的委托功能之后，我们就可以对by lazy的工作原理进行解密了，它的基本语法结构如下: 
+```kotlin
+val p by lazy { ... }
+```
+现在再来看这段代码，是不是觉得更有头绪了呢？实际上，bylazy并不是连在一起的关键字，只有by才是Kotlin中的关键字，
+lazy在这里只是一个高阶函数而已。在lazy函数中会创建并返回一个Delegate对象，当我们调用p属性的时候，
+其实调用的是Delegate对象的getValue()方法，然后getValue()方法中又会调用lazy函数传入的Lambda表达式，
+这样表达式中的代码就可以得到执行了，并且调用p属性后得到的值就是Lambda表达式中最后一行代码的返回值。
+简单的实现如下:  
+```kotlin
+class Later<T>(val block: () -> T) {
+
+}
+```
+这里我们首先定义了一个Later类，并将它指定成泛型类。Later的构造函数中接收一个函数类型参数，这个函数类型参数不接收任何参数，并且返回值类型就是Later类指定的泛型。接着我们在Later类中实现getValue()方法，代码如下所示：
+```kotlin
+class Later<T>(val block: () -> T) {
+
+    var value: Any? = null
+
+    operator fun getValue(any: Any?, prop: KProperty<*>): T {
+        if (value == null) {
+            value = block()
+        }
+        return value as T
+    }
+
+}
+```
+这里将getValue()方法的第一个参数指定成了Any?类型，表示我们希望Later的委托功能在所有类中都可以使用。然后使用了一个value变量对值进行缓存，如果value为空就调用构造函数中传入的函数类型参数去获取值，否则就直接返回。由于懒加载技术是不会对属性进行赋值的，因此这里我们就不用实现setValue()方法了。代码写到这里，委托属性的功能就已经完成了。虽然我们可以立刻使用它，不过为了让它的用法更加类似于lazy函数，最好再定义一个顶层函数。这个函数直接写在Later.kt文件中就可以了，但是要定义在Later类的外面，因为只有不定义在任何类当中的函数才是顶层函数。代码如下所示：
+```kotlin
+fun <T> later(block: () -> T) = Later(block)
+```
+我们将这个顶层函数也定义成了泛型函数，并且它也接收一个函数类型参数。这个顶层函数的作用很简单：创建Later类的实例，并将接收的函数类型参数传给Later类的构造函数。现在，我们自己编写的later懒加载函数就已经完成了，你可以直接使用它来替代之前的lazy函数
+
+
+
 ##### 可观察属性
 
 如果你要观察一个属性的变化过程，那么可以将属性委托给`Delegates.observable`, `observable`函数原型如下：

From a1bc7c97237d7b78abc3c7afefcccdfcfd2b9efd Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 22 Dec 2022 19:30:02 +0800
Subject: [PATCH 091/213] update notes

---
 ...5\344\273\244\350\241\214\345\244\247\345\205\250.md" | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git "a/JavaKnowledge/\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214\345\244\247\345\205\250.md" "b/JavaKnowledge/\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214\345\244\247\345\205\250.md"
index 53efd6b1..77830f45 100644
--- "a/JavaKnowledge/\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214\345\244\247\345\205\250.md"
+++ "b/JavaKnowledge/\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214\345\244\247\345\205\250.md"
@@ -511,7 +511,16 @@ ifconfig [网络设备] [参数]
     
 
 
+- file命令是一个方便的小工具，能够探测文件的内部并判断文件类型：
+$ file .bashrc
+.bashrc: ASCII text
 
+
+- pkill命令可以使用程序名代替PID来终止进程，这就方便多了。除此之外，pkill命令也允许使用通配符，当系统出问题时，这是一个非常有用的工具：
+# pkill http*
+#
+该命令将“杀死”所有名称以http起始的进程，比如Apahce Web Server的httpd服务。
+警告　以root身份使用pkill命令时要格外小心。命令中的通配符很容易意外地将系统的重要进程终止。这可能会导致文件系统损坏。
     
 
         

From 5c4e1e1950f310663bace33581e8239adf8992b1 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 8 Feb 2023 20:52:43 +0800
Subject: [PATCH 092/213] update

---
 .../Git\347\256\200\344\273\213.md"           | 681 ++++++++++--------
 ...37\347\220\206\345\210\206\346\236\220.md" | 241 ++++---
 ...ps\347\232\204\345\214\272\345\210\253.md" |  14 +-
 ...05\345\255\230\346\250\241\345\236\213.md" |  37 +-
 ...12\346\234\211\345\272\217\346\200\247.md" |  71 +-
 .../MD5\345\212\240\345\257\206.md"           |  13 +-
 ...14Synchronized\345\214\272\345\210\253.md" |  80 +-
 ...13\346\261\240\347\256\200\344\273\213.md" |  38 +-
 ...46\344\271\240\346\211\213\345\206\214.md" |  16 +-
 ...70\345\205\263\345\267\245\345\205\267.md" | 481 +++++--------
 10 files changed, 815 insertions(+), 857 deletions(-)

diff --git "a/JavaKnowledge/Git\347\256\200\344\273\213.md" "b/JavaKnowledge/Git\347\256\200\344\273\213.md"
index d3d372be..fbba61fb 100644
--- "a/JavaKnowledge/Git\347\256\200\344\273\213.md"
+++ "b/JavaKnowledge/Git\347\256\200\344\273\213.md"
@@ -1,46 +1,54 @@
 Git简介
-===
-
-`Git`和其他版本控制系统(包括`Subversion`及其他相似的工具)的主要差别在于`Git`对待数据的方法。概念上来区分，其它大部分系统以文件变更列表的方式存储信息。 
-这类系统(`CVS、Subversion、Perforce、Bazaar`等等)将它们保存的信息看作是一组基本文件和每个文件随时间逐步累积的差异。存储每个文件与初始版本的差异。   
-
-
-`Git`不按照以上方式对待或保存数据。反之，`Git`更像是把数据看作是对小型文件系统的一组快照。每次你提交更新，或在`Git`中保存项目状态时，
-它主要对当时的全部文件制作一个快照并保存这个快照的索引。为了高效，如果文件没有修改，`Git`不再重新存储该文件，而是只保留一个链接指向之前存储的文件。`Git`对待数据更像是一个快照流。
-
-`Git`是分布式版本控制系统，集中式和分布式版本控制有什么区别呢？   
-
-- 集中式版本控制系统    
-    版本库是集中存放在中央服务器的，而干活的时候，用的都是自己的电脑，所以要先从中央服务器取得最新的版本，然后开始干活，干完活了，再把自己的活推送给中央服务器。中央服务器就好比是一个图书馆，你要改一本书，必须先从图书馆借出来，然后回到家自己改，改完了，再放回图书馆。集中式版本控制系统最大的毛病就是必须联网才能工作，如果在局域网内还好，带宽够大，速度够快，可如果在互联网上，遇到网速慢的话，可能提交一个10M的文件就需要5分钟，这还不得把人给憋死啊。    
-    ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_jizhong.jpeg)                
-
-- 分布式版本控制系统     
-    分布式版本控制系统根本没有“中央服务器”，每个人的电脑上都是一个完整的版本库，这样，你工作的时候，就不需要联网了，因为版本库就在你自己的电脑上。既然每个人电脑上都有一个完整的版本库，那多个人如何协作呢？比方说你在自己电脑上改了文件A，你的同事也在他的电脑上改了文件A，这时，你们俩之间只需把各自的修改推送给对方，就可以互相看到对方的修改了。     
-    和集中式版本控制系统相比，分布式版本控制系统的安全性要高很多，因为每个人电脑里都有完整的版本库，某一个 人   的电脑坏掉了不要紧，随便从其他人那里复制一个就可以了。而集中式版本控制系统的中央服务器要是出了问题，所有人都没法干活了。    
-    在实际使用分布式版本控制系统的时候，其实很少在两人之间的电脑上推送版本库的修改，因为可能你们俩不在一个局域网内，两台电脑互相访问不了，也可能今天你的同事病了，他的电脑压根没有开机。因此，分布式版本控制系统通常也有一台充当“中央服务器”的电脑，但这个服务器的作用仅仅是用来方便“交换”大家的修改，没有它大家也一样干活，只是交换修改不方便而已。          
-    ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_fenbu.jpeg)             
+=======
+
+`Git`和其他版本控制系统(包括`Subversion`及其他相似的工具)的主要差别在于`Git`对待数据的方法。概念上来区分，其它大部分系统以文件
+变更列表的方式存储信息。
+这类系统(`CVS、Subversion、Perforce、Bazaar`等等)将它们保存的信息看作是一组基本文件和每个文件随时间逐步累积的差异。
+存储每个文件与初始版本的差异。
+
+`Git`不按照以上方式对待或保存数据。反之，`Git`更像是把数据看作是对小型文件系统的一组快照。每次你提交更新，或在`Git`中保存项目
+状态时，它主要对当时的全部文件制作一个快照并保存这个快照的索引。为了高效，如果文件没有修改，`Git`不再重新存储该文件，而是只保留一个
+链接指向之前存储的文件。`Git`对待数据更像是一个快照流。
+
+`Git`是分布式版本控制系统，集中式和分布式版本控制有什么区别呢？
+
+- 集中式版本控制系统
+  版本库是集中存放在中央服务器的，而干活的时候，用的都是自己的电脑，所以要先从中央服务器取得最新的版本，然后开始干活，干完活了，
+  再把自己的活推送给中央服务器。中央服务器就好比是一个图书馆，你要改一本书，必须先从图书馆借出来，然后回到家自己改，改完了，
+  再放回图书馆。集中式版本控制系统最大的毛病就是必须联网才能工作，如果在局域网内还好，带宽够大，速度够快，可如果在互联网上，
+  遇到网速慢的话，可能提交一个10M的文件就需要5分钟，这还不得把人给憋死啊。
+  ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_jizhong.jpeg)
+- 分布式版本控制系统
+  分布式版本控制系统根本没有“中央服务器”，每个人的电脑上都是一个完整的版本库，这样，你工作的时候，就不需要联网了，因为版本库就在
+  你自己的电脑上。既然每个人电脑上都有一个完整的版本库，那多个人如何协作呢？比方说你在自己电脑上改了文件A，你的同事也在他的电脑上
+  改了文件A，这时，你们俩之间只需把各自的修改推送给对方，就可以互相看到对方的修改了。
+  和集中式版本控制系统相比，分布式版本控制系统的安全性要高很多，因为每个人电脑里都有完整的版本库，某一个人的电脑坏掉了不要紧，
+  随便从其他人那里复制一个就可以了。而集中式版本控制系统的中央服务器要是出了问题，所有人都没法干活了。
+  在实际使用分布式版本控制系统的时候，其实很少在两人之间的电脑上推送版本库的修改，因为可能你们俩不在一个局域网内，两台电脑互相
+  访问不了，也可能今天你的同事病了，他的电脑压根没有开机。因此，分布式版本控制系统通常也有一台充当“中央服务器”的电脑，但这个服务器
+  的作用仅仅是用来方便“交换”大家的修改，没有它大家也一样干活，只是交换修改不方便而已。
+
+  ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_fenbu.jpeg)
 
 版本库
----
+------
 
-什么是版本库呢？版本库又名仓库，英文名`repository`，你可以简单理解成一个目录，这个目录里面的所有文件都可以被`Git`管理起来，每个文件的修改、删除，`Git`都能跟踪，
-以便任何时刻都可以追踪历史，或者在将来某个时刻可以“还原”。
+什么是版本库呢？版本库又名仓库，英文名`repository`，你可以简单理解成一个目录，这个目录里面的所有文件都可以被`Git`管理起来，
+每个文件的修改、删除，`Git`都能跟踪，以便任何时刻都可以追踪历史，或者在将来某个时刻可以“还原”。
 
-所以，创建一个版本库非常简单:   
+所以，创建一个版本库非常简单:
 
 - 创建一个空目录
 - 通过`git init`命令把这个目录变成`Git`可以管理的仓库：
-    瞬间`Git`就把仓库建好了，而且告诉你是一个空的仓库`（empty Git repository）`，细心的读者可以发现当前目录下多了一个`.git`的目录，
-    这个目录是`Git`来跟踪管理版本库的，没事千万不要手动修改这个目录里面的文件，不然改乱了，就把`Git`仓库给破坏了。
+  瞬间`Git`就把仓库建好了，而且告诉你是一个空的仓库`（empty Git repository）`，细心的读者可以发现当前目录下多了一个`.git`的目录，
+  这个目录是`Git`来跟踪管理版本库的，没事千万不要手动修改这个目录里面的文件，不然改乱了，就把`Git`仓库给破坏了。
 - 使用命令`git add <file>`，注意，可反复多次使用，添加多个文件；
 - 使用命令`git commit`，完成。
 
+Git的五种状态
+-------------
 
-Git的五种状态 
----
-
-
-`Git`有五种状态，你的文件可能处于其中之一:     
+`Git`有五种状态，你的文件可能处于其中之一:
 
 - 未修改`(origin)`
 - 已修改`(modified)`
@@ -48,37 +56,34 @@ Git的五种状态
 - 已提交`(committed)`
 - 已推送`(pushed)`
 
-已提交表示数据已经安全的保存在本地数据库中。 已修改表示修改了文件，但还没保存到数据库中。 已暂存表示对一个已修改文件的当前版本做了标记，使之包含在下次提交的快照中。
+已提交表示数据已经安全的保存在本地数据库中。
+已修改表示修改了文件，但还没保存到数据库中。
+已暂存表示对一个已修改文件的当前版本做了标记，使之包含在下次提交的快照中。
 
 `Git`仓库目录是`Git`用来保存项目的元数据和对象数据库的地方。这是`Git`中最重要的部分，从其它计算机克隆仓库时，拷贝的就是这里的数据。
 工作目录是对项目的某个版本独立提取出来的内容。这些从`Git`仓库的压缩数据库中提取出来的文件，放在磁盘上供你使用或修改。
 
 暂存区域是一个文件，保存了下次将提交的文件列表信息，一般在`Git`仓库目录中。 有时候也被称作‘索引’，不过一般说法还是叫暂存区域。
 
-基本的`Git`工作流程如下:     
+基本的`Git`工作流程如下:
 
 - 在工作目录中修改文件。
 - 暂存文件，将文件的快照放入暂存区域。
 - 提交更新，找到暂存区域的文件，将快照永久性存储到`Git`仓库目录。
 
-
 四个区
----
+------
 
-`Git`主要分为四个区:    
+`Git`主要分为四个区:
 
 - 工作区`(Working Area)`
 - 暂存区`(Stage或Index Area)`
 - 本地仓库`(Local Repository)`
 - 远程仓库`(Remote Repository)`
 
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_buzhou.jpg)
 
-
-上面说了`git add`和`git commit`的惭怍，总体分为了三个部分，其实更加详细的来分析，还需要一个`git push`的过程，也就是把更改`push`到远程仓库中。   
-
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_buzhou.jpg)       
-
-正常情况下，我们的工作流程就是三个步骤，分别对应上图中的三个箭头线:    
+正常情况下，我们的工作流程就是三个步骤，分别对应上图中的三个箭头线:
 
 ```shell
 git add . // 把所有文件放入暂存区
@@ -86,12 +91,15 @@ git commit -m "comment"  // 把所有文件从暂存区提交进本地仓库
 git push  // 把所有文件从本地仓库推送进远程仓库
 ```
 
-先上一张图             
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git.png)                  
-图中的`index`部分就是暂存区           
+先上一张图
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git.png)
+
+图中的`index`部分就是暂存区
 
 ## 三棵树
-Git 作为一个系统，是以它的一般操作来管理并操纵这三棵树的：
+
+Git作为一个系统，是以它的一般操作来管理并操纵这三棵树的：
 
 | 树                | 用途                                 |
 | :---------------- | :----------------------------------- |
@@ -101,105 +109,113 @@ Git 作为一个系统，是以它的一般操作来管理并操纵这三棵树
 
 #### HEAD
 
-HEAD 是当前分支引用的指针，它总是指向该分支上的最后一次提交。 这表示 HEAD 将是下一次提交的父结点。 通常，理解 HEAD 的最简方式，就是将它看做 **该分支上的最后一次提交** 的快照。
+HEAD是当前分支引用的指针，它总是指向该分支上的最后一次提交。这表示HEAD将是下一次提交的父结点。通常，理解HEAD的最简方式，
+就是将它看做**该分支上的最后一次提交**的快照。
 
 #### 索引
 
-索引是你的 **预期的下一次提交**。 我们也会将这个概念引用为 Git 的“暂存区”，这就是当你运行 `git commit` 时 Git 看起来的样子。
+索引是你的**预期的下一次提交**。我们也会将这个概念引用为Git的“暂存区”，这就是当你运行`git commit`时Git看起来的样子。
 
 #### 工作目录
 
-最后，你就有了自己的 **工作目录**（通常也叫 **工作区**）。 另外两棵树以一种高效但并不直观的方式，将它们的内容存储在 `.git` 文件夹中。 工作目录会将它们解包为实际的文件以便编辑。 你可以把工作目录当做 **沙盒**。在你将修改提交到暂存区并记录到历史之前，可以随意更改。
+最后，你就有了自己的**工作目录**（通常也叫**工作区**）。 另外两棵树以一种高效但并不直观的方式，将它们的内容存储在`.git`文件夹中。
+工作目录会将它们解包为实际的文件以便编辑。你可以把工作目录当做**沙盒**。在你将修改提交到暂存区并记录到历史之前，可以随意更改。
 
+#### Git目录下文件的状态:
 
-#### Git目录下文件的状态: 
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_file_lifecycle.png?raw=true)你工作目录下的每一个文件都不外乎这两种状态:
 
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_file_lifecycle.png?raw=true)        
-你工作目录下的每一个文件都不外乎这两种状态: 
 - 已跟踪(Tracked)
-    已跟踪的文件是指那些被纳入了版本控制的文件，在上一次快照中有他们的记录，在工作一段时间后，它们的状态可能是未修改，已修改或已放入暂存区。简而言之，已跟踪的文件就是Git已经知道的文件
+  已跟踪的文件是指那些被纳入了版本控制的文件，在上一次快照中有他们的记录，在工作一段时间后，它们的状态可能是未修改，已修改或
+  已放入暂存区。简而言之，已跟踪的文件就是Git已经知道的文件
 - 未跟踪(Untracked)
-    工作目录中除已跟踪文件外的其它所有文件都属于未跟踪文件，它们即不存在与上次快照的记录中，也没有被放入暂存区。
-
+  工作目录中除已跟踪文件外的其它所有文件都属于未跟踪文件，它们即不存在与上次快照的记录中，也没有被放入暂存区。
 
 ## 常用命令
 
 ### git config
-安装好git后我们要先配置一下。以便`git`跟踪。           
-
-    ```
-    git config --global user.name "xxx"            
-    git config --global user.email "xxx@xxx.com"
-    ```
-    上面修改后可以使用`cat ~/.gitconfig`查看                      
-    如果指向修改仓库中的用户名时可以不加`--global`，这样可以用`cat .git/config`来查看             
-    `git config --list`来查看所有的配置。   
-    如果需要查看当前的user.name和user.email的值可以通过`git config user.name`
-
-### git init    
-新建仓库     
-    ```        
-    mkdir gitDemo
-    cd gitDemo
-    git init
-    ```
-    这样就创建完了。
-
-### git clone仓库                 
-    在某一目录下执行.          
-    `git clone [git path]`                                    
-    只是后`Git`会自动把当地仓库的`master`分支和远程仓库的`master`分支对应起来，远程仓库默认的名称是`origin`。
-
-### git add提交文件更改(修改和新增),把当前的修改添加到暂存区                                 
-    `git add xxx.txt`添加某一个文件                
-    `git add .`添加当前目录所有的文件            
-
-### `git commit`提交，把修改由暂存区提交到仓库中                         
-    `git commit`提交，然后在出来的提示框内查看当前提交的内容以及输入注释。          
-    或者也可以用`git commit -m "xxx"` 提交到本地仓库并且注释是xxx      
-    
-    `git commit`是很小的一件事情，但是往往小的事情往往引不起大家的关注，不妨打开公司的任一个`repo`，查看`commit log`，满篇的`update`和`fix`，
-    完全不知道这些`commit`是要做啥。在提交`commit`的时候尽量保证这个`commit`只做一件事情，比如实现某个功能或者修改了配置文件。注意是保证每个`commit`
-    只做一件事，而不是让你做了一件事`commit`后就`push`，那样就有点过分了。  
-
-### `git cherry-pick`          
-    `git cherry-pick`可以选择某一个分支中的一个或几个`commit(s)`来进行操作。例如，假设我们有个稳定版本的分支，叫`v2.0`，另外还有个开发版本的分支`v3.0`，我们不能直接把两个分支合并，这样会导致稳定版本混乱，但是又想增加一个`v3.0`中的功能到`v2.0`中，这里就可以使用`cherry-pick`了。     
-    就是对已经存在的`commit`进行 再次提交；     
-    简单用法:    
-    `git cherry-pick <commit id>`     
-    `git rebase`命令基本是是一个自动化的`cherry-pick`命令。它计算出一系列的提交，然后再以它们在其他地方以同样的顺序一个一个的`cherry-picks`出它们。
-### `git status`查看当前仓库的状态和信息，会提示哪些内容做了改变已经当前所在的分支。              
+
+安装好git后我们要先配置一下。以便`git`跟踪。
+```git config --global user.name "xxx"             git config --global user.email "xxx@xxx.com"```
+上面修改后可以使用`cat ~/.gitconfig`查看
+如果指向修改仓库中的用户名时可以不加`--global`，这样可以用`cat .git/config`来查看
+`git config --list`来查看所有的配置。
+如果需要查看当前的user.name和user.email的值可以通过`git config user.name`
+
+### git init
+
+新建仓库
+``` 
+mkdir gitDemo 
+cd gitDemo 
+git init
+```
+这样就创建完了。
+
+### git clone仓库
+
+在某一目录下执行.
+`git clone [git path]`
+只是后`Git`会自动把当地仓库的`master`分支和远程仓库的`master`分支对应起来，远程仓库默认的名称是`origin`。
+
+### git add提交文件更改(修改和新增),把当前的修改添加到暂存区
+
+`git add xxx.txt`添加某一个文件
+`git add .`添加当前目录所有的文件
+
+### `git commit`提交，把修改由暂存区提交到仓库中
+
+`git commit`提交，然后在出来的提示框内查看当前提交的内容以及输入注释。
+或者也可以用`git commit -m "xxx"` 提交到本地仓库并且注释是xxx
+
+`git commit`是很小的一件事情，但是往往小的事情往往引不起大家的关注，不妨打开公司的任一个`repo`，查看`commit log`，
+满篇的`update`和`fix`，完全不知道这些`commit`是要做啥。在提交`commit`的时候尽量保证这个`commit`只做一件事情，
+比如实现某个功能或者修改了配置文件。注意是保证每个`commit`只做一件事，而不是让你做了一件事`commit`后就`push`，
+那样就有点过分了。
+
+### `git cherry-pick`
+
+`git cherry-pick`可以选择某一个分支中的一个或几个`commit(s)`来进行操作。例如，假设我们有个稳定版本的分支，叫`v2.0`，
+另外还有个开发版本的分支`v3.0`，我们不能直接把两个分支合并，这样会导致稳定版本混乱，但是又想增加一个`v3.0`中的功能到`v2.0`中，
+这里就可以使用`cherry-pick`了。
+就是对已经存在的`commit`进行 再次提交；
+简单用法:
+`git cherry-pick <commit id>`
+`git rebase`命令基本是是一个自动化的`cherry-pick`命令。它计算出一系列的提交，然后再以它们在其他地方以同样的顺序一个一个的`cherry-picks`出它们。
+
+### `git status`查看当前仓库的状态和信息，会提示哪些内容做了改变已经当前所在的分支。
 
 ### `git diff`
 
-    ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_diff.webp?raw=true)        
-    `git diff`直接查看当前修改未add(暂存staged)的差别
-    `git diff --staged`查看已add(到暂存区)的差别                  
-    `git diff HEAD -- xx.txt`查看工作区与版本库最新版的差别。            
-    
-    - 首先如果我们只是本地修改了一个文件，但是还没有执行`git add .`之前，该如何查看有那些修改。这种情况下直接执行`git diff`就可以了。   
-    - 那如果我们执行了`git add .`操作，然后你再执行`git diff`这时就会发现没有任何结果，这时因为`git diff`这个命令只是检查工作区和暂存区之间的差异。    
-    如果我们要查看暂存区和本地仓库之间的差异就需要加一个参数使用`--staged`参数或者`--cached`，`git diff --cached`。这样再执行就可以看到暂存区和本地仓库之间的差异。     
-    - 现在如果我们把修改使用`git commit`从暂存区提交到本地仓库，再看一下差异。这时候再执行`git diff --cached`就会发现没有任何差异。
-如果我们行查看本地仓库和远程仓库的差异，就要换另一个参数，执行`git diff master origin/master`这样就可以看到差异了。 这里面`master`是本地的仓库，而`origin/master`是
-    远程仓库，因为默认都是在主分支上工作，所以两边都是`master`而`origin`代表远程。    
-    
-### `git push` 提交到远程仓库                        
-    可以直接调用`git push`推送到当前分支         
-    或者`git push origin master`推送到远程`master`分支         
-    `git push origin devBranch`推送到远程`devBranch`分支           
-
-### `git log`查看当前分支下的提交记录             
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_diff.webp?raw=true)`git diff`直接查看当前修改未add(暂存staged)的差别
+`git diff --staged`查看已add(到暂存区)的差别`git diff HEAD -- xx.txt`查看工作区与版本库最新版的差别。
+
+- 首先如果我们只是本地修改了一个文件，但是还没有执行`git add .`之前，该如何查看有那些修改。这种情况下直接执行`git diff`就可以了。
+- 那如果我们执行了`git add .`操作，然后你再执行`git diff`这时就会发现没有任何结果，这时因为`git diff`这个命令只是检查工作区和暂存区之间的差异。
+  如果我们要查看暂存区和本地仓库之间的差异就需要加一个参数使用`--staged`参数或者`--cached`，`git diff --cached`。这样再执行就可以看到暂存区和本地仓库之间的差异。
+- 现在如果我们把修改使用`git commit`从暂存区提交到本地仓库，再看一下差异。这时候再执行`git diff --cached`就会发现没有任何差异。
+  如果我们行查看本地仓库和远程仓库的差异，就要换另一个参数，执行`git diff master origin/master`这样就可以看到差异了。 这里面`master`是本地的仓库，而`origin/master`是
+  远程仓库，因为默认都是在主分支上工作，所以两边都是`master`而`origin`代表远程。
+
+### `git push` 提交到远程仓库
+
+可以直接调用`git push`推送到当前分支       
+或者`git push origin master`推送到远程`master`分支       
+`git push origin devBranch`推送到远程`devBranch`分支         
+### `git log`查看当前分支下的提交记录
+
 用`git log`可以查看提交历史，以便确定要回退到哪个版本。
 如果已经使用`git log`查出版本`commit id`后`reset`到某一次提交后，又要重返回来，
-用`git reflog`查看命令历史，以便确定要回到未来的哪个版本。     
+用`git reflog`查看命令历史，以便确定要回到未来的哪个版本。
+
 ```
 git log -p -2 // -p 是仅显示最近的x次提交   
 git log --stat // stat简略的显示每次提交的内容梗概，如哪些文件变更，多少删除，多少添加
 git log --oneline --graph
 git log --grep="1"
 ```
-下面是常用的参数:   
+下面是常用的参数:
+
 - `–-author=“Alex Kras”` ——只显示某个用户的提交任务
 - `–-name-only` ——只显示变更文件的名称
 - `–-oneline`——将提交信息压缩到一行显示
@@ -210,78 +226,90 @@ git log --grep="1"
 - `--grep` ——过滤内容
 
 #### Git日志搜索
+
 如果你想知道某一个东西是什么时候存在或者引入的。git log命令有许多强大的工具可以通过提交信息甚至是diff的内容来找到某个特定的提交。
-例如，如果我们想找到ZLIB_BUF_MAX常量是什么时候引入的，我们可以使用-S选项来显示新增和删除该字符串的提交:   
+例如，如果我们想找到ZLIB_BUF_MAX常量是什么时候引入的，我们可以使用-S选项来显示新增和删除该字符串的提交:
 
 ```shell
 git log -S ZLIB_BUF_MAX --oneline
 ```
-### `git reflog`                
+### `git reflog`
+
 可以查看所有操作记录包括`commit`和`reset`操作以及删除的`commit`记录
 
 ### `git reset`
 
-`git reset`命令用于将当前HEAD复位到指定状态。一般用于撤消之前的一些操作(如:`git add`,`git commit`等)。                 
+`git reset`命令用于将当前HEAD复位到指定状态。一般用于撤消之前的一些操作(如:`git add`,`git commit`等)。
 在`git`的一般使用中，如果发现错误的将不想暂存的文件被`git add`进入索引之后，想回退取消，则可以使用命令:`git reset HEAD <file>`，
-同时`git add`完毕之后，`git`也会做相应的提示，比如:    
+同时`git add`完毕之后，`git`也会做相应的提示，比如:
+
 ```shell
 # Changes to be committed: 
 #   (use "git reset HEAD <file>..." to unstage) 
 # 
 # new file:   test.py
 ```
+`git reset [--hard|soft|mixed|merge|keep] [<commit>或HEAD]`:将当前的分支重设`(reset)`到指定的`<commit>`或者`HEAD`(默认，如果不显示指定`<commit>`，默认是`HEAD`，即最新的一次提交)，并且根据`[mode]`有可能更新索引和工作目录。`mode`的取值可以是`hard、soft、mixed、merged、keep`。下面来详细说明每种模式的意义和效果:
 
-`git reset [--hard|soft|mixed|merge|keep] [<commit>或HEAD]`:将当前的分支重设`(reset)`到指定的`<commit>`或者`HEAD`(默认，如果不显示指定`<commit>`，默认是`HEAD`，即最新的一次提交)，并且根据`[mode]`有可能更新索引和工作目录。`mode`的取值可以是`hard、soft、mixed、merged、keep`。下面来详细说明每种模式的意义和效果:    
-   - `--hard`:彻底回退到某一个版本，本地的源码也会变为上一个版本的内容。重删除工作空间改动代码，撤销commit，撤销git add .。所有变更集都会被丢弃。
-   - `--mixed`:默认方式，它回退到某个版本，只保留源码，不删除工作空间改动代码，撤销commit，并且撤销git add . 。所有变更集都放在工作区。
-   - `--soft`: 回退到某个版本，不删除工作空间改动代码，撤销commit，不撤销git add . ，所有变更集都放在暂存区，如果还要提交直接重新commit即可。     
+- `--hard`:彻底回退到某一个版本，本地的源码也会变为上一个版本的内容。重删除工作空间改动代码，撤销commit，撤销git add .。所有变更集都会被丢弃。
+- `--mixed`:默认方式，它回退到某个版本，只保留源码，不删除工作空间改动代码，撤销commit，并且撤销git add . 。所有变更集都放在工作区。
+- `--soft`: 回退到某个版本，不删除工作空间改动代码，撤销commit，不撤销git add . ，所有变更集都放在暂存区，如果还要提交直接重新commit即可。
 
 #### 示例
 
-假设我们进入到一个新目录，其中有一个文件。 我们称其为该文件的 v1 版本，将它标记为蓝色。 现在运行 git init，这会创建一个 Git 仓库，其中的 HEAD 引用指向未创建的 master 分支。 
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-ex1.png?raw=true)      
+假设我们进入到一个新目录，其中有一个文件。 我们称其为该文件的v1版本，将它标记为蓝色。 
+现在运行git init，这会创建一个Git仓库，其中的HEAD引用指向未创建的master分支。
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-ex1.png?raw=true)
 此时，只有工作目录有内容。
-现在我们想要提交这个文件，所以用git add来获取工作目录中的内容，并将其复制到索引中。 
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-ex2.png?raw=true)        
+现在我们想要提交这个文件，所以用git add来获取工作目录中的内容，并将其复制到索引中。
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-ex2.png?raw=true)
 接着运行git commit，它会取得索引中的内容并将它保存为一个永久的快照，然后创建一个指向该快照的提交对象，最后更新master来指向本次提交。
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-ex3.png?raw=true)        
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-ex3.png?raw=true)
 此时如果我们运行 git status，会发现没有任何改动，因为现在三棵树完全相同。
 
-现在我们想要对文件进行修改然后提交它。 我们将会经历同样的过程；首先在工作目录中修改文件。 我们称其为该文件的 v2 版本，并将它标记为红色。
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-ex4.png?raw=true)        
-如果现在运行 git status，我们会看到文件显示在 “Changes not staged for commit” 下面并被标记为红色，因为该条目在索引与工作目录之间存在不同。 接着我们运行 git add 来将它暂存到索引中。
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-ex5.png?raw=true)        
-此时，由于索引和 HEAD 不同，若运行 git status 的话就会看到 “Changes to be committed” 下的该文件变为绿色 ——也就是说，现在预期的下一次提交与上一次提交不同。 最后，我们运行 git commit 来完成提交。
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-ex6.png?raw=true)        
-现在运行 git status 会没有输出，因为三棵树又变得相同了。
+现在我们想要对文件进行修改然后提交它。 我们将会经历同样的过程；首先在工作目录中修改文件。 我们称其为该文件的v2版本，并将它标记为红色。
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-ex4.png?raw=true)
+如果现在运行git status，我们会看到文件显示在 “Changes not staged for commit” 下面并被标记为红色，因为该条目在索引与工作目录之间存在不同。
+接着我们运行git add来将它暂存到索引中。
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-ex5.png?raw=true)
+此时，由于索引和HEAD不同，若运行git status的话就会看到“Changes to be committed” 下的该文件变为绿色 ——也就是说，现在预期的下一次提交
+与上一次提交不同。 最后，我们运行git commit来完成提交。
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-ex6.png?raw=true)
+现在运行git status会没有输出，因为三棵树又变得相同了。
 
-切换分支或克隆的过程也类似。 当检出一个分支时，它会修改 HEAD 指向新的分支引用，将 索引 填充为该次提交的快照， 然后将 索引 的内容复制到 工作目录 中。
+切换分支或克隆的过程也类似。当检出一个分支时，它会修改HEAD指向新的分支引用，将索引填充为该次提交的快照，
+然后将索引的内容复制到工作目录中。
 
 #### 重置的作用
-在以下情景中观察 reset 命令会更有意义。
 
-为了演示这些例子，假设我们再次修改了 file.txt 文件并第三次提交它。 现在的历史看起来是这样的：
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-start.png?raw=true)        
-让我们跟着 reset 看看它都做了什么。 它以一种简单可预见的方式直接操纵这三棵树。 它做了三个基本操作。
+在以下情景中观察reset命令会更有意义。
+
+为了演示这些例子，假设我们再次修改了file.txt 文件并第三次提交它。 现在的历史看起来是这样的：
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-start.png?raw=true)
+让我们跟着reset看看它都做了什么。它以一种简单可预见的方式直接操纵这三棵树。它做了三个基本操作。
 
 ##### 第 1 步：移动 HEAD
+
 reset 做的第一件事是移动 HEAD 的指向。 这与改变 HEAD 自身不同（checkout 所做的）；reset 移动 HEAD 指向的分支。 这意味着如果 HEAD 设置为 master 分支（例如，你正在 master 分支上）， 运行 git reset 9e5e6a4 将会使 master 指向 9e5e6a4。
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-soft.png?raw=true)        
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-soft.png?raw=true)
 无论你调用了何种形式的带有一个提交的 reset，它首先都会尝试这样做。 使用 reset --soft，它将仅仅停在那儿。
 
 现在看一眼上图，理解一下发生的事情：它本质上是撤销了上一次 git commit 命令。 当你在运行 git commit 时，Git 会创建一个新的提交，并移动 HEAD 所指向的分支来使其指向该提交。 当你将它 reset 回 HEAD~（HEAD 的父结点）时，其实就是把该分支移动回原来的位置，而不会改变索引和工作目录。 现在你可以更新索引并再次运行 git commit 来完成 git commit --amend 所要做的事情了
+
 ##### 第 2 步：更新索引（--mixed）
+
 注意，如果你现在运行 git status 的话，就会看到新的 HEAD 和以绿色标出的它和索引之间的区别。
 
 接下来，reset 会用 HEAD 指向的当前快照的内容来更新索引。
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-mixed.png?raw=true)        
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-mixed.png?raw=true)
 如果指定 --mixed 选项，reset 将会在这时停止。 这也是默认行为，所以如果没有指定任何选项（在本例中只是 git reset HEAD~），这就是命令将会停止的地方。
 
 现在再看一眼上图，理解一下发生的事情：它依然会撤销一上次 提交，但还会 取消暂存 所有的东西。 于是，我们回滚到了所有 git add 和 git commit 的命令执行之前。
 
 ##### 第 3 步：更新工作目录（--hard）
+
 reset 要做的的第三件事情就是让工作目录看起来像索引。 如果使用 --hard 选项，它将会继续这一步。
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-hard.png?raw=true)        
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-hard.png?raw=true)
 现在让我们回想一下刚才发生的事情。 你撤销了最后的提交、git add 和 git commit 命令 以及 工作目录中的所有工作。
 
 必须注意，--hard 标记是 reset 命令唯一的危险用法，它也是 Git 会真正地销毁数据的仅有的几个操作之一。 其他任何形式的 reset 调用都可以轻松撤消，但是 --hard 选项不能，因为它强制覆盖了工作目录中的文件。 在这种特殊情况下，我们的 Git 数据库中的一个提交内还留有该文件的 v3 版本， 我们可以通过 reflog 来找回它。但是若该文件还未提交，Git 仍会覆盖它从而导致无法恢复。
@@ -293,8 +321,8 @@ reset 命令会以特定的顺序重写这三棵树，在你指定以下选项
 - 使索引看起来像 HEAD （若未指定 --hard，则到此停止）
 - 使工作目录看起来像索引
 
-
 ##### 通过路径来重置
+
 前面讲述了 reset 基本形式的行为，不过你还可以给它提供一个作用路径。 若指定了一个路径，reset 将会跳过第 1 步，并且将它的作用范围限定为指定的文件或文件集合。 这样做自然有它的道理，因为 HEAD 只是一个指针，你无法让它同时指向两个提交中各自的一部分。 不过索引和工作目录 可以部分更新，所以重置会继续进行第 2、3 步。
 
 现在，假如我们运行 git reset file.txt （这其实是 git reset --mixed HEAD file.txt 的简写形式，因为你既没有指定一个提交的 SHA-1 或分支，也没有指定 --soft 或 --hard），它会：
@@ -303,19 +331,18 @@ reset 命令会以特定的顺序重写这三棵树，在你指定以下选项
 - 让索引看起来像 HEAD （到此处停止）
 
 所以它本质上只是将 file.txt 从 HEAD 复制到索引中。
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-path1.png?raw=true)        
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-path1.png?raw=true)
 它还有 取消暂存文件 的实际效果。 如果我们查看该命令的示意图，然后再想想 git add 所做的事，就会发现它们正好相反。
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-path2.png?raw=true)        
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-path2.png?raw=true)
 这就是为什么 git status 命令的输出会建议运行此命令来取消暂存一个文件。我们可以不让 Git 从 HEAD 拉取数据，而是通过具体指定一个提交来拉取该文件的对应版本。 我们只需运行类似于 git reset eb43bf file.txt 的命令即可。
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-path3.png?raw=true)        
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-path3.png?raw=true)
 它其实做了同样的事情，也就是把工作目录中的文件恢复到 v1 版本，运行 git add 添加它， 然后再将它恢复到 v3 版本（只是不用真的过一遍这些步骤）。 如果我们现在运行 git commit，它就会记录一条“将该文件恢复到 v1 版本”的更改， 尽管我们并未在工作目录中真正地再次拥有它。
 
 还有一点同 git add 一样，就是 reset 命令也可以接受一个 --patch 选项来一块一块地取消暂存的内容。 这样你就可以根据选择来取消暂存或恢复内容了。
 
+### `git checkout`撤销修改或者切换分支
 
-
-### `git checkout`撤销修改或者切换分支           
-`git checkout -- xx.txt`意思就是将`xx.txt`文件在工作区的修改全部撤销。可能会有两种情况:      
+`git checkout -- xx.txt`意思就是将`xx.txt`文件在工作区的修改全部撤销。可能会有两种情况:
 
 - 修改后还没有调用`git add`添加到暂存区，现在撤销后就会和版本库一样的状态。
 - 修改后已经调用`git add`添加到暂存区后又做了修改，这时候撤销就会回到暂存区的状态。
@@ -323,50 +350,47 @@ reset 命令会以特定的顺序重写这三棵树，在你指定以下选项
 总的来说`git checkout`就是让这个文件回到最近一次`git commit`或者`git add`的状态。
 这里还有一个问题就是我胡乱修改了某个文件内容然后调用了`git add`添加到缓存区中，这时候想丢弃修改该怎么办？也是要分两步:
 
-- 使用`git reset HEAD file`命令，将暂存区中的内容回退，这样修改的内容会从暂存区回到工作区。             
-- 使用`git checkout --file`直接丢弃工作区的修改。            
+- 使用`git reset HEAD file`命令，将暂存区中的内容回退，这样修改的内容会从暂存区回到工作区。
+- 使用`git checkout --file`直接丢弃工作区的修改。
 
-`git checkout`把当前目录所有修改的文件从`HEAD`都撤销修改。        
+`git checkout`把当前目录所有修改的文件从`HEAD`都撤销修改。
 为什么分支的地方也是用`git checkout`这里撤销还是用它呢？他们的区别在于`--`，如果没有`--`那就是检出分支了。
-`git checkout origin/developer`  // 切换到orgin/developer分支   
-
-上面介绍了两个回退操作`git reset`和`git checkout`，这里就总结一下如何来对修改进行撤销操作:     
+`git checkout origin/developer`  // 切换到orgin/developer分支
 
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_reset_checkout.png?raw=true)        
+上面介绍了两个回退操作`git reset`和`git checkout`，这里就总结一下如何来对修改进行撤销操作:
 
-- 已经修改，但是并未执行`git add .`进行暂存        
-    如果只是修改了本地文件，但是还没有执行`git add .`这时候我们的修改还是再工作区，并未进入暂存区，我们可以使用:`git checkouot .`或者`git reset --hard`来进行
-    撤销操作。   
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_reset_checkout.png?raw=true)
 
-    `git add .`的反义词是`git checkout .`做完修改后，如果想要向前一步，让修改进入暂存区执行`git add .`如果想退后一步，撤销修改就执行`git checkout .`。   
+- 已经修改，但是并未执行`git add .`进行暂存
+  如果只是修改了本地文件，但是还没有执行`git add .`这时候我们的修改还是再工作区，并未进入暂存区，我们可以使用:`git checkouot .`或者`git reset --hard`来进行
+  撤销操作。
 
-- 已暂存，未提交    
-    如果已经执行了`git add .`但是还没有执行`git commit -m "comment"`这时候你意识到了错误，想要撤销，可以执行:      
+  `git add .`的反义词是`git checkout .`做完修改后，如果想要向前一步，让修改进入暂存区执行`git add .`如果想退后一步，撤销修改就执行`git checkout .`。
+- 已暂存，未提交
+  如果已经执行了`git add .`但是还没有执行`git commit -m "comment"`这时候你意识到了错误，想要撤销，可以执行:
 
-    ```
-    git reset   // git reset 只是把修改退回到了git add .之前的状态，也就是让文件还处于已修改未暂存的状态
-    git checkout .   // 上面让文件处于已修改未暂存的状态，还要执行git checkout .来撤销工作区的状态
-    ```
-    或`git reset --hard`
+  ```
+  git reset   // git reset 只是把修改退回到了git add .之前的状态，也就是让文件还处于已修改未暂存的状态
+  git checkout .   // 上面让文件处于已修改未暂存的状态，还要执行git checkout .来撤销工作区的状态
+  ```
+  或`git reset --hard`
 
-    上面两个例子中都使用了`git reset --hard`这个命令也可以完成，这个命令可以一步到位的把你的修改完全恢复到本地仓库的未修改的状态。     
+  上面两个例子中都使用了`git reset --hard`这个命令也可以完成，这个命令可以一步到位的把你的修改完全恢复到本地仓库的未修改的状态。
+- 已提交，未推送
+  如果执行了`git add .`又执行了`git commit -m "comment"`提交了代码，这时候代码已经进入到了本地仓库，然而你发现问题了，想要撤销，怎么办？
+  执行`git reset --hard origin/master`还是`git reset --hard`命令，只不过这次多了一个参数`origin/master`，这代表远程仓库，既然本地仓库已经有了
+  你提交的脏代码，那么就从远程仓库中把代码恢复把。
 
-- 已提交，未推送  
-    如果执行了`git add .`又执行了`git commit -m "comment"`提交了代码，这时候代码已经进入到了本地仓库，然而你发现问题了，想要撤销，怎么办？   
-    执行`git reset --hard origin/master`还是`git reset --hard`命令，只不过这次多了一个参数`origin/master`，这代表远程仓库，既然本地仓库已经有了
-    你提交的脏代码，那么就从远程仓库中把代码恢复把。   
+  但是上面这样会导致你之前修改的代码都没有了，如果我只是想撤回提交，还想要我之前修改的东西重新回到本地仓库呢？
+  `git reset --soft HEAD^`，这样就成功的撤销了你的commit。注意，仅仅是撤回commit操作，您写的代码仍然保留。
+- 已推送到远程仓库
+  如果你执行`git add .`后又`commit`又执行了`git push`操作了，这时候你的代码已经进入到了远程仓库中，如果你发现你提交的代码又问题想恢复的话，那你只能先把本地仓库的
+  代码恢复，然后再强制执行`git push`仓做，`push`到远程仓库就可以了。
 
-    但是上面这样会导致你之前修改的代码都没有了，如果我只是想撤回提交，还想要我之前修改的东西重新回到本地仓库呢？ 
-    `git reset --soft HEAD^`，这样就成功的撤销了你的commit。注意，仅仅是撤回commit操作，您写的代码仍然保留。
-
-- 已推送到远程仓库  
-    如果你执行`git add .`后又`commit`又执行了`git push`操作了，这时候你的代码已经进入到了远程仓库中，如果你发现你提交的代码又问题想恢复的话，那你只能先把本地仓库的
-    代码恢复，然后再强制执行`git push`仓做，`push`到远程仓库就可以了。    
-    
-    ```
-    git reset --hard HEAD^  // HEAD^代表最新提交的前一次  
-    git push -f  // 强制推送
-    ```
+  ```
+  git reset --hard HEAD^  // HEAD^代表最新提交的前一次  
+  git push -f  // 强制推送
+  ```
 
 ### reset checkout的区别
 
@@ -375,31 +399,40 @@ reset 命令会以特定的顺序重写这三棵树，在你指定以下选项
 不带路径
 运行 git checkout [branch] 与运行 git reset --hard [branch] 非常相似，它会更新所有三棵树使其看起来像 [branch]，不过有两点重要的区别。
 
-首先不同于 reset --hard，checkout 对工作目录是安全的，它会通过检查来确保不会将已更改的文件弄丢。 其实它还更聪明一些。它会在工作目录中先试着简单合并一下，这样所有 还未修改过的 文件都会被更新。 而 reset --hard 则会不做检查就全面地替换所有东西。
+首先不同于 reset --hard，checkout 对工作目录是安全的，它会通过检查来确保不会将已更改的文件弄丢。 其实它还更聪明一些。它会在工作目录中先试着
+简单合并一下，这样所有 还未修改过的 文件都会被更新。 而 reset --hard 则会不做检查就全面地替换所有东西。
 
 第二个重要的区别是 checkout 如何更新 HEAD。 reset 会移动 HEAD 分支的指向，而 checkout 只会移动 HEAD 自身来指向另一个分支。
 
-例如，假设我们有 master 和 develop 分支，它们分别指向不同的提交；我们现在在 develop 上（所以 HEAD 指向它）。 如果我们运行 git reset master，那么 develop 自身现在会和 master 指向同一个提交。 而如果我们运行 git checkout master 的话，develop 不会移动，HEAD 自身会移动。 现在 HEAD 将会指向 master。
+例如，假设我们有 master 和 develop 分支，它们分别指向不同的提交；我们现在在 develop 上（所以 HEAD 指向它）。
+如果我们运行 git reset master，那么 develop 自身现在会和 master 指向同一个提交。 而如果我们运行 git checkout master 的话，
+develop 不会移动，HEAD 自身会移动。 现在 HEAD 将会指向 master。
+
+所以，虽然在这两种情况下我们都移动 HEAD 使其指向了提交 A，但做法是非常不同的。 reset 会移动 HEAD 分支的指向，而checkout则移动
+HEAD自身。
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-checkout.png?raw=true)
 
-所以，虽然在这两种情况下我们都移动 HEAD 使其指向了提交 A，但 做法 是非常不同的。 reset 会移动 HEAD 分支的指向，而 checkout 则移动 HEAD 自身。
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-checkout.png?raw=true)        
 #### 带路径
+
 运行 checkout 的另一种方式就是指定一个文件路径，这会像 reset 一样不会移动 HEAD。 它就像 git reset [branch] file 那样用该次提交中的那个文件来更新索引，但是它也会覆盖工作目录中对应的文件。 它就像是 git reset --hard [branch] file（如果 reset 允许你这样运行的话）， 这样对工作目录并不安全，它也不会移动 HEAD。
 
 此外，同 git reset 和 git add 一样，checkout 也接受一个 --patch 选项，允许你根据选择一块一块地恢复文件内容。
 
-### `git revert`撤销提交   
+### `git revert`撤销提交
+
 `git revert`在撤销一个提交的同时会创建一个新的提交，这是一个安全的方法，因为它不会重写提交历史。
 
 - `git revert`是生成一个新的提交来撤销某次提交，此次提交之前的`commit`都会被保留
-- `git reset`是回到某次提交，提交及之前的`commit`都会被保留，但是此次之后的修改都会被退回到暂存区     
+- `git reset`是回到某次提交，提交及之前的`commit`都会被保留，但是此次之后的修改都会被退回到暂存区
 
 相比`git reset`它不会改变现在得提交历史。`git reset`是直接删除制定的`commit`
 并把`HEAD`向后移动了一下。而`git revert`是一次新的特殊的`commit`，`HEAD`继续前进，本质和普通`add commit`一样，仅仅是`commit`内容很特殊。内容是与前面普通`commit`变化的反操作。
 比如前面普通`commit`是增加一行`a`，那么`revert`内容就是删除一行`a`。
-在 Git 开发中通常会控制主干分支的质量，但有时还是会把错误的代码合入到远程主干。 虽然可以直接回滚远程分支， 但有时新的代码也已经合入，直接回滚后最近的提交都要重新操作。 那么有没有只移除某些 Commit 的方式呢？可以一次 revert操作来完成。
+在 Git 开发中通常会控制主干分支的质量，但有时还是会把错误的代码合入到远程主干。虽然可以直接回滚远程分支，但有时新的代码也已经合入，
+直接回滚后最近的提交都要重新操作。 那么有没有只移除某些Commit的方式呢？可以用一次revert操作来完成。
 
 考虑这个例子，我们提交了 6 个版本，其中 3-4 包含了错误的代码需要被回滚掉。 同时希望不影响到后续的 5-6。
+
 ```shell
 * 982d4f6 (HEAD -> master) version 6
 * 54cc9dc version 5
@@ -408,18 +441,23 @@ reset 命令会以特定的顺序重写这三棵树，在你指定以下选项
 * f7742cd version 2
 * 6c4db3f version 1
 ```
-这种情况在团队协作的开发中会很常见：可能是流程或认为原因不小心合入了错误的代码， 也可能是合入一段时间后才发现存在问题。 总之已经存在后续提交，使得直接回滚不太现实。
+这种情况在团队协作的开发中会很常见：可能是流程或认为原因不小心合入了错误的代码，也可能是合入一段时间后才发现存在问题。
+总之已经存在后续提交，使得直接回滚不太现实。
+
+下面的部分就开始介绍具体操作了，同时我们假设远程分支是受保护的（不允许 Force Push）。思路是从产生一个新的 Commit 撤销之前的错误提交。
 
-下面的部分就开始介绍具体操作了，同时我们假设远程分支是受保护的（不允许 Force Push）。 思路是从产生一个新的 Commit 撤销之前的错误提交。
+使用 git revert <commit> 可以撤销指定的提交， 要撤销一串提交可以用 <commit1>..<commit2> 语法。 注意这是一个前开后闭区间，
+即不包括commit1，但包括commit2。
 
-使用 git revert <commit> 可以撤销指定的提交， 要撤销一串提交可以用 <commit1>..<commit2> 语法。 注意这是一个前开后闭区间，即不包括 commit1，但包括 commit2。
 ```shell
 git revert --no-commit f7742cd..551c408
 git commit -a -m 'This reverts commit 7e345c9 and 551c408'
 ```
-其中 f7742cd 是 version 2，551c408 是 version 4，这样被移除的是 version 3 和 version 4。 注意 revert 命令会对每个撤销的 commit 进行一次提交，--no-commit 后可以最后一起手动提交。
+其中 f7742cd 是 version 2，551c408 是 version 4，这样被移除的是 version 3 和 version 4。 
+注意 revert 命令会对每个撤销的 commit 进行一次提交，--no-commit 后可以最后一起手动提交。
 
 此时 Git 记录是这样的：
+
 ```shell
 * 8fef80a (HEAD -> master) This reverts commit 7e345c9 and 551c408
 * 982d4f6 version 6
@@ -431,24 +469,29 @@ git commit -a -m 'This reverts commit 7e345c9 and 551c408'
 ```
 现在的 HEAD（8fef80a）就是我们想要的版本，把它 Push 到远程即可。
 
-git revert 命令本质上就是一个逆向的 git cherry-pick 操作。 它将你提交中的变更的以完全相反的方式的应用到一个新创建的提交中，本质上就是撤销或者倒转。
+git revert 命令本质上就是一个逆向的 git cherry-pick 操作。 它将你提交中的变更的以完全相反的方式的应用到一个新创建的提交中，
+本质上就是撤销或者倒转。
+
+### `git rm`删除文件
 
-### `git rm`删除文件     
 该文件就不再纳入版本管理了。如果删除之前修改过并且已经放到暂存区域的话，则必须要用强制删除选项 -f（译注：即 force 的首字母），以防误删除文件后丢失修改的内容。
-另外一种情况是，我们想把文件从 Git 仓库中删除（亦即从暂存区域移除），但仍然希望保留在当前工作目录中。换句话说，仅是从跟踪清单中删除。比如一些大型日志文件或者一堆 .a 编译文件，不小心纳入仓库后，要移除跟踪但不删除文件，以便稍后在 .gitignore 文件中补上，用 --cached 选项即可：`git rm --cached readme.txt`   
+另外一种情况是，我们想把文件从 Git 仓库中删除（亦即从暂存区域移除），但仍然希望保留在当前工作目录中。换句话说，仅是从跟踪清单中删除。
+比如一些大型日志文件或者一堆 .a 编译文件，不小心纳入仓库后，要移除跟踪但不删除文件，以便稍后在 .gitignore 文件中补上，
+用 --cached 选项即可：`git rm --cached readme.txt`
+
+### 分支
 
-### 分支                   
-`git`分支的创建和合并都是非常快的，因为增加一个分支其实就是增加一个指针，合并其实就是让某个分支的指针指向某一个位置。        
- ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_master_branch.png?raw=true) 
+`git`分支的创建和合并都是非常快的，因为增加一个分支其实就是增加一个指针，合并其实就是让某个分支的指针指向某一个位置。
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_master_branch.png?raw=true)
 
-#### 创建分支                   
+#### 创建分支
 
-`git branch devBranch`创建名为`devBranch`的分支。          
-`git checkout devBranch`切换到`devBranch`分支。            
+`git branch devBranch`创建名为`devBranch`的分支。
+`git checkout devBranch`切换到`devBranch`分支。
 `git checkout -b devBranch`创建+切换到分支`devBranch`。
-`git branch`查看当前仓库中的分支。                   
+`git branch`查看当前仓库中的分支。
 `git branch -r`查看远程仓库的分支。
-`git branch -d devBranch`删除`devBranch`分支。            
+`git branch -d devBranch`删除`devBranch`分支。
 
 ```
 origin/HEAD -> origin/master
@@ -458,15 +501,18 @@ origin/master
 origin/master_sg
 origin/offline
 ```
-`git branch -d devBranch`删除`devBranch`分支。           
-当时如果在新建了一个分支后进行修改但是还没有合并到其他分支的时候就去使用`git branch -d xxx`删除的时候系统会手提示说这个分支没有被合并，删除失败。
+`git branch -d devBranch`删除`devBranch`分支。
+当时如果在新建了一个分支后进行修改但是还没有合并到其他分支的时候就去使用`git branch -d xxx`删除的时候系统会手提示说这个分支没有
+被合并，删除失败。
 这时如果你要强行删除的话可以使用命令`git branch -D xxx`.
 如何删除远程分支呢？
+
 ```
 git branch -r -d origin/developer
 git push origin :developer
 ```
 如何本地创建分支并推送给远程仓库？
+
 ```
 // 本地创建分支
 git checkout master //进入master分支
@@ -474,43 +520,39 @@ git checkout -b frommaster //以master为源创建分支frommaster
 // 推送到远程仓库
 git push origin frommaster// 推送到远程仓库所要使用的名字
 ```
-
-如何切到到远程仓库分支进行开发呢？         
+如何切到到远程仓库分支进行开发呢？
 `git checkout -b frommaster origin/frommaster`
 // 本地新建frommaster分支并且与远程仓库的frommaster分支想关联
-提交更改的话就用 
+提交更改的话就用
 `git push origin frommaster`
 
-// 重命名分支    
+// 重命名分支
 `git branch -m new_branch wchar_support`
 // 查看每一个分支的最后一次提交
 `git branch -v`
 
 #### `git merge`合并指定分支到当前分支
 
-`git merge devBranch`将`devBranch`分支合并到`master`。          
+`git merge devBranch`将`devBranch`分支合并到`master`。
 
-### 打`tag`                   
-`git tag v1.0`来进行打`tag`，默认为`HEAD`             
-`git tag`查看所有`tag`          
-如果我想在之前提交的某次`commit`上打`tag`，`git tag v1.0 commitID`     
+### 打`tag`
+
+`git tag v1.0`来进行打`tag`，默认为`HEAD`
+`git tag`查看所有`tag`
+如果我想在之前提交的某次`commit`上打`tag`，`git tag v1.0 commitID`
 当然也可以在打`tag`时带上参数 `git tag v1.0 -m "version 1.0 released" commitID`
 `git tag -d xxx`删除xxx
 
-`git show tagName`来查看某`tag`的详细信息。          
-
-
-- 打完`tag`后怎么推送到远程仓库         
-    `git push origin tagName`      
+`git show tagName`来查看某`tag`的详细信息。
 
-- 删除`tag`        
-    `git tag -d tagName`      
-
-- 删除完`tag`后怎么推送到远程仓库，这个写法有点复杂                  
-    `git push origin:refs/tags/tagName` 
-
-- 忽略文件                
-    在`git`根目录下创建一个特殊的`.gitignore`文件，把想要忽略的文件名填进去就可以了,匹配模式最后跟斜杠(/)说明要忽略的是目录,#是注释 。
+- 打完`tag`后怎么推送到远程仓库
+  `git push origin tagName`
+- 删除`tag`
+  `git tag -d tagName`
+- 删除完`tag`后怎么推送到远程仓库，这个写法有点复杂
+  `git push origin:refs/tags/tagName`
+- 忽略文件
+  在`git`根目录下创建一个特殊的`.gitignore`文件，把想要忽略的文件名填进去就可以了,匹配模式最后跟斜杠(/)说明要忽略的是目录,#是注释 。
 
 ### amend修改最后一次提交
 
@@ -524,12 +566,16 @@ $ git commit --amend --no-edit
 
 #### 修改多个提交信息
 
-为了修改在提交历史中较远的提交，必须使用更复杂的工具。 Git 没有一个改变历史工具，但是可以使用变基工具来变基一系列提交，基于它们原来的 HEAD 而不是将其移动到另一个新的上面。 通过交互式变基工具，可以在任何想要修改的提交后停止，然后修改信息、添加文件或做任何想做的事情。 可以通过给 git rebase 增加 -i 选项来交互式地运行变基。 必须指定想要重写多久远的历史，这可以通过告诉命令将要变基到的提交来做到。
+为了修改在提交历史中较远的提交，必须使用更复杂的工具。 Git 没有一个改变历史工具，但是可以使用变基工具来变基一系列提交，
+基于它们原来的 HEAD 而不是将其移动到另一个新的上面。 通过交互式变基工具，可以在任何想要修改的提交后停止，然后修改信息、添加文件或
+做任何想做的事情。 可以通过给 git rebase 增加 -i 选项来交互式地运行变基。 必须指定想要重写多久远的历史，这可以通过告诉命令将要变
+基到的提交来做到。
 
 例如，如果想要修改最近三次提交信息，或者那组提交中的任意一个提交信息， 将想要修改的最近一次提交的父提交作为参数传递给 git rebase -i 命令，即 HEAD~2^ 或 HEAD~3。 记住 ~3 可能比较容易，因为你正尝试修改最后三次提交；但是注意实际上指定了以前的四次提交，即想要修改提交的父提交：
 
 $ git rebase -i HEAD~3
-再次记住这是一个变基命令——在 HEAD~3..HEAD 范围内的每一个修改了提交信息的提交及其 所有后裔 都会被重写。 不要涉及任何已经推送到中央服务器的提交——这样做会产生一次变更的两个版本，因而使他人困惑。
+再次记住这是一个变基命令——在 HEAD~3..HEAD 范围内的每一个修改了提交信息的提交及其 所有后裔 都会被重写。
+不要涉及任何已经推送到中央服务器的提交——这样做会产生一次变更的两个版本，因而使他人困惑。
 输入
 
 $ git commit --amend
@@ -539,26 +585,25 @@ $ git rebase --continue
 这个命令将会自动地应用另外两个提交，然后就完成了。 如果需要将不止一处的 pick 改为 edit，需要在每一个修改为 edit 的提交上重复这些步骤。 每一次，Git 将会停止，让你修正提交，然后继续直到完成。
 
 ### 查看远程仓库克隆地址
-`git remote -v`
 
-关于`git`的工作区、缓存区可以看下图`index`标记部分的区域就是暂存区                     
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_stage.jpg?raw=true)         
+`git remote -v`
 
-从这个图中能看到缓存区的存在，这就是为什么我们新加或者修改之后都要调用`git add`方法后再调用`git commit`。              
+关于`git`的工作区、缓存区可以看下图`index`标记部分的区域就是暂存区
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_stage.jpg?raw=true)
 
+从这个图中能看到缓存区的存在，这就是为什么我们新加或者修改之后都要调用`git add`方法后再调用`git commit`。
 
 ### stash(贮藏)
 
 stash会处理工作目录的脏的文件--即跟踪文件的修改与暂存的改动--然后将未完成的修改保存到一个栈上，而你可以在任何时候重新应用这些改动（甚至在不同的分支上）。
-假设你现在在`a`分支上开发新版本内容，已经开发了一部分，但是还没有达到可以提交的程度。你需要切换到`b`分支进行另一个升级的开发。那么可以把当前工作的改变隐藏起来，要将一个新的存根推到堆栈上，运行`git stash`命令。   
+假设你现在在`a`分支上开发新版本内容，已经开发了一部分，但是还没有达到可以提交的程度。你需要切换到`b`分支进行另一个升级的开发。那么可以把当前工作的改变隐藏起来，要将一个新的存根推到堆栈上，运行`git stash`命令。
 
 ```shell
 $ git stash
 Saved working directory and index state WIP on master: ef07ab5 synchronized with the remote repository
 HEAD is now at ef07ab5 synchronized with the remote repository
 ```
-
-现在，工作目录是干净的，所有更改都保存在堆栈中。 现在使用`git status`命令来查看当前工作区状态:   
+现在，工作目录是干净的，所有更改都保存在堆栈中。 现在使用`git status`命令来查看当前工作区状态:
 
 ```shell
 $ git status
@@ -567,95 +612,122 @@ Your branch is up-to-date with 'origin/master'.
 
 nothing to commit, working directory clean
 ```
-
 现在，可以安全地切换分支并在其他地方工作。通过使用`git stash list`命令来查看已存在更改的列表。
 
 ```shell
 $ git stash list
 stash@{0}: WIP on master: ef07ab5 synchronized with the remote repository
 ```
-
-这个命令所储藏的修改可以使用`git stash list`列出，使用`git stash show`进行检查，并使用`git stash apply`或`git stash apply stash@{2}`恢复(可能在不同的提交之上)。或者可以用git stash pop将最近的一次stash恢复。调用没有任何参数的`git stash`相当于`git stash save`。在17年10月下旬Git讨论废弃了git stash save命令，代之以现有的git stash push命令。
+这个命令所储藏的修改可以使用`git stash list`列出，使用`git stash show`进行检查，并使用`git stash apply`
+或`git stash apply stash@{2}`恢复(可能在不同的提交之上)。或者可以用git stash pop将最近的一次stash恢复。调用没有任何参数
+的`git stash`相当于`git stash save`。在17年10月下旬Git讨论废弃了git stash save命令，代之以现有的git stash push命令。
 可以使用git stash drop加上要移除的贮藏的名字来移除它。
 
+### 区间提交
 
+你想要查看 experiment 分支中还有哪些提交尚未被合并入 master 分支。 你可以使用 master..experiment 来让 Git 显示这些提交。也就是“在 experiment 分支中而不在 master 分支中的提交”。
 
-### 区间提交
-你想要查看 experiment 分支中还有哪些提交尚未被合并入 master 分支。 你可以使用 master..experiment 来让 Git 显示这些提交。也就是“在 experiment 分支中而不在 master 分支中的提交”。 
 ```shell
 git log master..experiment
 ```
 #### 三点
+
 这个语法可以选择出被两个引用 之一 包含但又不被两者同时包含的提交。 再看看之前双点例子中的提交历史。 如果你想看 master 或者 experiment 中包含的但不是两者共有的提交，你可以执行：
+
 ```shell
 git log master...experiment
 ```
-
-
 ### Rebase操作
+
 官网中将rebase翻译为变基，我感觉理解成改变基点，重新实现更容易理解一些。
-假设目前除master分支之外还有一个experiment分支: 
+假设目前除master分支之外还有一个experiment分支:
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/basic-rebase-1.png?raw=true)
+我们现在想要把master分支merge一下experiment分支的最新代码。整合分支最容易的方法是merge命令。它会把这两个分支的最新快照(C3和C4)以及两者
+最近的共同祖先(C2)进行三方合并，合并的结果是生成一个新的快照(C5)并提交。
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/basic-rebase-2.png?raw=true)
+其实，还有一种方法：你可以提取在C4中引入的补丁和修改，然后在C3的基础上应用一次。在Git中，这种操作就叫做变基(rebase)。
+你可以使用rebase命令将提交到某一分支上的所有修改都移至另一分支上，就好像“重新播放”一样。
+在这个例子中，你可以检出experiment分支，然后将它变基到master分支上:
 
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/basic-rebase-1.png?raw=true)        
-我们现在想要把master分支merge一下experiment分支的最新代码。整合分支最容易的方法是merge命令。它会把这两个分支的最新快照(C3和C4)以及两者最近的共同祖先(C2)进行三方合并，合并的结果是生成一个新的快照(C5)并提交。
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/basic-rebase-2.png?raw=true)        
-其实，还有一种方法：你可以提取在C4中引入的补丁和修改，然后在C3的基础上应用一次。在Git中，这种操作就叫做变基(rebase)。你可以使用rebase命令将提交到某一分支上的所有修改都移至另一分支上，就好像“重新播放”一样。
-在这个例子中，你可以检出experiment分支，然后将它变基到master分支上:  
 ```shell
 git checkout experiment
 git rebase master
 ```
-它的原理是首先找到这两个分支(即当前分支experiment、变基操作的目标基底分支master)的最近共同祖先C2，然后对比当前分支相对于该祖先的历次提交，提取相应的修改并存为临时文件，然后将当前分支指向目标基底C3，最后以此将之前另存为临时文件的修改依序引用。
-![将C4中的修改变基到C3上](https://raw.githubusercontent.com/CharonChui/Pictures/master/basic-rebase-3.png?raw=true)        
+它的原理是首先找到这两个分支(即当前分支experiment、变基操作的目标基底分支master)的最近共同祖先C2，然后对比当前分支相对于该祖
+先的历次提交，提取相应的修改并存为临时文件，然后将当前分支指向目标基底C3，最后以此将之前另存为临时文件的修改依序引用。
+![将C4中的修改变基到C3上](https://raw.githubusercontent.com/CharonChui/Pictures/master/basic-rebase-3.png?raw=true)
 现在回到master分支，进行一次快进合并。
+
 ```shell
 git checkout master
 git merge experiment
 ```
-![master分支的快进合并](https://raw.githubusercontent.com/CharonChui/Pictures/master/basic-rebase-4.png?raw=true)        
-此时C4'指向的快照就和上面直接用merge中的C5指向的快照一模一样了。这两种整合方法的最终结果没有任何区别，但是变基使得提交历史更加整洁。你在查看一个经过变基的分支的历史记录时会发现，尽管实际的开发工作是并行的，但它们看上去就像是串行的一样，提交历史是一条直线没有分叉。
-一般我们这样做的目的是为了确保在向远程分支推送时能保持提交历史的整洁--例如向某个他人维护的项目贡献代码时。在这种情况下，你首先在自己的分支里进行开发，当开发完成时你需要先将你的代码变基到orgin/master上，然后再向主项目提交修改。这样的话，该项目的维护者就不再需要进行整合工作，只需要快进合并即可。
-请注意，无论是通过变基，还是通过三方合并，整合的最终结果所指向的快照始终是一样的，只不过提交历史不同罢了。变基是将一系列提交按照原有次序依次应用到另一分支上，而合并是把最终结果合在一起。
+![master分支的快进合并](https://raw.githubusercontent.com/CharonChui/Pictures/master/basic-rebase-4.png?raw=true)
+此时C4'指向的快照就和上面直接用merge中的C5指向的快照一模一样了。这两种整合方法的最终结果没有任何区别，但是变基使得提交历史更加整洁。
+你在查看一个经过变基的分支的历史记录时会发现，尽管实际的开发工作是并行的，但它们看上去就像是串行的一样，提交历史是一条直线没有分叉。
+一般我们这样做的目的是为了确保在向远程分支推送时能保持提交历史的整洁--例如向某个他人维护的项目贡献代码时。在这种情况下，你首先在自己
+的分支里进行开发，当开发完成时你需要先将你的代码变基到orgin/master上，然后再向主项目提交修改。这样的话，该项目的维护者就不再需要
+进行整合工作，只需要快进合并即可。
+请注意，无论是通过变基，还是通过三方合并，整合的最终结果所指向的快照始终是一样的，只不过提交历史不同罢了。变基是将一系列提交按照原有
+次序依次应用到另一分支上，而合并是把最终结果合在一起。
 
 ##### 更有趣的变基例子
-在对两个分支进行变基时，所生成的“重放”并不一定要在目标分支上应用，你也可以指定另外的一个分支进行应用。假如你创建了一个主题分支server，为服务端添加了一些功能，提交了C3和C4.然后从C3上创建了主题分支client，为客户端添加了一些功能，提交了C8和C9.最后，你回到server分支，又提交了C10.
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/interesting-rebase-1.png?raw=true)        
-假设你希望将client中的修改合并到主分支并发布，但暂时并不想合并server中的修改，因为他们还需要经过更全面的测试。这时，你就可以使用git rebase命令的--onto选项，选中在client分支里但不在server分支里的修改(即C8和C9)，将它们在master分支上重放: `git rebase --onto master server client`
-以上命令的意思是：取出client分支，找出它从server分支分歧之后的补丁，然后把这些补丁在master分支上重放一遍，让client看起来像直接基于master修改一样。
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/interesting-rebase-2.png?raw=true)        
+
+在对两个分支进行变基时，所生成的“重放”并不一定要在目标分支上应用，你也可以指定另外的一个分支进行应用。假如你创建了一个主题分支server，
+为服务端添加了一些功能，提交了C3和C4.然后从C3上创建了主题分支client，为客户端添加了一些功能，提交了C8和C9.最后，你回到server分支，
+又提交了C10.
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/interesting-rebase-1.png?raw=true)
+假设你希望将client中的修改合并到主分支并发布，但暂时并不想合并server中的修改，因为他们还需要经过更全面的测试。这时，你就可以使用
+git rebase命令的--onto选项，选中在client分支里但不在server分支里的修改(即C8和C9)，
+将它们在master分支上重放: `git rebase --onto master server client`
+以上命令的意思是：取出client分支，找出它从server分支分歧之后的补丁，然后把这些补丁在master分支上重放一遍，让client看起来像直接
+基于master修改一样。
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/interesting-rebase-2.png?raw=true)
 现在可以快速合并master分支了(快速合并master分支，使之包含来自client分支的修改)：
+
 ```shell
 git checkout master
 git merge client
 ```
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/interesting-rebase-3.png?raw=true)        
-接下来你决定将server分支中的修改也整合进来，使用git rebase <basebranch> <topicbranch>命令可以直接将主题分支(即这里的server)变基到基分支(即这里的master)上。这样做能省去你先切换到server分支，再对其进行变基命令的多个步骤。
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/interesting-rebase-3.png?raw=true)
+接下来你决定将server分支中的修改也整合进来，使用git rebase <basebranch> <topicbranch>命令可以直接将主题分支
+(即这里的server)变基到基分支(即这里的master)上。这样做能省去你先切换到server分支，再对其进行变基命令的多个步骤。
 `git rebase master server`
 如下图，将server中的修改变基到master上所示，server中的代码被“续”到了master后面。
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/interesting-rebase-4.png?raw=true)        
-然后就可以快进合并主分支master了: 
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/interesting-rebase-4.png?raw=true)
+然后就可以快进合并主分支master了:
+
 ```shell
 git checkout master
 git merge server
 ```
-至此，client和server分支中的修改都已经整合到主分支里了，你可以删除这两个分支，最终提交历史会变成下图的样子: 
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/interesting-rebase-5.png?raw=true)        
+至此，client和server分支中的修改都已经整合到主分支里了，你可以删除这两个分支，最终提交历史会变成下图的样子:
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/interesting-rebase-5.png?raw=true)
 
 ##### 变基的风险
-奇妙的变基也并非完美无缺，要用它得遵守一条准则： 
+
+奇妙的变基也并非完美无缺，要用它得遵守一条准则：
 如果提交存在于你的仓库之外，而别人可能基于这些提交进行开发，那么不要执行变基。
-变基操作的实质是丢弃一些现有的提交，然后相应地新建一些内容一样但实际上不同的提交。如果你已经将提交推送至某个仓库，而其他人也已经从该仓库拉取提交并进行了后续工作，此时，如果你用git rebase命令重新整理了提交并再次推送，你的同伴因此将不得不再次将他们手头的工作与你的提交进行整合，如果接下来你还要拉去并整合他们修改过的提交，事情就会变的一团糟。
-让我们来看一个在公开仓库上执行变基操作所带来的问题。假设你从一个中央服务器克隆然后在它的基础上进行了一些开发。你的提交历史如下图: 
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/perils-of-rebasing-1.png?raw=true)       
-然后，某人又向中央服务器提交了一些修改，其中还包括一次合并。你抓取了这些在远程分支上的修改，并将其合并到你本地的开发分支，然后你的提交记录就会变成这样:  
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/perils-of-rebasing-2.png?raw=true)        
-接下来，这个人又决定把合并操作回滚，改用变基。继而又用git push --force命令覆盖了服务器上的提交历史。之后你从服务器抓取更新，会发现多出来一些新的提交: 
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/perils-of-rebasing-3.png?raw=true)        
-结果就是你们两个人的处境都十分尴尬。如果你执行git pull命令，你将合并来自两条提交历史的内容，生成一个新的合并提交，最终仓库也会变成:  
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/perils-of-rebasing-4.png?raw=true)        
-这相当于是你将相同的内容又合并了一次，生成了一个新的提交。此时如果你执行git log命令，你会发现有两个调的作者、日期、日志居然是一样的，这会令人感到混乱。此外，如果你将这一堆又推送到服务器上，你实际上是将那些已经被变基抛弃的提交又找了回来，这会令人感到更加混乱。很明显对方并不想在提交历史中看到C4和C6，因为之前就是他把这两个提交丢弃的。
+变基操作的实质是丢弃一些现有的提交，然后相应地新建一些内容一样但实际上不同的提交。如果你已经将提交推送至某个仓库，而其他人也已经从该
+仓库拉取提交并进行了后续工作，此时，如果你用git rebase命令重新整理了提交并再次推送，你的同伴因此将不得不再次将他们手头的工作与你的
+提交进行整合，如果接下来你还要拉去并整合他们修改过的提交，事情就会变的一团糟。
+让我们来看一个在公开仓库上执行变基操作所带来的问题。假设你从一个中央服务器克隆然后在它的基础上进行了一些开发。你的提交历史如下图:
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/perils-of-rebasing-1.png?raw=true)
+然后，某人又向中央服务器提交了一些修改，其中还包括一次合并。你抓取了这些在远程分支上的修改，并将其合并到你本地的开发分支，然后你的提交
+记录就会变成这样:
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/perils-of-rebasing-2.png?raw=true)
+接下来，这个人又决定把合并操作回滚，改用变基。继而又用git push --force命令覆盖了服务器上的提交历史。之后你从服务器抓取更新，会发现
+多出来一些新的提交:
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/perils-of-rebasing-3.png?raw=true)
+结果就是你们两个人的处境都十分尴尬。如果你执行git pull命令，你将合并来自两条提交历史的内容，生成一个新的合并提交，最终仓库也会变成:
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/perils-of-rebasing-4.png?raw=true)
+这相当于是你将相同的内容又合并了一次，生成了一个新的提交。此时如果你执行git log命令，你会发现有两个调的作者、日期、日志居然是一样的，
+这会令人感到混乱。此外，如果你将这一堆又推送到服务器上，你实际上是将那些已经被变基抛弃的提交又找了回来，这会令人感到更加混乱。
+很明显对方并不想在提交历史中看到C4和C6，因为之前就是他把这两个提交丢弃的。
 
 ##### 用变基解决变基
+
 如果你 真的 遭遇了类似的处境，Git 还有一些高级魔法可以帮到你。 如果团队中的某人强制推送并覆盖了一些你所基于的提交，你需要做的就是检查你做了哪些修改，以及他们覆盖了哪些修改。
 
 实际上，Git 除了对整个提交计算 SHA-1 校验和以外，也对本次提交所引入的修改计算了校验和——即 “patch-id”。
@@ -670,7 +742,7 @@ git merge server
 - 把查到的这些提交应用在 teamone/master 上面
 
 从而我们将得到与 你将相同的内容又合并了一次，生成了一个新的提交 中不同的结果，如图 在一个被变基然后强制推送的分支上再次执行变基 所示。
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/perils-of-rebasing-5.png?raw=true)        
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/perils-of-rebasing-5.png?raw=true)
 要想上述方案有效，还需要对方在变基时确保 C4' 和 C4 是几乎一样的。 否则变基操作将无法识别，并新建另一个类似 C4 的补丁（而这个补丁很可能无法整洁的整合入历史，因为补丁中的修改已经存在于某个地方了）。
 
 在本例中另一种简单的方法是使用 git pull --rebase 命令而不是直接 git pull。 又或者你可以自己手动完成这个过程，先 git fetch，再 git rebase teamone/master。
@@ -680,40 +752,44 @@ git merge server
 如果你或你的同事在某些情形下决意要这么做，请一定要通知每个人执行 git pull --rebase 命令，这样尽管不能避免伤痛，但能有所缓解。
 
 #### 变基 vs. 合并
-至此，你已在实战中学习了变基和合并的用法，你一定会想问，到底哪种方式更好。 在回答这个问题之前，让我们退后一步，想讨论一下提交历史到底意味着什么。
 
-有一种观点认为，仓库的提交历史即是 记录实际发生过什么。 它是针对历史的文档，本身就有价值，不能乱改。 从这个角度看来，改变提交历史是一种亵渎，你使用 谎言 掩盖了实际发生过的事情。 如果由合并产生的提交历史是一团糟怎么办？ 既然事实就是如此，那么这些痕迹就应该被保留下来，让后人能够查阅。
+至此，你已在实战中学习了变基和合并的用法，你一定会想问，到底哪种方式更好。 在回答这个问题之前，让我们退后一步，想讨论一下提交历史
+到底意味着什么。
 
-另一种观点则正好相反，他们认为提交历史是 项目过程中发生的事。 没人会出版一本书的第一版草稿，软件维护手册也是需要反复修订才能方便使用。 持这一观点的人会使用 rebase 及 filter-branch 等工具来编写故事，怎么方便后来的读者就怎么写。
+有一种观点认为，仓库的提交历史即是记录实际发生过什么。它是针对历史的文档，本身就有价值，不能乱改。 从这个角度看来，改变提交历史是
+一种亵渎，你使用谎言掩盖了实际发生过的事情。如果由合并产生的提交历史是一团糟怎么办？ 既然事实就是如此，那么这些痕迹就应该被保留下来，
+让后人能够查阅。
 
-现在，让我们回到之前的问题上来，到底合并还是变基好？希望你能明白，这并没有一个简单的答案。 Git 是一个非常强大的工具，它允许你对提交历史做许多事情，但每个团队、每个项目对此的需求并不相同。 既然你已经分别学习了两者的用法，相信你能够根据实际情况作出明智的选择。
-
-总的原则是，只对尚未推送或分享给别人的本地修改执行变基操作清理历史， 从不对已推送至别处的提交执行变基操作，这样，你才能享受到两种方式带来的便利。
+另一种观点则正好相反，他们认为提交历史是项目过程中发生的事。没人会出版一本书的第一版草稿，软件维护手册也是需要反复修订才能方便使用。
+持这一观点的人会使用 rebase 及 filter-branch 等工具来编写故事，怎么方便后来的读者就怎么写。
 
+现在，让我们回到之前的问题上来，到底合并还是变基好？希望你能明白，这并没有一个简单的答案。 Git 是一个非常强大的工具，它允许你对
+提交历史做许多事情，但每个团队、每个项目对此的需求并不相同。 既然你已经分别学习了两者的用法，相信你能够根据实际情况作出明智的选择。
 
+总的原则是，只对尚未推送或分享给别人的本地修改执行变基操作清理历史， 从不对已推送至别处的提交执行变基操作，这样，你才能享受到两
+种方式带来的便利。
 
 ### git fetch与git pull的区别
 
-`git`中`fetch`命令是将远程分支的最新内容拉到了本地，但是`fecth`后是看不到变化的，如果查看当前的分支，会发现此时本地多了一个`FETCH_HEAD`的指针，`checkout`到该指针后才可以查看远程分支的最新内容。
+`git`中`fetch`命令是将远程分支的最新内容拉到了本地，但是`fecth`后是看不到变化的，如果查看当前的分支，会发现此时本地多了
+一个`FETCH_HEAD`的指针，`checkout`到该指针后才可以查看远程分支的最新内容。
 
 而`git pull`的作用相当于`fetch`和`merge`的组合，会自动合并:
 
-```git 
+```git
 git fetch origin master
 git merge FETCH_HEAD
 ```
-
 ### git pull 与git pull --rebase的使用
 
-使用下面的关系区别这两个操作:   
+使用下面的关系区别这两个操作:
 
 ```git
 git pull = git fetch + git merge
 git pull --rebase = git fetch + git rebase
 ```
-`git rebase`的过程中，有时会有`conflit`这时`Git`会停止`rebase`并让用户去解决冲突，解决完冲突后，用`git add`命令去更新这些内容，然后不用执行`git commit`，直接执行`git rebase --continue`这样`git`会继续`apply`余下的补丁。   
-
-
+`git rebase`的过程中，有时会有`conflit`这时`Git`会停止`rebase`并让用户去解决冲突，解决完冲突后，
+用`git add`命令去更新这些内容，然后不用执行`git commit`，直接执行`git rebase --continue`这样`git`会继续`apply`余下的补丁。
 
 ## 参考
 
@@ -721,10 +797,5 @@ git pull --rebase = git fetch + git rebase
 
 ---
 
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
-
-
-
-​    
-
+- 邮箱 ：charon.chui@gmail.com
+- Good Luck!
diff --git "a/JavaKnowledge/HashMap\345\256\236\347\216\260\345\216\237\347\220\206\345\210\206\346\236\220.md" "b/JavaKnowledge/HashMap\345\256\236\347\216\260\345\216\237\347\220\206\345\210\206\346\236\220.md"
index 5ebc846c..f610438e 100644
--- "a/JavaKnowledge/HashMap\345\256\236\347\216\260\345\216\237\347\220\206\345\210\206\346\236\220.md"
+++ "b/JavaKnowledge/HashMap\345\256\236\347\216\260\345\216\237\347\220\206\345\210\206\346\236\220.md"
@@ -9,17 +9,31 @@ HashMap基于Map接口实现，元素以键值对的方式存储，并且允许
 
 其底层数据结构是数组称之为哈希桶，每个桶(bucket)里面放的是链表，链表中的每个节点，就是哈希表中的每个元素。
 
-通过hash的方法，通过put和get存储和获取对象。存储对象时，我们将K / V传给put方法时，它调用hashCode计算hash从而得到bucket位置，进一步存储，HashMap会根据当前bucket的占用情况自动调整容量 (超过 Load  Facotr则resize为原来的2倍)。获取对象时，我们 K传给get，它调用hashCodeO()计算hash从而得到bucket位置，并进一步调用equals()方法确定键值对。如果发生碰撞的时候，Hashmap通过链表将产生碰撞冲突的元素组织起来，在JDK8中，如果一个bucket中碰撞冲突的元素超过8哥，则使用红黑树来替换链表，从而提高速度。
-
-因其底层哈希桶的数据结构是数组，所以也会涉及到扩容的问题。当HashMap的容量达到threshold域值时，就会触发扩容。扩容前后，哈希桶的长度一定会是2的次方。这样在根据key的hash值寻找对应的哈希桶时，可以用位运算替代取余操作，更加高效。而key的hash值，并不仅仅只是key对象的hashCode()方法的返回值，还会经过扰动函数的扰动，以使hash值更加均衡。因为hashCode()是int类型，取值范围是40多亿，只要哈希函数映射的比较均匀松散，碰撞几率是很小的。 但就算原本的hashCode()取得很好，每个key的hashCode()不同，但是由于HashMap的哈希桶的长度远比hash取值范围小，默认是16，所以当对hash值以桶的长度取余，以找到存放该key的桶的下标时，由于取余是通过与操作完成的，会忽略hash值的高位。因此只有hashCode()的低位参加运算，发生不同的hash值，但是得到的index相同的情况的几率会大大增加，这种情况称之为hash碰撞。 即，碰撞率会增大。扰动函数就是为了解决hash碰撞的。它会综合hash值高位和低位的特征，并存放在低位，因此在与运算时，相当于高低位一起参与了运算，以减少hash碰撞的概率。（在JDK8之前，扰动函数会扰动四次，JDK8简化了这个操作）扩容操作时，会new一个新的Node数组作为哈希桶，然后将原哈希表中的所有数据(Node节点)移动到新的哈希桶中，相当于对原哈希表中所有的数据重新做了一个put操作。所以性能消耗很大，可想而知，在哈希表的容量越大时，性能消耗越明显。扩容时，如果发生过哈希碰撞，节点数小于8个。则要根据链表上每个节点的哈希值，依次放入新哈希桶对应下标位置。因为扩容是容量翻倍，所以原链表上的每个节点，现在可能存放在原来的下标，即low位， 或者扩容后的下标，即high位。 high位= low位+原哈希桶容量如果追加节点后，链表数量》=8，则转化为红黑树由迭代器的实现可以看出，遍历HashMap时，顺序是按照哈希桶从低到高，链表从前往后，依次遍历的。
-
-
-
-
+通过hash的方法，通过put和get存储和获取对象。存储对象时，我们将K / V传给put方法时，它调用hashCode计算hash
+从而得到bucket位置，进一步存储，HashMap会根据当前bucket的占用情况自动调整容量 (超过Load Facotr则resize为原来的2倍)。
+获取对象时，我们将K传给get()方法，它调用hashCodeO()计算hash从而得到bucket位置，并进一步调用equals()方法确定键值对。
+如果发生碰撞的时候，HashMap通过链表将产生碰撞冲突的元素组织起来，在JDK8中，如果一个bucket中碰撞冲突的元素超过8个，
+则使用红黑树来替换链表，从而提高速度。
+
+因其底层哈希桶的数据结构是数组，所以也会涉及到扩容的问题。当HashMap的容量达到threshold域值时，就会触发扩容。
+扩容前后，哈希桶的长度一定会是2的次方。这样在根据key的hash值寻找对应的哈希桶时，可以用位运算替代取余操作，更加高效。
+而key的hash值，并不仅仅只是key对象的hashCode()方法的返回值，还会经过扰动函数的扰动，以使hash值更加均衡。
+因为hashCode()是int类型，取值范围是40多亿，只要哈希函数映射的比较均匀松散，碰撞几率是很小的。 但就算原本的hashCode()取的很好，
+每个key的hashCode()不同，但是由于HashMap的哈希桶的长度远比hash取值范围小，默认是16，所以当对hash值以桶的长度取余，
+以找到存放该key的桶的下标时，由于取余是通过与操作完成的，会忽略hash值的高位。因此只有hashCode()的低位参加运算，
+发生不同的hash值，但是得到的index相同的情况的几率会大大增加，这种情况称之为hash碰撞。即碰撞率会增大。
+扰动函数就是为了解决hash碰撞的。它会综合hash值高位和低位的特征，并存放在低位，因此在与运算时，相当于高低位一起参与了运算，
+以减少hash碰撞的概率。（在JDK8之前，扰动函数会扰动四次，JDK8简化了这个操作）扩容操作时，会new一个新的Node数组作为哈希桶，
+然后将原哈希表中的所有数据(Node节点)移动到新的哈希桶中，相当于对原哈希表中所有的数据重新做了一个put操作。所以性能消耗很大，
+可想而知，在哈希表的容量越大时，性能消耗越明显。扩容时，如果发生过哈希碰撞，节点数小于8个。则要根据链表上每个节点的哈希值，
+依次放入新哈希桶对应下标位置。因为扩容是容量翻倍，所以原链表上的每个节点，现在可能存放在原来的下标，即low位， 或者扩容后的下标，
+即high位。 high位= low位+原哈希桶容量如果追加节点后，链表数量》=8，则转化为红黑树由迭代器的实现可以看出，遍历HashMap时，
+顺序是按照哈希桶从低到高，链表从前往后，依次遍历的。
 
 ## JDK1.7
 
-HashMap在JDK1.8中发生了改变，下面的部分是基于JDK1.7的分析。HashMap主要是用数组来存储数据的，我们都知道它会对key进行哈希运算，哈希运算会有重复的哈希值，对于哈希值的冲突，HashMap采用链表来解决的。
+HashMap在JDK1.8中发生了改变，下面的部分是基于JDK1.7的分析。HashMap主要是用数组来存储数据的，我们都知道它会对key进行哈希运算，
+哈希运算会有重复的哈希值，对于哈希值的冲突，HashMap采用链表来解决的。
 在HashMap里有这样的一句属性声明:   
 
 ```java
@@ -28,28 +42,25 @@ transient Entry[] table;
 可以看到Map是通过数组的方式来储存Entry那Entry是神马呢？就是HashMap存储数据所用的类，它拥有的属性如下:   
 ```java
 static class Entry implements Map.Entry {
-	final K key;
-	V value;
-	Entry next;
-	final int hash;
-	...//More code goes here
+    final K key;
+    V value;
+    Entry next;
+    final int hash;
+    ...//More code goes here
 }  
 ```
-看到next了吗？next就是为了哈希冲突而存在的。比如通过哈希运算，一个新元素应该在数组的第10个位置，但是第10个位置已经有Entry，那么好吧，将新加的元素也放到第10个位置，将第10个位置的原有Entry赋值给当前新加的Entry的next属性。数组存储的是链表，链表是为了解决哈希冲突的，这一点要注意。
+看到next了吗？next就是为了哈希冲突而存在的。比如通过哈希运算，一个新元素应该在数组的第10个位置，但是第10个位置已经有Entry，
+那么好吧，将新加的元素也放到第10个位置，将第10个位置的原有Entry赋值给当前新加的Entry的next属性。
+数组存储的是链表，链表是为了解决哈希冲突的，这一点要注意。
 
 好了，总结一下:       
 
 - HashMap中有一个叫table的Entry数组。这个数组存储了Entry类的对象。Entry类包含了key-value作为实例变量。
-
 - table的索引在逻辑上叫做“桶”(bucket)，它存储了链表的第一个元素。
-
-- 每当往Hashmap里面存放key-value对的时候，都会为它们实例化一个Entry对象，这个Entry对象就会存储在前面提到的Entry数组table中。根据key的hashcode()方法计算出来的hash值来决定在Entry数组的索引(所在的桶)。
-
+- 每当往Hashmap里面存放key-value对的时候，都会为它们实例化一个Entry对象，这个Entry对象就会存储在前面提到的Entry数组table中。 根据key的hashcode()方法计算出来的hash值来决定在Entry数组的索引(所在的桶)。
 - 如果两个key有相同的hash值，他们会被放在table数组的同一个桶里面。
-
 - key的equals()方法用来确保key的唯一性。
 
-    
 
 接下来看一下put方法:      
 
@@ -70,33 +81,33 @@ static class Entry implements Map.Entry {
 */
 public V put(K key, V value) {
     // 对key做null检查。如果key是null，会被存储到table[0]，因为null的hash值总是0。
-	if (key == null)
-		return putForNullKey(value);
-	// 计算key的hash值,hash值用来找到存储Entry对象的数组的索引。有时候hash函数可能写的很不好，所以JDK的设计者添加了另一个叫做hash()的方法，它接收刚才计算的hash值作为参数	
-	int hash = hash(key.hashCode());
-	// indexFor(hash,table.length)用来计算在table数组中存储Entry对象的精确的索引
-	int i = indexFor(hash, table.length);
-	
-	for (Entry<k , V> e = table[i]; e != null; e = e.next) {
-	    // 如果这个位置已经有了(也就是hash值一样)就用链表来存了。 开始迭代链表
-		Object k;
-		// 直到Entry->next为null，就把当前的Entry对象变成链表的下一个节点。
-		if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
-		    // 如果我们再次放入同样的key会怎样呢？它会替换老的value。在迭代的过程中，会调用equals()方法来检查key的相等性(key.equals(k))，
-			// 如果这个方法返回true，它就会用当前Entry的value来替换之前的value。
-			V oldValue = e.value;
-			e.value = value;
-			e.recordAccess(this);
-			return oldValue;
-		}
-	}
-	// 如果计算出来的索引位置没有元素，就直接把Entry对象放到那个索引上。
-	modCount++;
-	addEntry(hash, key, value, i);
-	return null;
+    if (key == null)
+        return putForNullKey(value);
+    // 计算key的hash值,hash值用来找到存储Entry对象的数组的索引。有时候hash函数可能写的很不好，所以JDK的设计者添加了另一个叫做hash()的方法，它接收刚才计算的hash值作为参数   
+    int hash = hash(key.hashCode());
+    // indexFor(hash,table.length)用来计算在table数组中存储Entry对象的精确的索引
+    int i = indexFor(hash, table.length);
+    
+    for (Entry<k , V> e = table[i]; e != null; e = e.next) {
+        // 如果这个位置已经有了(也就是hash值一样)就用链表来存了。 开始迭代链表
+        Object k;
+        // 直到Entry->next为null，就把当前的Entry对象变成链表的下一个节点。
+        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
+            // 如果我们再次放入同样的key会怎样呢？它会替换老的value。在迭代的过程中，会调用equals()方法来检查key的相等性(key.equals(k))，
+            // 如果这个方法返回true，它就会用当前Entry的value来替换之前的value。
+            V oldValue = e.value;
+            e.value = value;
+            e.recordAccess(this);
+            return oldValue;
+        }
+    }
+    // 如果计算出来的索引位置没有元素，就直接把Entry对象放到那个索引上。
+    modCount++;
+    addEntry(hash, key, value, i);
+    return null;
 }
 ```
-再看一下get方法:　　　　
+再看一下get方法:
 ```java
 /**
   * Returns the value to which the specified key is mapped, or {@code null}
@@ -118,31 +129,33 @@ public V put(K key, V value) {
   */
 public V get(Object key) {
     // 如果key是null，table[0]这个位置的元素将被返回。
-	if (key == null)
-		return getForNullKey();
-	// 计算hash值
-	int hash = hash(key.hashCode());
-	// indexFor(hash,table.length)用来计算要获取的Entry对象在table数组中的精确的位置，使用刚才计算的hash值。
-	for (Entry<k , V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
-		Object k;
-		// 在获取了table数组的索引之后，会迭代链表，调用equals()方法检查key的相等性，如果equals()方法返回true，get方法返回Entry对象的value，否则，返回null。
-		if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
-    		return e.value;
-		}
-	return null;
+    if (key == null)
+        return getForNullKey();
+    // 计算hash值
+    int hash = hash(key.hashCode());
+    // indexFor(hash,table.length)用来计算要获取的Entry对象在table数组中的精确的位置，使用刚才计算的hash值。
+    for (Entry<k , V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
+        Object k;
+        // 在获取了table数组的索引之后，会迭代链表，调用equals()方法检查key的相等性，如果equals()方法返回true，get方法返回Entry对象的value，否则，返回null。
+        if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
+            return e.value;
+        }
+    return null;
 }
 ```
 
-
-
 ## JDK1.8
 
-在Jdk1.8中HashMap的实现方式做了一些改变，但是基本思想还是没有变得，只是在一些地方做了优化，下面来看一下这些改变的地方,数据结构的存储由数组+链表的方式，变化为数组+链表+红黑树的存储方式，当链表长度超过阈值（8）时，将链表转换为红黑树。利用红黑树快速增删改查的特点来提高HashMap的性能，其中会用到红黑树的插入、删除、查找等算法。HashMap中，如果key经过hash算法得出的数组索引位置全部不相同，即Hash算法非常好，那样的话，getKey方法的时间复杂度就是O(1)，如果Hash算法技术的结果碰撞非常多，假如Hash算极其差，所有的Hash算法结果得出的索引位置一样，那样所有的键值对都集中到一个桶中，或者在一个链表中，或者在一个红黑树中，时间复杂度分别为O(n)和O(lgn)。
+在Jdk1.8中HashMap的实现方式做了一些改变，但是基本思想还是没有变的，只是在一些地方做了优化，下面来看一下这些改变的地方,
+数据结构的存储由数组+链表的方式，变化为数组+链表+红黑树的存储方式，当链表长度超过阈值（8）时，将链表转换为红黑树。
+利用红黑树快速增删改查的特点来提高HashMap的性能，其中会用到红黑树的插入、删除、查找等算法。HashMap中，
+如果key经过hash算法得出的数组索引位置全部不相同，即Hash算法非常好，那样的话，getKey方法的时间复杂度就是O(1)，
+如果Hash算法技术的结果碰撞非常多，假如Hash算法极其差，所有的Hash算法结果得出的索引位置一样，那样所有的键值对都集中到一个桶中，
+或者在一个链表中，或者在一个红黑树中，时间复杂度分别为O(n)和O(lgn)。
 
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/hashmap_data_structure.jpg)
 
 
-
 既然发生了变化，那这里就以1.8的源码基础上再做一下分析:  
 
 1. 首先看一下对应的两个Node类:  
@@ -167,7 +180,7 @@ public V get(Object key) {
         public final K getKey()        { return key; }
         public final V getValue()      { return value; }
         public final String toString() { return key + "=" + value; }
-    	// 每一个节点的hashcode值，是将key和value的hashCode值异或得到的
+        // 每一个节点的hashcode值，是将key和value的hashCode值异或得到的
         public final int hashCode() {
             return Objects.hashCode(key) ^ Objects.hashCode(value);
         }
@@ -217,7 +230,7 @@ public V get(Object key) {
          * @return root of tree
          */
         final void treeify(Node<K,V>[] tab) {
-       		...
+            ...
         }
     
         /**
@@ -229,7 +242,7 @@ public V get(Object key) {
         }
     
         /**
-    	 * 红黑树的插入
+         * 红黑树的插入
          * Tree version of putVal.
          */
         final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
@@ -285,7 +298,7 @@ public V get(Object key) {
     ```java
     public class HashMap<K,V> extends AbstractMap<K,V>
         implements Map<K,V>, Cloneable, Serializable {
-    	// 默认的初始化容量大小，必须是2的倍数，默认是16，为啥必须是2的倍数，后面会说
+        // 默认的初始化容量大小，必须是2的倍数，默认是16，为啥必须是2的倍数，后面会说
         static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
         // 在构造函数中未指定时使用的负载因子。
         static final float DEFAULT_LOAD_FACTOR = 0.75f;
@@ -329,7 +342,10 @@ public V get(Object key) {
 
 ### 确定哈希桶数组索引位置
 
-不管增加、删除、查找键值对，定位到哈希桶数组的位置都是很关键的第一步。前面说过HashMap的数据结构是数组和链表的结合，所以我们当然希望这个HashMap里面的元素位置尽量分布均匀些，尽量使得每个位置上的元素数量只有一个，那么当我们用hash算法求得这个位置的时候，马上就可以知道对应位置的元素就是我们要的，不用遍历链表，大大优化了查询的效率。HashMap定位数组索引位置，直接决定了hash方法的离散性能。先看看源码的实现：  
+不管增加、删除、查找键值对，定位到哈希桶数组的位置都是很关键的第一步。前面说过HashMap的数据结构是数组和链表的结合，
+所以我们当然希望这个HashMap里面的元素位置尽量分布均匀些，尽量使得每个位置上的元素数量只有一个，那么当我们用hash算法求得这个位置的
+时候，马上就可以知道对应位置的元素就是我们要的，不用遍历链表，大大优化了查询的效率。HashMap定位数组索引位置，直接决定了hash方法的
+离散性能。先看看源码的实现：  
 
 ```java
 static final int hash(Object key) {
@@ -338,18 +354,22 @@ static final int hash(Object key) {
 }
 ```
 
-hash函数是先拿到通过key 的hashcode，是32位的int值，然后让hashcode的高16位和低16位进行异或操作。为什么要这样设计呢？ 主要有两个原因 ：  
+hash函数是先拿到通过key的hashcode，是32位的int值，然后让hashcode的高16位和低16位进行异或操作。为什么要这样设计呢？ 
+主要有两个原因 ：  
 
 1. 一定要尽可能降低hash碰撞，越分散越好。
 2. 算法一定要尽可能高效，因为这是高频操作，因此采用位运算。
 
-因为hashcode是32位的int值int值范围为**-2147483648~2147483647**，前后加起来大概40亿的映射空间。只要哈希函数映射得比较均匀松散，一般应用是很难出现碰撞的。但问题是一个40亿长度的数组，内存是放不下的。你想，如果HashMap数组的初始大小才16，用之前需要对数组的长度取模运算，得到的余数才能用来访问数组下标。源码中模运算就是把散列值和数组长度-1做一个"与"操作，位运算比%运算要快。
-
-
+因为hashcode是32位的int值int值范围为**-2147483648~2147483647**，前后加起来大概40亿的映射空间。只要哈希函数映射得比较均匀松散，
+一般应用是很难出现碰撞的。但问题是一个40亿长度的数组，内存是放不下的。你想，如果HashMap数组的初始大小才16，用之前需要对数组的长度取模运算，
+得到的余数才能用来访问数组下标。源码中模运算就是把散列值和数组长度-1做一个"与"操作，位运算比%运算要快。
 
 
-
-对于任意给定的对象，只要它的hashCode()返回值相同，那么程序调用所计算得到的Hash码值总是相同的。我们首先想到的就是把hash值对数组长度取模运算，这样一来，元素的分布相对来说是比较均匀的。但是，模运算的消耗还是比较大的，在HashMap中是这样做的：调用 (table.length  -1) & hash来计算该对象应该保存在table数组的哪个索引处。这个方法非常巧妙，它通过 (table.length  -1) & hash来得到该对象的保存位，而HashMap底层数组的长度总是2的n次方，当length总是2的n次方时， (table.length  -1) & hash运算等价于对length取模，也就是h%length，但是&比%具有更高的效率。
+对于任意给定的对象，只要它的hashCode()返回值相同，那么程序调用所计算得到的Hash值总是相同的。我们首先想到的就是把hash值对数组长度
+取模运算，这样一来，元素的分布相对来说是比较均匀的。但是，模运算的消耗还是比较大的，
+在HashMap中是这样做的：调用 (table.length  -1) & hash来计算该对象应该保存在table数组的哪个索引处。
+这个方法非常巧妙，它通过 (table.length  -1) & hash来得到该对象的保存位，而HashMap底层数组的长度总是2的n次方，
+当length总是2的n次方时， (table.length  -1) & hash运算等价于对length取模，也就是h%length，但是&比%具有更高的效率。
 
 当length总是2的倍数时，h & (length-1) 将是一个非常巧妙的设计：
 
@@ -359,16 +379,16 @@ hash函数是先拿到通过key 的hashcode，是32位的int值，然后让hashc
 - 但是当h=16时 , length=16 时，那么h & length - 1将得到0了；
 - 当h=17时, length=16时，那么h & length - 1将得到1了。
 
-这样保证计算得到的索引值总是位于 table 数组的索引之内。
-
+这样保证计算得到的索引值总是位于table数组的索引之内。
 
 
-在JDK1.8的实现中，优化了高位运算的算法，通过hashCode()的高16位异或低16位实现的：(h = k.hashCode()) ^ (h >>>  16)，主要是从速度、功效、质量来考虑的，这么做可以在数组table的length比较小的时候，也能保证考虑到高低Bit都参与到Hash的计算中，同时不会有太大的开销。
+在JDK1.8的实现中，优化了高位运算的算法，通过hashCode()的高16位异或低16位实现的：(h = k.hashCode()) ^ (h >>>  16)，
+主要是从速度、功效、质量来考虑的，这么做可以在数组table的length比较小的时候，也能保证考虑到高低Bit都参与到Hash的计算中，
+同时不会有太大的开销。
 
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/hashmap_hash.bmp)
 
 
-
 ### put
 
 ```java
@@ -389,7 +409,7 @@ hash函数是先拿到通过key 的hashcode，是32位的int值，然后让hashc
             // 3. 如果tab[索引]的值为null，那就说明这个索引没有数组桶，直接新建一个数组桶
             tab[i] = newNode(hash, key, value, null);
         else {
-           	// 4. 否则就是目前已经存在该索引的数组桶了，要继续判断是链表还是红黑树。
+            // 4. 否则就是目前已经存在该索引的数组桶了，要继续判断是链表还是红黑树。
             Node<K,V> e; K k;
             // 5. 判断table[索引]处的收个元素是否和key一样，如果首个就是那就直接覆盖value，不用再找了
             if (p.hash == hash &&
@@ -400,7 +420,7 @@ hash函数是先拿到通过key 的hashcode，是32位的int值，然后让hashc
                 // 7. 数组桶首个元素不是，并且链表是红黑树，红黑树直接插入键值对
                 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
             else {
-            	// 8. 目前为链表，开始遍历链表准备插入
+                // 8. 目前为链表，开始遍历链表准备插入
                 for (int binCount = 0; ; ++binCount) {
                     if ((e = p.next) == null) {
                         // 添加到目前的节点的next上
@@ -475,27 +495,19 @@ final void treeifyBin(Node<K,V>[] tab, int hash) {
 resize()方法用于初始化数组或数组扩容，每次扩容后容量为原来的2倍，并进行数据迁移。 
 
 
-
-例如我们从 16 扩展为 32 时，具体的变化如下所示：
-
+例如我们从16扩展为32时，具体的变化如下所示：
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/resize1.bmp)
 
-
-
-
-因此元素在重新计算hash之后，因为n变为 2 倍，那 n-1的mask范围在高位多1bit (红色)，因此新的 index就会发生这样的变化：
-
+因此元素在重新计算hash之后，因为n变为2倍，那n-1的mask范围在高位多1bit (红色)，因此新的index就会发生这样的变化：
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/resize2.bmp)
 
-
-因此，我们在扩充HashMap的时候，不需要重新计算hash，只需要看看原来的hash值新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引变成 “原索引 + oldCap”。可以看看下图为16扩充为32的resize示意图：
-
+因此，我们在扩充HashMap的时候，不需要重新计算hash，只需要看看原来的hash值新增的那个bit是1还是0就好了，
+是0的话索引没变，是1的话索引变成 “原索引 + oldCap”。可以看看下图为16扩充为32的resize示意图：
 ![resize](https://raw.githubusercontent.com/CharonChui/Pictures/master/resize3.bmp)
 
 
-
-
-这个设计确实非常的巧妙，既省去了重新计算 hash 值的时间，而且同时，**由于新增的 1bit 是 0 还是 1 可以认为是随机的，因此 resize 的过程，均匀的把之前的冲突的节点分散到新的 bucket 了**。
+这个设计确实非常的巧妙，既省去了重新计算hash值的时间，而且同时，**由于新增的1bit是0还是1可以认为是随机的，因此resize的过程，
+均匀的把之前的冲突的节点分散到新的bucket了**。
 
 ```java
 final Node<K,V>[] resize() {
@@ -602,7 +614,8 @@ final Node<K,V>[] resize() {
 }
 ```
 
-再看一下往哈希表里插入一个节点的putVal函数,如果参数onlyIfAbsent是true，那么不会覆盖相同key的值value。如果evict是false。那么表示是在初始化时调用的
+再看一下往哈希表里插入一个节点的putVal函数,如果参数onlyIfAbsent是true，那么不会覆盖相同key的值value。
+如果evict是false，那么表示是在初始化时调用的。
 
 ```java
 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
@@ -673,7 +686,7 @@ final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
 
 * 运算尽量都用位运算代替，更高效。
 * 对于扩容导致需要新建数组存放更多元素时，除了要将老数组中的元素迁移过来，也记得将老数组中的引用置null，以便GC
-* 取下标 是用 哈希值 与运算 （桶的长度-1） i = (n - 1) & hash。 由于桶的长度是2的n次方，这么做其实是等于 一个模运算。但是效率更高
+* 取下标 是用哈希值与运算 （桶的长度-1） i = (n - 1) & hash。 由于桶的长度是2的n次方，这么做其实是等于 一个模运算。但是效率更高
 * 扩容时，如果发生过哈希碰撞，节点数小于8个。则要根据链表上每个节点的哈希值，依次放入新哈希桶对应下标位置。
 * 因为扩容是容量翻倍，所以原链表上的每个节点，现在可能存放在原来的下标，即low位， 或者扩容后的下标，即high位。 high位= low位+原哈希桶容量
 * 利用哈希值 与运算 旧的容量 ，if ((e.hash & oldCap) == 0),可以得到哈希值去模后，是大于等于oldCap还是小于oldCap，等于0代表小于oldCap，应该存放在低位，否则存放在高位。这里又是一个利用位运算 代替常规运算的高效点
@@ -716,7 +729,7 @@ final Node<K,V> getNode(int hash, Object key) {
 
 
 
-## JDK 7 与 JDK 8 中关于 HashMap的对比
+## JDK 7与JDK 8中关于HashMap的对比
 
 1. JDK8为红黑树 + 链表 + 数组的形式，当桶内元素大于8时，便会树化。
 2. hash值的计算方式不同 (jdk 8 简化)。
@@ -727,25 +740,33 @@ final Node<K,V> getNode(int hash, Object key) {
 
 
 
-
-
 ## 问题
 
 1. 为什么capcity是2的幂？
-     因为算index时用的是(n-1) & hash，这样就能保证n-1是全为1的二进制数，如果不全为1的话，存在某一位为 0，那么0，1与0与的结果都是0，这样便有可能将两个hash不同的值最终装入同一个桶中，造成冲突。所以必须是2的幂。这是为了服务key映射到index的Hash算法的，公式index=hashcode(key)&(length-1)，初始长度(16-1)，二进制为1111&hashcode结果为hashcode最后四位，能最大程度保持平均，二的幂数保证二进制为1，保持hashcode最后四位。这种算法在保持分布均匀之外，效率也非常高。
+
+    因为算index时用的是(n-1) & hash，这样就能保证n-1是全为1的二进制数，如果不全为1的话，存在某一位为0，那么0，1与0与的结果都是0，
+    这样便有可能将两个hash不同的值最终装入同一个桶中，造成冲突。所以必须是2的幂。这是为了服务key映射到index的Hash算法的，
+    公式index=hashcode(key)&(length-1)，初始长度(16-1)，二进制为1111&hashcode结果为hashcode最后四位，能最大程度保持平均，二的幂数保证二进制为1，保持hashcode最后四位。这种算法在保持分布均匀之外，效率也非常高。
 
 2. 为什么需要使用加载因子，为什么需要扩容呢？
 
-    因为如果填充比很大，说明利用的空间很多，如果一直不进行扩容的话，链表就会越来越长，这样查找的效率很低，因为链表的长度很大（当然最新版本使用了红黑树后会改进很多），扩容之后，将原来链表数组的每一个链表分成奇偶两个子链表分别挂在新链表数组的散列位置，这样就减少了每个链表的长度，增加查找效率。HashMap 本来是以空间换时间，所以填充比没必要太大。但是填充比太小又会导致空间浪费。如果关注内存，填充比可以稍大，如果主要关注查找性能，填充比可以稍小。
+    因为如果填充比很大，说明利用的空间很多，如果一直不进行扩容的话，链表就会越来越长，这样查找的效率很低，因为链表的长度很大（当然最新版本使用了红黑树后会改进很多），
+    扩容之后，将原来链表数组的每一个链表分成奇偶两个子链表分别挂在新链表数组的散列位置，这样就减少了每个链表的长度，增加查找效率。HashMap本来是以空间换时间，所以填充比没必要太大。
+    但是填充比太小又会导致空间浪费。如果关注内存，填充比可以稍大，如果主要关注查找性能，填充比可以稍小。
 
 3. 为什么 HashMap 是线程不安全的，实际会如何体现？
 
-    - 如果多个线程同时使用put方法添加元素，假设正好存在两个put的key发生了碰撞 (hash值一样)，那么根据HashMap的实现，这两个key会添加到数组的同一个位置，这样最终就会发生其中一个线程的put的数据被覆盖。
-- 如果多个线程同时检测到元素个数超过数组大小 * loadFactor。这样会发生多个线程同时对hash数组进行扩容，都在重新计算元素位置以及复制数据，但是最终只有一个线程扩容后的数组会赋给table，也就是说其他线程的都会丢失，并且各自线程put的数据也丢失。且会引起死循环的错误。
+    如果多个线程同时使用put方法添加元素，假设正好存在两个put的key发生了碰撞 (hash值一样)，那么根据HashMap的实现，
+    这两个key会添加到数组的同一个位置，这样最终就会发生其中一个线程的put的数据被覆盖。
+    如果多个线程同时检测到元素个数超过数组大小 * loadFactor。这样会发生多个线程同时对hash数组进行扩容，都在重新计算元素位置
+    以及复制数据，但是最终只有一个线程扩容后的数组会赋给table，也就是说其他线程的都会丢失，并且各自线程put的数据也丢失。
+    且会引起死循环的错误。
     
 4. 与HashTable的区别
 
-    Hashtable是遗留类，很多映射的常用功能与HashMap类似，不同的是它承自Dictionary类，并且是线程安全的，任一时间只有一个线程能写Hashtable，它的并发性不如ConcurrentHashMap，因为ConcurrentHashMap引入了分段锁。Hashtable不建议在新代码中使用，不需要线程安全的场合可以用HashMap替换，需要线程安全的场合可以用ConcurrentHashMap替换。
+    Hashtable是遗留类，很多映射的常用功能与HashMap类似，不同的是它承自Dictionary类，并且是线程安全的，任一时间只有一个线程能写Hashtable，
+    它的并发性不如ConcurrentHashMap，因为ConcurrentHashMap引入了分段锁。Hashtable不建议在新代码中使用，不需要线程安全的场合可以用HashMap替换，
+    需要线程安全的场合可以用ConcurrentHashMap替换。
 
     - 与之相比HashTable是线程安全的，且不允许key、value是null。
     - HashTable默认容量是11。
@@ -754,15 +775,12 @@ final Node<K,V> getNode(int hash, Object key) {
     - 扩容时，新容量是原来的2倍+1。int newCapacity = (oldCapacity << 1) + 1;
     - Hashtable是Dictionary的子类同时也实现了Map接口，HashMap是Map接口的一个实现类
     
-5. 扩容的时候为什么1.8 不用重新hash就可以直接定位原节点在新数据的位置呢?
+5. 扩容的时候为什么1.8不用重新hash就可以直接定位原节点在新数据的位置呢?
 
     这是由于扩容是扩大为原数组大小的2倍，用于计算数组位置的掩码仅仅只是高位多了一个1，举个例子：
-
-      扩容前长度为16，用于计算 (n-1) & hash 的二进制n - 1为0000 1111， 
-
-       扩容后为32后的二进制就高位多了1，============>为0001 1111。因为是& 运算，1和任何数 & 都是它本身，那就分二种情况，如下图：原数据hashcode高位第4位为0和高位为1的情况；第四位高位为0，重新hash数值不变，第四位为1，重新hash数值比原来大16（旧数组的容量）。
-
-    
+        扩容前长度为16，用于计算 (n-1) & hash 的二进制n - 1为0000 1111，
+        扩容后为32后的二进制就高位多了1，============>为0001 1111。因为是&运算，1和任何数&都是它本身，那就分二种情况，
+        原数据hashcode高位第4位为0和高位为1的情况；第四位高位为0，重新hash数值不变，第四位为1，重新hash数值比原来大16（旧数组的容量）。
 
 
 参考:  
@@ -773,11 +791,8 @@ final Node<K,V> getNode(int hash, Object key) {
 
 
 
-
-
-
 ---
 - 邮箱 ：charon.chui@gmail.com  
 - Good Luck! 
 
-	
+    
diff --git "a/JavaKnowledge/Http\344\270\216Https\347\232\204\345\214\272\345\210\253.md" "b/JavaKnowledge/Http\344\270\216Https\347\232\204\345\214\272\345\210\253.md"
index 417c7785..e24c20ec 100644
--- "a/JavaKnowledge/Http\344\270\216Https\347\232\204\345\214\272\345\210\253.md"
+++ "b/JavaKnowledge/Http\344\270\216Https\347\232\204\345\214\272\345\210\253.md"
@@ -39,12 +39,12 @@ HTTP与HTTPS的区别
 
 你是不是很好奇，当你在浏览器中输入网址后，到底发生了什么事情？你想要的内容是如何展现出来的？让我们通过一个例子来探讨一下，我们假设访问的 URL 地址为 `http://www.someSchool.edu/someDepartment/home.index`，当我们输入网址并点击回车时，浏览器内部会进行如下操作
 
-- DNS服务器会首先进行域名的映射，找到访问`www.someSchool.edu`所在的地址，然后HTTP 客户端进程在 80 端口发起一个到服务器 `www.someSchool.edu` 的 TCP 连接（80 端口是 HTTP 的默认端口）。在客户和服务器进程中都会有一个`套接字`与其相连。
-- HTTP 客户端通过它的套接字向服务器发送一个 HTTP 请求报文。该报文中包含了路径 `someDepartment/home.index` 的资源，我们后面会详细讨论 HTTP 请求报文。
-- HTTP 服务器通过它的套接字接受该报文，进行请求的解析工作，并从其`存储器(RAM 或磁盘)`中检索出对象 [www.someSchool.edu/someDepartment/home.index，然后把检索出来的对象进行封装，封装到](http://www.someSchool.edu/someDepartment/home.index，然后把检索出来的对象进行封装，封装到) HTTP 响应报文中，并通过套接字向客户进行发送。
-- HTTP 服务器随即通知 TCP 断开 TCP 连接，实际上是需要等到客户接受完响应报文后才会断开 TCP 连接。
-- HTTP 客户端接受完响应报文后，TCP 连接会关闭。HTTP 客户端从响应中提取出报文中是一个 HTML 响应文件，并检查该 HTML 文件，然后循环检查报文中其他内部对象。
-- 检查完成后，HTTP 客户端会把对应的资源通过显示器呈现给用户。
+- DNS服务器会首先进行域名的映射，找到访问`www.someSchool.edu`所在的地址，然后HTTP客户端进程在80端口发起一个到服务器`www.someSchool.edu`的TCP连接（80端口是HTTP的默认端口）。在客户和服务器进程中都会有一个`套接字`与其相连。
+- HTTP客户端通过它的套接字向服务器发送一个HTTP请求报文。该报文中包含了路径`someDepartment/home.index`的资源，我们后面会详细讨论HTTP请求报文。
+- HTTP服务器通过它的套接字接受该报文，进行请求的解析工作，并从其`存储器(RAM 或磁盘)`中检索出对象 [www.someSchool.edu/someDepartment/home.index，然后把检索出来的对象进行封装，封装到](http://www.someSchool.edu/someDepartment/home.index，然后把检索出来的对象进行封装，封装到)HTTP响应报文中，并通过套接字向客户进行发送。
+- HTTP服务器随即通知TCP断开TCP连接，实际上是需要等到客户接受完响应报文后才会断开TCP连接。
+- HTTP客户端接受完响应报文后，TCP连接会关闭。HTTP客户端从响应中提取出报文中是一个HTML响应文件，并检查该HTML文件，然后循环检查报文中其他内部对象。
+- 检查完成后，HTTP客户端会把对应的资源通过显示器呈现给用户。
 
 至此，键入网址再按下回车的全过程就结束了。上述过程描述的是一种简单的`请求-响应`全过程，真实的请求-响应情况可能要比上面描述的过程复杂很多。
 
@@ -190,4 +190,4 @@ HTTP + 加密 + 认证 + 完整性保护 = HTTPS
 - 邮箱 ：charon.chui@gmail.com  
 - Good Luck! 
 
-	
\ No newline at end of file
+    
\ No newline at end of file
diff --git "a/JavaKnowledge/Java\345\206\205\345\255\230\346\250\241\345\236\213.md" "b/JavaKnowledge/Java\345\206\205\345\255\230\346\250\241\345\236\213.md"
index 90eb117e..1e2fae6a 100644
--- "a/JavaKnowledge/Java\345\206\205\345\255\230\346\250\241\345\236\213.md"
+++ "b/JavaKnowledge/Java\345\206\205\345\255\230\346\250\241\345\236\213.md"
@@ -1,12 +1,16 @@
 Java内存模型
 ===
 
-Java虚拟机(Java Virtual Machine)在执行Java程序的过程中，会把它管理的内存划分为五个不同的数据区域(Heap Memory、Stack Memory、Method Area、PC、Native Stack Memory)，这些区域都有各自的用途、创建时间、销毁时间:     
+Java虚拟机(Java Virtual Machine)在执行Java程序的过程中，会把它管理的内存划分为五个不同的数据区域(Heap Memory、
+Stack Memory、Method Area、PC、Native Stack Memory)，这些区域都有各自的用途、创建时间、销毁时间:     
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/jvm_memory_model.jpeg)
 
 ## Program Counter Register
 
-程序计数器是一块较小的内存空间，严格来说是一个数据结构，用于保存当前正在执行的程序的内存地址，由于Java是支持多线程执行的，所以程序执行的轨迹不可能一直都是线性执行。当有多个线程交叉执行时，被中断的线程的程序当前执行到哪条内存地址必然要保存下来，以便用于被中断的线程恢复执行时再按照被中断时的指令地址继续执行下去。为了线程切换后能恢复到正确的执行位置，每个线程都需要有一个独立的程序计数器，各个线程之间计数器互不影响，独立存储，我们称这类内存区域为“线程私有”的内存,这在某种程度上有点类似于“ThreadLocal”，是线程安全的。可以看作是当前线程所执行的字节码的行号指示器。
+程序计数器是一块较小的内存空间，严格来说是一个数据结构，用于保存当前正在执行的程序的内存地址，由于Java是支持多线程执行的，所以程序执行的轨迹
+不可能一直都是线性执行。当有多个线程交叉执行时，被中断的线程的程序当前执行到哪条内存地址必然要保存下来，以便用于被中断的线程恢复执行时再按照
+被中断时的指令地址继续执行下去。为了线程切换后能恢复到正确的执行位置，每个线程都需要有一个独立的程序计数器，各个线程之间计数器互不影响，独立存储，
+我们称这类内存区域为“线程私有”的内存,这在某种程度上有点类似于“ThreadLocal”，是线程安全的。可以看作是当前线程所执行的字节码的行号指示器。
 
 从上面的介绍中我们知道程序计数器主要有两个作用：
 
@@ -22,12 +26,11 @@ Java虚拟机(Java Virtual Machine)在执行Java程序的过程中，会把它
 所有的对象实例和数组都存放到Heap内存中。Heap内存也称为共享内存。多线程可以共享这里面的数据。 
 
 - 堆内存在JVM启动的时候被加载(初始大小: -Xms)
-
 - 堆内存在程序运行时会增加或减少
-
 - 最小值: -Xmx
-
-- 从结构上来分，可以分为新生代和老年代。而新生代又可以分为Eden空间、From Survivor空间（s0）、To Survivor空间（s1）。 所有新生成的对象首先都是放在新生代的。需要注意，Survivor的两个区是对称的，没先后关系，所以同一个区中可能同时存在从Eden复制过来的对象，和从前一个Survivor复制过来的对象，而复制到老年代的只有从第一个Survivor区过来的对象。而且，Survivor区总有一个是空的。
+- 从结构上来分，可以分为新生代和老年代。而新生代又可以分为Eden空间、From Survivor空间（s0）、To Survivor空间（s1）。 所有新生成的对象首先
+    都是放在新生代的。需要注意，Survivor的两个区是对称的，没先后关系，所以同一个区中可能同时存在从Eden复制过来的对象，和从前一个Survivor复制
+    过来的对象，而复制到老年代的只有从第一个Survivor区过来的对象。而且，Survivor区总有一个是空的。
 
   ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/jvm_heap_memory.png)
 
@@ -35,7 +38,7 @@ Java虚拟机(Java Virtual Machine)在执行Java程序的过程中，会把它
 
 ## Stack Memory
 
-栈总是与线程关联在一起的，每当创建一个线程，JVM就会为该线程创建对应的线程栈，线程stack中包含有关线程调用了哪些方法以达到当前执行点的信息。，也可以称之为调用栈，只要线程执行代码，调用栈就会发生改变。在这个栈中又会包含多个栈帧(Stack Frame)，栈是由一个个栈帧组成，这些栈帧是与每个方法关联起来的，每运行一个方法就创建一个栈帧，每个栈帧会含有一些局部变量表、操作栈和方法返回值等信息。
+栈总是与线程关联在一起的，每当创建一个线程，JVM就会为该线程创建对应的线程栈，线程stack中包含有关线程调用了哪些方法以达到当前执行点的信息，也可以称之为调用栈，只要线程执行代码，调用栈就会发生改变。在这个栈中又会包含多个栈帧(Stack Frame)，栈是由一个个栈帧组成，这些栈帧是与每个方法关联起来的，每运行一个方法就创建一个栈帧，每个栈帧会含有一些局部变量表、操作栈和方法返回值等信息。
 
 局部变量表主要存放了编译器可知的各种数据类型（boolean、byte、char、short、int、float、long、double）、对象引用（reference类型，它不同于对象本身，可能是一个指向对象起始地址的引用指针，也可能是指向一个代表对象的句柄或其他与此对象相关的位置）。
 
@@ -51,8 +54,8 @@ Java虚拟机(Java Virtual Machine)在执行Java程序的过程中，会把它
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/stack_heap.png)
 
 - 局部变量可以是原始类型，在这种情况下，它完全保留在线程堆栈中。
-- 局部变量也可以是对对象的引用。在这种情况下，引用（局部变量）存储在线程堆栈中，但是对象本身（如果存储在堆中）。
-- 一个对象可能包含方法，而这些方法可能包含局部变量。即使该方法所属的对象存储在堆内存中，这些局部变量也存储在线程堆内存中。
+- 局部变量也可以是对对象的引用。在这种情况下，引用（局部变量）存储在线程堆栈中，但是对象本身（如果有）存储在堆中。
+- 一个对象可能包含方法，而这些方法可能包含局部变量。即使该方法所属的对象存储在堆中，这些局部变量也存储在线程堆栈中。
 - 对象的成员变量与对象本身一起存储在堆中。不管成员变量是原始类型时，以及它是对对象的引用时，都是如此。    
 - 静态类变量也与类定义一起存储在堆中。    
 - 引用对象的所有线程都可以访问堆上的对象。当线程可以访问对象时，它也可以访问该对象的成员变量。如果两个线程同时在同一个对象上调用一个方法，则它们都将有权访问该对象的成员变量，但是每个线程将拥有自己的局部变量副本。
@@ -92,7 +95,7 @@ Java 虚拟机栈会出现两种异常：StackOverFlowError 和 OutOfMemoryError
 
 JVM会加载、链接、初始化class文件。一个class文件会把其所有所有符号引用都保留在一个位置，即常量池中。 
 
-每个class文件都会有一个对应constant pool。但是class文件中的常量池显示让不够的，因为需要再JVM上执行。这种情况下，需要runtime constant pool来服务JVM的运行。
+每个class文件都会有一个对应constant pool。但是class文件中的常量池显然是不够的，因为需要再JVM上执行。这种情况下，需要runtime constant pool来服务JVM的运行。
 
 Java虚拟机加载的每个类或接口都有其常量池的内部版本，称为运行时常量池(runtime constant pool)。运行时常量池是特定于实现的数据结构，它与类文件中的常量池是一一对应映射的。因此，在最初加载类型之后，该类型的所有符号引用都驻留在该类型的运行时常量池中。包括字符串常量，类和接口名称，字段名称以及类中引用的其他常量。
 
@@ -109,9 +112,9 @@ System.out.println(str1==str2);//false
 ```java
 String str1 = "str";
 String str2 = "ing";
-		  
+        
 String str3 = "str" + "ing";//常量池中的对象
-String str4 = str1 + str2; //在堆上创建的新的对象	  
+String str4 = str1 + str2; //在堆上创建的新的对象   
 String str5 = "string";//常量池中的对象
 System.out.println(str3 == str4);//false
 System.out.println(str3 == str5);//true
@@ -178,7 +181,7 @@ JMM(Java Memory Model)规定了所有的变量都存储在主内存（Main Memor
 
 由上述对JVM内存结构的描述中，我们知道了堆和方法区是线程共享的。而局部变量，方法定义参数和异常处理器参数就不会在线程之间共享，它们不会有内存可见性问题，也不受内存模型的影响。
 
-Java线程之间的通信由Java内存模型（本文简称为JMM）控制，JMM决定一个线程对共享变量的写入何时对另一个线程可见。从抽象的角度来看，JMM定义了线程和主内存之间的抽象关系：线程之间的共享变量存储在主内存（main memory）中，每个线程都有一个私有的本地内存（local memory），本地内存中存储了该线程以读/写共享变量的副本。本地内存是JMM的一个抽象概念，并不真实存在。它涵盖了缓存，写缓冲区，寄存器以及其他的硬件和编译器优化。
+Java线程之间的通信由Java内存模型(JMM)控制，JMM决定一个线程对共享变量的写入何时对另一个线程可见。从抽象的角度来看，JMM定义了线程和主内存之间的抽象关系：线程之间的共享变量存储在主内存（main memory）中，每个线程都有一个私有的本地内存（local memory），本地内存中存储了该线程以读/写共享变量的副本。本地内存是JMM的一个抽象概念，并不真实存在。它涵盖了缓存，写缓冲区，寄存器以及其他的硬件和编译器优化。
 
 假设线程A与线程B之间如要通信的话，必须要经历下面2个步骤: 
 
@@ -212,7 +215,7 @@ Class Reordering {
 
 
 
-当然不行！ 因为在writer方法中，可能发生了重排序，y的写入动作可能发在x写入之前，这种情况下，线程B就有可能看到x的值还是0。
+当然不行！因为在writer方法中，可能发生了重排序，y的写入动作可能发在x写入之前，这种情况下，线程B就有可能看到x的值还是0。
 
 在Java内存模型中，描述了在多线程代码中，哪些行为是正确的、合法的，以及多线程之间如何进行通信，代码中变量的读写行为如何反应到内存、CPU缓存的底层细节。
 
@@ -226,7 +229,7 @@ Class Reordering {
 a是在栈内存中的，当main()方法执行结束，a就被清理了。但是你创建的内部类中的方法却可能在main()方法执行完成后再去执行，但是这时候局部变量已经不存在了，那怎么解决这个问题呢？ 
 因此实际上是在访问它的副本，而不是访问原始的局部变量。
 
-在Java的参数传递中，当基本类型作为参数传递时，传递的是值的拷贝，无论你怎么改变这个拷贝，原值是不会改变的；当对象作为参数传递时，传递的是对象的引用的拷贝，无论你怎么改变这个新的引用的指向，原来的引用是不会改变的（当然如果你通过这个引用改变了对象的内容，那么改变实实在在发生了）。知识点三，当final修饰基本类型变量时，不可更改其值，当final修饰引用变量时，不可更改其指向，只能更改其对象的内容。
+在Java的参数传递中，当基本类型作为参数传递时，传递的是值的拷贝，无论你怎么改变这个拷贝，原值是不会改变的；当对象作为参数传递时，传递的是对象的引用的拷贝，无论你怎么改变这个新的引用的指向，原来的引用是不会改变的（当然如果你通过这个引用改变了对象的内容，那么改变实实在在发生了）。而当final修饰基本类型变量时，不可更改其值，当final修饰引用变量时，不可更改其指向，只能更改其对象的内容。
 
 在Java中内部类会持有外部类的引用和方法中参数的引用，当反编译class文件后，内部类的class文件的构造函数参数中会传入外部类的对象以及方法内局部变量，不管是基本数据类型还是引用变量，如果重新赋值了，会导致内外指向的对象不一致，所以java就暴力的规定使用final，不能重新赋值。
 所以用final修饰实际上就是为了变量值(数据)的一致性。 这里所说的数据一致性，对引用变量来说是引用地址的一致性，对基本类型来说就是值的一致性。
@@ -247,9 +250,9 @@ a是在栈内存中的，当main()方法执行结束，a就被清理了。但是
 - [Where Has the Java PermGen Gone?](https://www.infoq.com/articles/Java-PERMGEN-Removed/)
 
 
-​		
+​   
 ---
 - 邮箱 ：charon.chui@gmail.com  
 - Good Luck! 
 
-	
+  
diff --git "a/JavaKnowledge/Java\345\271\266\345\217\221\347\274\226\347\250\213\344\271\213\345\216\237\345\255\220\346\200\247\343\200\201\345\217\257\350\247\201\346\200\247\344\273\245\345\217\212\346\234\211\345\272\217\346\200\247.md" "b/JavaKnowledge/Java\345\271\266\345\217\221\347\274\226\347\250\213\344\271\213\345\216\237\345\255\220\346\200\247\343\200\201\345\217\257\350\247\201\346\200\247\344\273\245\345\217\212\346\234\211\345\272\217\346\200\247.md"
index 1f3a021f..14d1a46c 100644
--- "a/JavaKnowledge/Java\345\271\266\345\217\221\347\274\226\347\250\213\344\271\213\345\216\237\345\255\220\346\200\247\343\200\201\345\217\257\350\247\201\346\200\247\344\273\245\345\217\212\346\234\211\345\272\217\346\200\247.md"
+++ "b/JavaKnowledge/Java\345\271\266\345\217\221\347\274\226\347\250\213\344\271\213\345\216\237\345\255\220\346\200\247\343\200\201\345\217\257\350\247\201\346\200\247\344\273\245\345\217\212\346\234\211\345\272\217\346\200\247.md"
@@ -23,14 +23,19 @@
 - 计算`a+b`        
 - 将计算结果写入内存       
     如果有两个线程`t1`,`t2`在进行这样的操作。`t1`在第二步做完之后还没来得及把数据写回内存就被线程调度器中断了，于是`t2`开始执行，`t2`执行完毕后`t1`又把没有完成的第三步做完。这个时候就出现了错误，
-    相当于`t2`的计算结果被无视掉了。所以上面的买碘片例子在同步`add`方法之前，实际结果总是小于预期结果的，因为很多操作都被无视掉了。                       
+    相当于`t2`的计算结果被无视掉了。所以上面的片例子在同步`add`方法之前，实际结果总是小于预期结果的，因为很多操作都被无视掉了。                       
     类似的，像`a++`这样的操作也都不具有原子性。所以在多线程的环境下一定要记得进行同步操作。   
 
 ## 可见性(Visibility)
 
 可见性指的是当一个线程修改了共享变量后，其他线程能够立即得知这个修改。
 
-在多核处理器中，如果多个线程对一个变量进行操作，但是这多个线程有可能被分配到多个处理器中运行，那么编译器会对代码进行优化，当线程要处理该变量时，多个处理器会将变量从主内存复制一份分别存储在自己的片上存储器中，等到进行完操作后，再赋值回主存。(这样做的好处是提高了运行的速度，因为在处理过程中多个处理器减少了同主内存通信的次数)；同样在单核处理器中这样由于备份造成的问题同样存在！这样的优化带来的问题之一是变量可见性——如果线程`t1`与线程`t2`分别被安排在了不同的处理器上面，那么`t1`与`t2`对于变量`A`的修改时相互不可见，如果`t1`给`A`赋值，然后`t2`又赋新值，那么`t2`的操作就将`t1`的操作覆盖掉了，这样会产生不可预料的结果。所以，即使有些操作时原子性的，但是如果不具有可见性，那么多个处理器中备份的存在就会使原子性失去意义。
+在多核处理器中，如果多个线程对一个变量进行操作，但是这多个线程有可能被分配到多个处理器中运行，那么编译器会对代码进行优化，
+当线程要处理该变量时，多个处理器会将变量从主内存复制一份分别存储在自己的片上存储器中，等到进行完操作后，再赋值回主存。
+(这样做的好处是提高了运行的速度，因为在处理过程中多个处理器减少了同主内存通信的次数)；
+同样在单核处理器中这样由于备份造成的问题同样存在！这样的优化带来的问题之一是变量可见性——如果线程`t1`与线程`t2`分别被安排在了不同
+的处理器上面，那么`t1`与`t2`对于变量`A`的修改时相互不可见，如果`t1`给`A`赋值，然后`t2`又赋新值，那么`t2`的操作就将`t1`的操作
+覆盖掉了，这样会产生不可预料的结果。所以，即使有些操作时原子性的，但是如果不具有可见性，那么多个处理器中备份的存在就会使原子性失去意义。
 
 volatile、synchronized、final都可以解决可见性问题。
 
@@ -38,7 +43,7 @@ volatile、synchronized、final都可以解决可见性问题。
 
 有序性：即程序执行的顺序按照代码的先后顺序执行。
 
-有序性简单来说就是程序代码执行的顺序是否按照我们编写代码的顺序执行，一般来说，为了提高性能，编译器和处理器会对指令做重排序，重排序分3类
+有序性简单来说就是程序代码执行的顺序是否按照我们编写代码的顺序执行，一般来说，为了提高性能，编译器和处理器会对指令做重排序， 重排序分3类
 
 - 编译器优化重排序，在不改变单线程程序语义的前提下，改变代码的执行顺序
 - 指令集并行的重排序，对于不存在数据依赖的指令，处理器可以改变语句对应指令的执行顺序来充分利用CPU资源
@@ -77,52 +82,53 @@ public class Singleton{
                 }
             }
         }
-	    return instance;
+        return instance;
     }
 }
 ```
 
 我们先看 instance=newSingleton() 的未被编译器优化的操作
 
-- 指令 1：分配一块内存 M；
-- 指令 2：在内存 M 上初始化 Singleton 对象；
-- 指令 3：然后 M 的地址赋值给 instance 变量。
+- 指令 1：分配一块内存M；
+- 指令 2：在内存M上初始化Singleton对象；
+- 指令 3：然后M的地址赋值给instance变量。
 
 编译器优化后的操作指令
 
-- 指令 1：分配一块内存 M；
-- 指令 2：将 M 的地址赋值给 instance 变量；
-- 指令 3：然后在内存 M 上初始化 Singleton 对象。
+- 指令 1：分配一块内存M；
+- 指令 2：将M的地址赋值给instance变量；
+- 指令 3：然后在内存M上初始化Singleton对象。
 
-现在有A，B两个线程，我们假设线程A先执行getInstance()方法，当执行编译器优化后的操作指令2时（此时候未完成对象的初始化），这时候发生了线程切换，那么线程B进入，刚好执行到第一次判断instance==nul会发现 instance不等于null了，所以直接返回instance，而此时的 instance 是没有初始化过的。
+现在有A，B两个线程，我们假设线程A先执行getInstance()方法，当执行编译器优化后的操作指令2时（此时候未完成对象的初始化），
+这时候发生了线程切换，那么线程B进入，刚好执行到第一次判断instance==nul会发现instance不等于null了，所以直接返回instance，
+而此时的instance是没有初始化过的。
 
-
-
-Java语言提供了volatile和synchronized两个关键字来保证线程之间操作的有序性，volatile关键字本身就包含了禁止指令重排序的语义，而synchronized则是由“一个变量在同一时刻只允许一条线程对其进行lock操作”这条规则来获得的，这个规则决定了持有同一个锁的两个同步块只能串行地进入。
+Java语言提供了volatile和synchronized两个关键字来保证线程之间操作的有序性，volatile关键字本身就包含了禁止指令重排序的语义，
+而synchronized则是由“一个变量在同一时刻只允许一条线程对其进行lock操作”这条规则来获得的，这个规则决定了持有同一个锁的两个同步块
+只能串行地进入。
 
 ## **先行发生原则：**
 
-如果Java内存模型中所有的有序性都只靠volatile和synchronized来完成，那么有一些操作将会变得很啰嗦，但是我们在编写Java并发代码的时候并没有感觉到这一点，这是因为Java语言中有一个“先行发生”(Happen-Before)的原则。这个原则非常重要，它是判断数据是否存在竞争，线程是否安全的主要依赖。
+如果Java内存模型中所有的有序性都只靠volatile和synchronized来完成，那么有一些操作将会变的很啰嗦，但是我们在编写Java并发代码的
+时候并没有感觉到这一点，这是因为Java语言中有一个“先行发生”(Happen-Before)的原则。这个原则非常重要，它是判断数据是否存在竞争，
+线程是否安全的主要依赖。
 
-先行发生原则是指Java内存模型中定义的两项操作之间的依序关系，如果说操作A先行发生于操作B，其实就是说发生操作B之前，操作A产生的影响能被操作B观察到，“影响”包含了修改了内存中共享变量的值、发送了消息、调用了方法等。下面是Java内存模型下一些”天然的“先行发生关系，这些先行发生关系无须任何同步器协助就已经存在，可以在编码中直接使用。如果两个操作之间的关系不在此列，并且无法从下列规则推导出来的话，它们就没有顺序性保障，虚拟机可以对它们进行随意地重排序。
+先行发生原则是指Java内存模型中定义的两项操作之间的依序关系，如果说操作A先行发生于操作B，其实就是说发生操作B之前，操作A产生的影响能
+被操作B观察到，“影响”包含了修改了内存中共享变量的值、发送了消息、调用了方法等。下面是Java内存模型下一些”天然的“先行发生关系，
+这些先行发生关系无须任何同步器协助就已经存在，可以在编码中直接使用。如果两个操作之间的关系不在此列，并且无法从下列规则推导出来的话，
+它们就没有顺序性保障，虚拟机可以对它们进行随意地重排序。
 
 - 程序次序规则(Pragram Order Rule)：在一个线程内，按照程序代码顺序，书写在前面的操作先行发生于书写在后面的操作。准确地说应该是控制流顺序而不是程序代码顺序，因为要考虑分支、循环结构。
-
 - 管程锁定规则(Monitor Lock Rule)：一个unlock操作先行发生于后面对同一个锁的lock操作。这里必须强调的是同一个锁，而”后面“是指时间上的先后顺序。
-
 - volatile变量规则(Volatile Variable Rule)：对一个volatile变量的写操作先行发生于后面对这个变量的读取操作，这里的”后面“同样指时间上的先后顺序。
-
 - 线程启动规则(Thread Start Rule)：Thread对象的start()方法先行发生于此线程的每一个动作。
-
 - 线程终于规则(Thread Termination Rule)：线程中的所有操作都先行发生于对此线程的终止检测，我们可以通过Thread.join()方法结束，Thread.isAlive()的返回值等作段检测到线程已经终止执行。
-
 - 线程中断规则(Thread Interruption Rule)：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生，可以通过Thread.interrupted()方法检测是否有中断发生。
-
 - 对象终结规则(Finalizer Rule)：一个对象初始化完成(构造方法执行完成)先行发生于它的finalize()方法的开始。
-
 - 传递性(Transitivity)：如果操作A先行发生于操作B，操作B先行发生于操作C，那就可以得出操作A先行发生于操作C的结论。
 
-一个操作”时间上的先发生“不代表这个操作会是”先行发生“，那如果一个操作”先行发生“是否就能推导出这个操作必定是”时间上的先发生“呢？也是不成立的，一个典型的例子就是指令重排序。所以时间上的先后顺序与先生发生原则之间基本没有什么关系，所以衡量并发安全问题一切必须以先行发生原则为准。
+一个操作”时间上的先发生“不代表这个操作会是”先行发生“，那如果一个操作”先行发生“是否就能推导出这个操作必定是”时间上的先发生“呢？也是不成立的，
+一个典型的例子就是指令重排序。所以时间上的先后顺序与先生发生原则之间基本没有什么关系，所以衡量并发安全问题一切必须以先行发生原则为准。
 
 ```java
 int i = 0;              
@@ -130,9 +136,13 @@ boolean flag = false;
 i = 1;                //语句1  
 flag = true;          //语句2
 ```
-上面代码定义了一个`int`型变量，定义了一个`boolean`类型变量，然后分别对两个变量进行赋值操作。从代码顺序上看，语句1是在语句2前面的，那么`JVM`在真正执行这段代码的时候会保证语句1一定会在语句2前面执行吗？
+上面代码定义了一个`int`型变量，定义了一个`boolean`类型变量，然后分别对两个变量进行赋值操作。从代码顺序上看，语句1是在语句2前面的，
+那么`JVM`在真正执行这段代码的时候会保证语句1一定会在语句2前面执行吗？
 不一定，为什么呢？这里可能会发生指令重排序`(Instruction Reorder)`。                      
-下面解释一下什么是指令重排序，一般来说，处理器为了提高程序运行效率，可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。比如上面的代码中，语句1和语句2谁先执行对最终的程序结果并没有影响，那么就有可能在执行过程中，语句2先执行而语句1后执行。但是要注意，虽然处理器会对指令进行重排序，但是它会保证程序最终结果会和代码顺序执行结果相同，那么它靠什么保证的呢？             
+下面解释一下什么是指令重排序，一般来说，处理器为了提高程序运行效率，可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序
+同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。比如上面的代码中，语句1和语句2谁先执行对最终的程序结果
+并没有影响，那么就有可能在执行过程中，语句2先执行而语句1后执行。但是要注意，虽然处理器会对指令进行重排序，但是它会保证程序最终结果会
+和代码顺序执行结果相同，那么它靠什么保证的呢？             
 再看下面一个例子:                
 
 ```java
@@ -158,9 +168,10 @@ while(!inited ){
 }
 doSomethingwithconfig(context);
 ```
-上面代码中，由于语句1和语句2没有数据依赖性，因此可能会被重排序。假如发生了重排序，在线程1执行过程中先执行语句2，而此时线程2会以为初始化工作已经完成，
-那么就会跳出while循环，去执行doSomethingwithconfig(context)方法，而此时context并没有被初始化，就会导致程序出错。
-从上面可以看出，指令重排序不会影响单个线程的执行，但是会影响到线程并发执行的正确性。也就是说，要想并发程序正确地执行，必须要保证原子性、可见性以及有序性。只要有一个没有被保证，就有可能会导致程序运行不正确。
+上面代码中，由于语句1和语句2没有数据依赖性，因此可能会被重排序。假如发生了重排序，在线程1执行过程中先执行语句2，而此时线程2会以为
+初始化工作已经完成， 那么就会跳出while循环，去执行doSomethingwithconfig(context)方法，而此时context并没有被初始化，
+就会导致程序出错。 从上面可以看出，指令重排序不会影响单个线程的执行，但是会影响到线程并发执行的正确性。也就是说，要想并发程序正确地执
+行，必须要保证原子性、可见性以及有序性。只要有一个没有被保证，就有可能会导致程序运行不正确。
 
 
 
@@ -168,4 +179,4 @@ doSomethingwithconfig(context);
 - 邮箱 ：charon.chui@gmail.com  
 - Good Luck! 
 
-	
+    
diff --git "a/JavaKnowledge/MD5\345\212\240\345\257\206.md" "b/JavaKnowledge/MD5\345\212\240\345\257\206.md"
index 0d2b6bce..62a8dd01 100644
--- "a/JavaKnowledge/MD5\345\212\240\345\257\206.md"
+++ "b/JavaKnowledge/MD5\345\212\240\345\257\206.md"
@@ -1,11 +1,11 @@
 MD5加密
-===
+=======
 
-`MD5`是一种不可逆的加密算法只能将原文加密，不能讲密文再还原去，原来把加密后将这个数组通过`Base64`给变成字符串，
+`MD5`是一种不可逆的加密算法只能将原文加密，不能将密文再还原回去，原来把加密后将这个数组通过`Base64`给变成字符串，
 这样是不严格的业界标准的做法是对其加密之后用每个字节`&15`然后就能得到一个`int`型的值，再将这个`int`型的值变成16进制的字符串.虽然MD5不可逆，
 但是网上出现了将常用的数字用`md5`加密之后通过数据库查询，所以`MD5`简单的情况下仍然可以查出来，一般可以对其多加密几次或者`&15`之后再和别的数运算等，
 这称之为*加盐*.
- 
+
 ```java
 public class MD5Utils {
     /**
@@ -35,6 +35,7 @@ public class MD5Utils {
 }
 ```
 
-----
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+---
+
+- 邮箱 ：charon.chui@gmail.com
+- Good Luck!
diff --git "a/JavaKnowledge/volatile\345\222\214Synchronized\345\214\272\345\210\253.md" "b/JavaKnowledge/volatile\345\222\214Synchronized\345\214\272\345\210\253.md"
index 9dd6ce0a..c4ed28a2 100644
--- "a/JavaKnowledge/volatile\345\222\214Synchronized\345\214\272\345\210\253.md"
+++ "b/JavaKnowledge/volatile\345\222\214Synchronized\345\214\272\345\210\253.md"
@@ -10,12 +10,10 @@
 
 这三种缓存的技术难度和制造成本是相对递减的，所以其容量也是相对递增的。
 
-那么，在有了多级缓存之后，程序的执行就变成了：    
+那么，在有了多级缓存之后，程序的执行就变成了：
 
 当CPU要读取一个数据时，首先从一级缓存中查找，如果没有找到再从二级缓存中查找，如果还是没有就从三级缓存或内存中查找。
 
-
-
 > 这就像一家创业公司，刚开始，创始人和员工之间工作关系其乐融融，但是随着创始人的能力和野心越来越大，逐渐和员工之间出现了差距，普通员工原来越跟不上CEO的脚步。老板的每一个命令，传到到基层员工之后，由于基层员工的理解能力、执行能力的欠缺，就会耗费很多时间。这也就无形中拖慢了整家公司的工作效率。
 >
 > 之后，这家公司开始设立中层管理人员，管理人员直接归CEO领导，领导有什么指示，直接告诉管理人员，然后就可以去做自己的事情了。管理人员负责去协调底层员工的工作。因为管理人员是了解手下的人员以及自己负责的事情的。所以，大多数时候，公司的各种决策，通知等，CEO只要和管理人员之间沟通就够了。
@@ -32,11 +30,11 @@
 
 随着计算机能力不断提升，开始支持多线程。那么问题就来了。我们分别来分析下单线程、多线程在单核CPU、多核CPU中的影响。
 
-**单线程。**cpu核心的缓存只被一个线程访问。缓存独占，不会出现访问冲突等问题。
+**单线程**：cpu核心的缓存只被一个线程访问。缓存独占，不会出现访问冲突等问题。
 
-**单核CPU，多线程。**进程中的多个线程会同时访问进程中的共享数据，CPU将某块内存加载到缓存后，不同线程在访问相同的物理地址的时候，都会映射到相同的缓存位置，这样即使发生线程的切换，缓存仍然不会失效。但由于任何时刻只能有一个线程在执行，因此不会出现缓存访问冲突。
+**单核CPU，多线程**：进程中的多个线程会同时访问进程中的共享数据，CPU将某块内存加载到缓存后，不同线程在访问相同的物理地址的时候，都会映射到相同的缓存位置，这样即使发生线程的切换，缓存仍然不会失效。但由于任何时刻只能有一个线程在执行，因此不会出现缓存访问冲突。
 
-**多核CPU，多线程。**每个核都至少有一个L1  缓存。多个线程访问进程中的某个共享内存，且这多个线程分别在不同的核心上执行，则每个核心都会在各自的caehe中保留一份共享内存的缓冲。由于多核是可以并行的，可能会出现多个线程同时写各自的缓存的情况，而各自的cache之间的数据就有可能不同。
+**多核CPU，多线程**：每个核都至少有一个L1缓存。多个线程访问进程中的某个共享内存，且这多个线程分别在不同的核心上执行，则每个核心都会在各自的caehe中保留一份共享内存的缓冲。由于多核是可以并行的，可能会出现多个线程同时写各自的缓存的情况，而各自的cache之间的数据就有可能不同。
 
 在CPU和主存之间增加缓存，在多线程场景下就可能存在**缓存一致性问题**，也就是说，在多核CPU中，每个核的自己的缓存中，关于同一个数据的缓存内容可能不一致。
 
@@ -50,7 +48,7 @@
 
 ### 处理器优化和指令重排
 
-上面提到在在CPU和主存之间增加缓存，在多线程场景下会存在**缓存一致性问题**。除了这种情况，还有一种硬件问题也比较重要。那就是为了使处理器内部的运算单元能够尽量的被充分利用，处理器可能会对输入代码进行乱序执行处理。这就是**处理器优化**。
+上面提到在CPU和主存之间增加缓存，在多线程场景下会存在**缓存一致性问题**。除了这种情况，还有一种硬件问题也比较重要。那就是为了使处理器内部的运算单元能够尽量的被充分利用，处理器可能会对输入代码进行乱序执行处理。这就是**处理器优化**。
 
 除了现在很多流行的处理器会对代码进行优化乱序处理，很多编程语言的编译器也会有类似的优化，比如Java虚拟机的即时编译器（JIT）也会做**指令重排**。
 
@@ -76,7 +74,7 @@
 
 所以，为了保证并发编程中可以满足原子性、可见性及有序性。有一个重要的概念，那就是——内存模型。
 
-**为了保证共享内存的正确性（可见性、有序性、原子性），内存模型定义了共享内存系统中多线程程序读写操作行为的规范。**通过这些规则来规范对内存的读写操作，从而保证指令执行的正确性。它与处理器有关、与缓存有关、与并发有关、与编译器也有关。他解决了CPU多级缓存、处理器优化、指令重排等导致的内存访问问题，保证了并发场景下的一致性、原子性和有序性。
+**为了保证共享内存的正确性（可见性、有序性、原子性），内存模型定义了共享内存系统中多线程程序读写操作行为的规范**。通过这些规则来规范对内存的读写操作，从而保证指令执行的正确性。它与处理器有关、与缓存有关、与并发有关、与编译器也有关。他解决了CPU多级缓存、处理器优化、指令重排等导致的内存访问问题，保证了并发场景下的一致性、原子性和有序性。
 
 内存模型解决并发问题主要采用两种方式：**限制处理器优化**和**使用内存屏障**。
 
@@ -86,31 +84,20 @@
 
 Java内存模型规定了所有的变量都存储在主内存中，每条线程还有自己的工作内存，线程的工作内存中保存了该线程中是用到的变量的主内存副本拷贝，线程对变量的所有操作都必须在工作内存中进行，而不能直接读写主内存(每个线程都分配有单独的处理器缓存，用这些处理器缓存去缓存一些数据，就可以不用再次访问主内存去获取相应的数据，这样就可以提高效率)。不同的线程之间也无法直接访问对方工作内存中的变量，线程间变量的传递均需要自己的工作内存和主存之间进行数据同步进行。而JMM就作用于工作内存和主存之间数据同步过程。他规定了如何做数据同步以及什么时候做数据同步。对于共享普通变量来说，约定了变量在工作内存中发生变化了之后，必须要回写到工作内存(**迟早要回写但并非马上回写**)，*但对于volatile变量则要求工作内存中发生变化之后，必须马上回写到工作内存，而线程读取volatile变量的时候，必须马上到工作内存中去取最新值而不是读取本地工作内存的副本*，此规则保证了前面所说的“当线程A对变量X进行了修改后，在线程A后面执行的其他线程能看到变量X的变动”。
 
-
-
-
-
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/java_mm.png)
 
 这里面提到的主内存和工作内存，读者可以简单的类比成计算机内存模型中的主存和缓存的概念。特别需要注意的是，主内存和工作内存与JVM内存结构中的Java堆、栈、方法区等并不是同一个层次的内存划分，无法直接类比。《深入理解Java虚拟机》中认为，如果一定要勉强对应起来的话，从变量、主内存、工作内存的定义来看，主内存主要对应于Java堆中的对象实例数据部分。工作内存则对应于虚拟机栈中的部分区域。
 
 **所以，再来总结下，JMM是一种规范，目的是解决由于多线程通过共享内存进行通信时，存在的本地内存数据不一致、编译器会对代码指令重排序、处理器会对代码乱序执行等带来的问题。**
 
-
-
 ## volatile
 
-
-
 作用：使变量在多个线程间可见（可见性），能够保证volatile变量的可见性，但不能保证volatile变量复合操作的原子性。
 
 `Java`语言规范中指出：为了获得最佳速度，允许线程保存共享成员变量的私有拷贝，而在这个过程中,变量的新值对其他线程是不可见的.而且只当线程进入或者离开同步代码块时才与共享成员变量
-的原始值对比。这样当多个线程同时与某个对象交互时，就必须要注意到要让线程及时的得到共享成员变量的变化。也就是说每个线程都有一个自己的本地内存空间，在线程执行时，先把变量从主内存读取到线程自己的本地内存空间，然后再对该变量进行操作，当对该变量操作完后，在某个时间再把变量刷新回主内存。 
-
-
+的原始值对比。这样当多个线程同时与某个对象交互时，就必须要注意到要让线程及时的得到共享成员变量的变化。也就是说每个线程都有一个自己的本地内存空间，在线程执行时，先把变量从主内存读取到线程自己的本地内存空间，然后再对该变量进行操作，当对该变量操作完后，在某个时间再把变量刷新回主内存。
 
 - volatile如何实现内存可见性。深入来说：通过加入**内存屏障**和**禁止重排序优化**来实现的
-
 - 对volatile变量执行写操作时，会在写操作后加入一条store屏障指令
 - 对volatile变量执行读操作时，会在读操作前加入一条load屏障指令
 
@@ -119,27 +106,20 @@ Java内存模型规定了所有的变量都存储在主内存中，每条线程
 1. **更新主内存。**
 2. **向CPU总线发送一个修改信号。**
 
-
-
 **这时监听CPU总线的处理器会收到这个修改信号后，如果发现修改的数据自己缓存了，就把自己缓存的数据失效掉。这样其它线程访问到这段缓存时知道缓存数据失效了，需要从主内存中获取。这样所有线程中的共享变量i就达到了一致性。**
 
 ![img](https://raw.githubusercontent.com/CharonChui/Pictures/master/java_mm_1.jpg)
 
 **所以volatile也可以看作线程间通信的一种廉价方式。**
 
-
-
-
 ### volatile关键字的非原子性
 
 所谓原子性，就是某系列的操作步骤要么全部执行，要么都不执行。
 
-比如，变量的自增操作 i++，分三个步骤： 
+比如，变量的自增操作 i++，分三个步骤：
 
 - 从内存中读取出变量 i 的值
-
 - 将i的值加1
-
 - 将加1后的值写回内存
 
 这说明 i++ 并不是一个原子操作。因为，它分成了三步，有可能当某个线程执行到了第②时被中断了，那么就意味着只执行了其中的两个步骤，没有全部执行。
@@ -152,9 +132,7 @@ volatile修饰的变量并不保证对它的操作（自增）具有原子性。
 
 **综上，仅靠volatile不能保证线程的安全性。（原子性）**
 
- 
-
-###  volatile禁止指令重排序
+### volatile禁止指令重排序
 
 代码书写的顺序与实际执行的顺序不同，指令重排序是编译器或处理器为了提高程序性能而做的优化
 
@@ -170,9 +148,9 @@ volatile禁止指令重排序，典型的应用是单例模式中的双重检查
 public class DoubleCheckSingleton {
 
 	private volatile static DoubleCheckSingleton singleton;
-	
+
 	private DoubleCheckSingleton() {}
-	
+
 	public static DoubleCheckSingleton getInstance() {
 		if(singleton == null) {
 			synchronized (singleton) {
@@ -183,7 +161,7 @@ public class DoubleCheckSingleton {
 		}
 		return singleton;
 	}
-	
+
 }
 ```
 
@@ -205,8 +183,6 @@ ctorInstance(memory);  //2.初始化对象
 
 指令重排序后，在多线程情况下，可能会发生A线程正在new对象，执行了3，但还没有执行2。此时B线程进入方法获取单例对象，执行同步代码块外的非空判断，发现变量非空，但此时对象还未初始化，B线程获取到的是一个未被初始化的对象。使用volatile修饰后，禁止指令重排序。即，先初始化对象后，再设置instance指向刚分配的内存地址。这样就就不存在获取到未被初始化的对象。
 
-
-
 ## synchronized
 
 **synchronized实现同步的基础是：Java中的每个对象都可作为锁。所以synchronized锁的都对象，只不过不同形式下锁的对象不一样。**
@@ -222,14 +198,10 @@ ctorInstance(memory);  //2.初始化对象
 - 然而，当一个线程访问`object`的一个`synchronized(this)`同步代码块时，另一个线程仍然可以访问该`object`中的非`synchronized(this)`同步代码块。
 - 尤其关键的是，当一个线程访问`object`的一个`synchronized(this)`同步代码块时，其他线程对`object`中所有其它`synchronized(this)`同步代码块的访问将被阻塞。
 
-
-
 **在JVM规范中规定了synchronized是通过Monitor对象来实现方法和代码块的同步，但两者实现细节有点一不样。代码块同步是使用monitorenter和monitorexit指令，方法同步是使用另外一种方法实现，细节JVM规范并没有详细说明。但是，方法的同步同样可以使用这两指令来实现。**
 
 **monitorenter指令是编译后插入到同步代码块的开始位置，而monitorexit指令是插入到方法结束处和异常处。JVM保证了每个monitorenter都有对应的monitorexit。任何一个对象都有一个monitor与之关联，当且一个monitor被持有后，对象将处于锁定状态。线程执行到monitorenter指令时，将会尝试获取对象对应monitor的所有权，即尝试获得对象的锁。**
 
-
-
 ### synchronized缺点
 
 #### 有性能损耗
@@ -242,8 +214,6 @@ Monitor其实是一种同步工具，也可以说是一种同步机制，它通
 >
 > 通常提供singal机制：允许正持有“许可”的线程暂时放弃“许可”，等待某个谓词成真（条件变量），而条件成立后，当前进程可以“通知”正在等待这个条件变量的线程，让他可以重新去获得运行许可。
 
-
-
 #### 产生阻塞
 
 基于Monitor对象，当多个线程同时访问一段同步代码时，首先会进入Entry Set，当有一个线程获取到对象的锁之后，才能进行The  Owner区域，其他线程还会继续在Entry Set等待。并且当某个线程调用了wait方法后，会释放锁并进入Wait Set等待。
@@ -252,20 +222,13 @@ Monitor其实是一种同步工具，也可以说是一种同步机制，它通
 
 所以，synchronize实现的锁本质上是一种阻塞锁，也就是说多个线程要排队访问同一个共享对象。
 
-
-
 ## volatile与Synchronized的区别：
 
-
-
 - synchronized通过加锁的方式，使得其在需要原子性、可见性和有序性这三种特性的时候都可以作为其中一种解决方案，看起来是“万能”的。的确，大部分并发控制操作都能使用synchronized来完成。
-
 - volatile通过在volatile变量的操作前后插入内存屏障的方式，保证了变量在并发场景下的可见性和有序性。
-
 - volatile关键字是无法保证原子性的，而synchronized通过monitorenter和monitorexit两个指令，可以保证被synchronized修饰的代码在同一时间只能被一个线程访问，即可保证不会出现CPU时间片在多个线程间切换，即可保证原子性
-
 - volatile是变量修饰符，而synchronized则作用于一段代码或方法。
-- volatile只是在线程内存和“主”内存间同步某个变量的值；而synchronized通过锁定和解锁某个监视器同步所有变量的值。显然synchronized要比volatile消耗更多资源。 
+- volatile只是在线程内存和“主”内存间同步某个变量的值；而synchronized通过锁定和解锁某个监视器同步所有变量的值。显然synchronized要比volatile消耗更多资源。
 
 一句话，那什么时候才能用volatile关键字呢？（千万记住了，重要事情说三遍，感觉这句话过时了）
 
@@ -277,23 +240,12 @@ Monitor其实是一种同步工具，也可以说是一种同步机制，它通
 
 比如上面 count++ ，是获取-计算-写入三步操作，也就是依赖当前值的，所以不能靠volatile 解决问题。
 
-
-
-
-
-参考:  
+参考:
 
 - [再有人问你Java内存模型是什么，就把这篇文章发给他](https://www.hollischuang.com/archives/2550)
 - [原子性、可见性以及有序性](https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E5%8E%9F%E5%AD%90%E6%80%A7%E3%80%81%E5%8F%AF%E8%A7%81%E6%80%A7%E4%BB%A5%E5%8F%8A%E6%9C%89%E5%BA%8F%E6%80%A7.md)
 
-
-
 ---
 
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
-
-
-
-
-
+- 邮箱 ：charon.chui@gmail.com
+- Good Luck!
diff --git "a/JavaKnowledge/\347\272\277\347\250\213\346\261\240\347\256\200\344\273\213.md" "b/JavaKnowledge/\347\272\277\347\250\213\346\261\240\347\256\200\344\273\213.md"
index 1ec4f548..27fff875 100644
--- "a/JavaKnowledge/\347\272\277\347\250\213\346\261\240\347\256\200\344\273\213.md"
+++ "b/JavaKnowledge/\347\272\277\347\250\213\346\261\240\347\256\200\344\273\213.md"
@@ -7,24 +7,24 @@
 
 - 在什么情况下使用线程池？ 
     - 单个任务处理的时间比较短 
-    - 将需处理的任务的数量大 
+    - 将要处理的任务的数量大 
 
     假设一个服务器完成一项任务所需时间为：`T1`创建线程时间，`T2`在线程中执行任务的时间，`T3`销毁线程时间。如果:`T1 + T3`远大于`T2`，则可以采用线程池，以提高服务器性能。
 
 
 - 一个线程池包括以下四个基本组成部分:      
 
-    - 线程池管理器（`ThreadPool`）:用于创建并管理线程池，包括 创建线程池，销毁线程池，添加新任务
-    - 工作线程（`PoolWorker`）:线程池中线程，在没有任务时处于等待状态，可以循环的执行任务
+    - 线程池管理器（`ThreadPool`）:用于创建并管理线程池，包括创建线程池，销毁线程池，添加新任务
+    - 工作线程（`PoolWorker`）:线程池中的线程，在没有任务时处于等待状态，可以循环的执行任务
     - 任务接口（`Task`）:每个任务必须实现的接口，以供工作线程调度任务的执行，它主要规定了任务的入口，任务执行完后的收尾工作，任务的执行状态等
     - 任务队列（`TaskQueue`）:用于存放没有处理的任务。提供一种缓冲机制。
 
 - 使用线程池的好处:        
     - 降低资源消耗。通过重复利用减少在创建和销毁线程上所花的时间以及系统资源的开销 
     - 提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，
-	     还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。如不使用线程池，有可能造成系统创建大量线程而导致消耗完系统内存以及”过度切换”。 
-	- 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
-	
+         还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。如不使用线程池，有可能造成系统创建大量线程而导致消耗完系统内存以及”过度切换”。 
+    - 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
+    
 - 工作流程            
     线程池的任务就在于负责这些线程的创建，销毁和任务处理参数传递、唤醒和等待。
     - 创建若干线程，置入线程池
@@ -33,22 +33,22 @@
     - 否则新建一个线程，并置入线程池，并执行上一步
     - 如果创建失败或者线程池已满，根据设计策略选择返回错误或将任务置入处理队列，等待处理
     - 销毁线程池
-	
+    
 - 风险           
     虽然线程池是构建多线程应用程序的强大机制，但使用它并不是没有风险的。
-	用线程池构建的应用程序容易遭受任何其它多线程应用程序容易遭受的所有并发风险，诸如同步错误和死锁，
-	它还容易遭受特定于线程池的少数其它风险，诸如与池有关的死锁、资源不足和线程泄漏。
-	
+    用线程池构建的应用程序容易遭受任何其它多线程应用程序容易遭受的所有并发风险，诸如同步错误和死锁，
+    它还容易遭受特定于线程池的少数其它风险，诸如与池有关的死锁、资源不足和线程泄漏。
+    
 - 资源不足                  
-    线程池的一个优点在于：相对于其它替代调度机制而言，它们通常执行得很好。但只有恰当地调整了线程池大小时才是这样的。
-	线程消耗包括内存和其它系统资源在内的大量资源。除了`Thread`对象所需的内存之外，每个线程都需要两个可能很大的执行调用堆栈。
-	除此以外`JVM`可能会为每个`Java`线程创建一个本机线程，这些本机线程将消耗额外的系统资源。最后虽然线程之间切换的调度开销很小，
-	但如果有很多线程，环境切换也可能严重地影响程序的性能。
+    线程池的一个优点在于：相对于其它替代调度机制而言，它们通常执行的很好。但只有恰当地调整了线程池大小时才是这样的。
+    线程消耗包括内存和其它系统资源在内的大量资源。除了`Thread`对象所需的内存之外，每个线程都需要两个可能很大的执行调用堆栈。
+    除此以外`JVM`可能会为每个`Java`线程创建一个本机线程，这些本机线程将消耗额外的系统资源。最后虽然线程之间切换的调度开销很小，
+    但如果有很多线程，环境切换也可能严重地影响程序的性能。
     如果线程池太大，那么被那些线程消耗的资源可能严重地影响系统性能。在线程之间进行切换将会浪费时间，
-	而且使用超出比您实际需要的线程可能会引起资源匮乏问题，因为池线程正在消耗一些资源，而这些资源可能会被其它任务更有效地利用。
-	除了线程自身所使用的资源以外，服务请求时所做的工作可能需要其它资源，例如`JDBC`连接、套接字或文件。
-	这些也都是有限资源，有太多的并发请求也可能引起失效，例如不能分配`JDBC`连接。	
-	
+    而且使用超出比您实际需要的线程可能会引起资源匮乏问题，因为池线程正在消耗一些资源，而这些资源可能会被其它任务更有效地利用。
+    除了线程自身所使用的资源以外，服务请求时所做的工作可能需要其它资源，例如`JDBC`连接、套接字或文件。
+    这些也都是有限资源，有太多的并发请求也可能引起失效，例如不能分配`JDBC`连接。   
+    
 
 线程池的使用
 ---
@@ -265,4 +265,4 @@ public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
 - 邮箱 ：charon.chui@gmail.com  
 - Good Luck! 
 
-	
+    
diff --git "a/Tools&Library/Markdown\345\255\246\344\271\240\346\211\213\345\206\214.md" "b/Tools&Library/Markdown\345\255\246\344\271\240\346\211\213\345\206\214.md"
index 8df1f5a3..1fc3e4f8 100644
--- "a/Tools&Library/Markdown\345\255\246\344\271\240\346\211\213\345\206\214.md"
+++ "b/Tools&Library/Markdown\345\255\246\344\271\240\346\211\213\345\206\214.md"
@@ -3,7 +3,7 @@ Markdown学习手册
 
 #### 一. 简单功能
 功能 | 效果 | Markdown代码 | 备注
-:--|:--|:--|:--
+---|---|---|---
 粗体 | **粗体** | `**粗体**` | 两边加**
 斜体 | _斜体_ | `_斜体_` | 两边加_
 中划线 | ~~中划线~~ | `~~中划线~~` | 两边加~~
@@ -146,20 +146,6 @@ def hello():
 单元格1|单元格2
 单元格3|单元格4
 
-而且还可以通过在表头分隔符中添加 `:` 来决定单元格的对齐方向，以下代码：  
-```
-表头1|表头2|表头3
-:--|:--:|--:
-左1|中1|右1
-左2|中2|右2
-```
-效果为：  
-
-表头1|表头2|表头3
-:--|:--:|--:
-左1|中1|右1
-左2|中2|右2
-    
 ##### 6. 特殊字符转义 
 如果需要在正文里使用特殊字符的话，可以用 `\` 来转义  
 
diff --git "a/Tools&Library/\346\200\247\350\203\275\344\274\230\345\214\226\347\233\270\345\205\263\345\267\245\345\205\267.md" "b/Tools&Library/\346\200\247\350\203\275\344\274\230\345\214\226\347\233\270\345\205\263\345\267\245\345\205\267.md"
index 1084d903..0770d1bb 100644
--- "a/Tools&Library/\346\200\247\350\203\275\344\274\230\345\214\226\347\233\270\345\205\263\345\267\245\345\205\267.md"
+++ "b/Tools&Library/\346\200\247\350\203\275\344\274\230\345\214\226\347\233\270\345\205\263\345\267\245\345\205\267.md"
@@ -1,166 +1,135 @@
 性能优化相关工具
-===
+有关性能优化的文章请参考性能优化和布局优化
 
-有关性能优化的文章请参考[性能优化][1]和[布局优化][2]
+DDMS(百宝箱)
+查看进程的内存使用
+DDMS可以让你查看到一个进程使用的堆内存。
 
+在Device了表选择你想查看的进程。
+点击Update Heap按钮来开启查看进程堆内存信息。
+在Heap页面，点击Cause GC来执行垃圾回收。
+在列表中点击一个对象类型来查看它所分配的内存大小。
+追踪对象的内存分配情况
+在Device了表选择你想查看的进程。
+在Allocation Tracker页面，点击Start Tracking按钮来开始追踪。
+点击Get Allocations来查看从你点击Start Tracking之后分配内存的对象列表。 你可以再次点击Get Allocations来添加新分配内存的对象列表。
+停止追踪或者清除数据可以点击Stop Tracking按钮。
+在列表中单独点击一行来查看详细的信息。
+使用文件系统
+DDMS提供了一个文件浏览器来供你查看、拷贝、删除文件。
 
-### DDMS(百宝箱)
+在Device页面，选中你想要查看的设备。
+从设备中拷贝文件，用文件浏览器选择文件后点击Pull file按钮。
+拷贝文件到设备中，点击Push file按钮。
+检查线程信息
+Thread页面可以显示指定进程中当前正在运行的线程。
 
-##### 查看进程的内存使用
+在Device页面，选择想要查看的进程。
+点击Update Threads按钮。
+在Thread页面，你可以查看对应的线程信息。
+启动方法分析
+方法分析可以追踪一个方法的特定信息，例如调用数量，执行时间、耗时等。如果想要更精确的控制想要收集的数据，可以使用startMethodTracing()和stopMethodTracing()方法。
 
-`DDMS`可以让你查看到一个进程使用的堆内存。    
-1. 在`Device`了表选择你想查看的进程。
-2. 点击`Update Heap`按钮来开启查看进程堆内存信息。
-3. 在`Heap`页面，点击`Cause GC`来执行垃圾回收。
-4. 在列表中点击一个对象类型来查看它所分配的内存大小。   
+在你开始使用方法分析之前请知晓如下限制:
 
-##### 追踪对象的内存分配情况     
+在Android 2.1及以前的设备必须有SD卡，并且你的应用必须有写入SD卡的权限。
+在Android 2.2及以后的设备中不需要SD卡，trace log文件会直接被导入到开发机上。
+开启方法分析:
 
-1. 在`Device`了表选择你想查看的进程。
-2. 在`Allocation Tracker`页面，点击`Start Tracking`按钮来开始追踪。
-3. 点击`Get Allocations`来查看从你点击`Start Tracking`之后分配内存的对象列表。 你可以再次点击`Get Allocations`来添加新分配内存的对象列表。 
-4. 停止追踪或者清除数据可以点击`Stop Tracking`按钮。 
-5. 在列表中单独点击一行来查看详细的信息。
+在Device页面，选择想要开启方法分析的进程。
+点击Start Method Profiling按钮。
+在Android 4.4及以后，可以选择trace_based profiling或者基本的sample-based profiling选项。在之前的版本智能使用trace-based profiling。
+在应用中操作界面来执行你想要分析的方法。
+点击Stop Method Profiling按钮。DDMS会停止分析并且将在Start Method Profiling和Stop Method Profiling中间手机的方法分析数据使用Traceview打开。
+使用网络流量工具
+从Android 4.0开始,DDMS包含了一个网络使用情况的页面来支持跟踪应用的网络请求。
 
-##### 使用文件系统
+如图:
 
-`DDMS`提供了一个文件浏览器来供你查看、拷贝、删除文件。
-1. 在`Device`页面，选中你想要查看的设备。
-2. 从设备中拷贝文件，用文件浏览器选择文件后点击`Pull file`按钮。
-3. 拷贝文件到设备中，点击`Push file`按钮。
+image。
 
-##### 检查线程信息  
+通过检测数据交互的频繁性以及在每次连接中数据的传递量，你可以知道应用中具体可以做的更好更高效的地方。 想要更好的查看引起数据交互的地方，可以使用TrafficsStats这个API，它也可以使用setThreadStatsTag()方法来设置数据使用情况的tag，
 
+首先要讲到的是Systrace，之前在淘宝面试的时候被问到，如有查找UI绘制卡顿的问题，我没答上来。早点知道Systrace就好了(当然只知道工具是不够的，也要懂得里面的原理)。
 
-`Thread`页面可以显示指定进程中当前正在运行的线程。 
+Systrace
+Systrace有什么用呢？官方文档中有一片文章的标题是：使用Systrace进行UI性能分析。
 
-1. 在`Device`页面，选择想要查看的进程。 
-2. 点击`Update Threads`按钮。   
-3. 在`Thread`页面，你可以查看对应的线程信息。 
+在应用程序开发的过程中，你需要检查用户交互是否平滑流畅，运行在稳定的60fps。如果中间出了些问题，导致某一帧延迟，我们想要解决该问题的第一步就是理解系统如何操作的。
 
-##### 启动方法分析
+Systrace工具可以让你来手机和观察整个android设备的时间信息，也称为trace。它会显示每个时间点上的CPU消耗图，显示每个线程在显示的内容以及每个进程当时在做的操作。
 
-方法分析可以追踪一个方法的特定信息，例如调用数量，执行时间、耗时等。如果想要更精确的控制想要收集的数据，可以使用`startMethodTracing()`和`stopMethodTracing()`方法。    
+在使用Systracv来分析应用之前，你需要手机应用的trace log信息。生成的trace能够让你清晰的观察系统在该时间内所做的任何事情。
 
-在你开始使用方法分析之前请知晓如下限制:    
+生成Trace
+为了能创建一个trace，你必须要执行如下几个操作。 首先，你要有一个Android 4.1及以上的设备。将该设备设置为debugging，连接你的设备并且安装应用。有些类型的信息，特别是一些硬盘的活动和内核工作队列，需要设备获取root权限才可以。 然而，大多数的Systrace log的数据只需要设备开启开发者debugging就可以了。
 
-- 在`Android 2.1`及以前的设备必须有`SD`卡，并且你的应用必须有写入`SD`卡的权限。 
-- 在`Android 2.2`及以后的设备中不需要`SD`卡，`trace log`文件会直接被导入到开发机上。
+Systrace可以通过命令行或者图形化界面的方式来运行，在Studio中打开Android Device Monitor然后选择Systracv图标image。
 
-开启方法分析:    
+下面以命令行的方式为例，这里只讲解一下Android 4.3及以上的使用方式:
 
-1. 在`Device`页面，选择想要开启方法分析的进程。
-2. 点击`Start Method Profiling`按钮。
-3. 在`Android 4.4`及以后，可以选择`trace_based profiling`或者基本的`sample-based profiling`选项。在之前的版本智能使用`trace-based profiling`。
-4. 在应用中操作界面来执行你想要分析的方法。 
-5. 点击`Stop Method Profiling`按钮。`DDMS`会停止分析并且将在`Start Method Profiling`和`Stop Method Profiling`中间手机的方法分析数据使用`Traceview`打开。   
+确保设备已经通过USB连接并且开启了debugging模式。
+设置一些参数并执行trace命令，例如:
+$ cd android-sdk/platform-tools/systrace
+$ python systrace.py --time=10 -o mynewtrace.html sched gfx view wm
+执行完上面的命令后就会在sdk/platform-tools/systrace/mynewtrace.html生成对应的html文件。
 
+在设备上执行一些你想要trace的过程。
+悲剧了，生成了对应的html文件，但是我死活打不开。打开是白屏，折腾了我半天，最后终于找到了解决方法:
 
-##### 使用网络流量工具   
+Firstly, if anyone is using Chrome v50.0+ on OS X, just try this please.
 
-从`Android 4.0`开始,`DDMS`包含了一个网络使用情况的页面来支持跟踪应用的网络请求。
+open chrome browser and go to "chrome://tracing" in the tracing page, click load and select the systrace generated html file. Secondly, I think it's a bug which is confirmed by Google.
 
-如图:   
+OK了。
 
-![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/ddms-network.png?raw=true)。 
-
-通过检测数据交互的频繁性以及在每次连接中数据的传递量，你可以知道应用中具体可以做的更好更高效的地方。
-想要更好的查看引起数据交互的地方，可以使用`TrafficsStats`这个`API`，它也可以使用`setThreadStatsTag()`方法来设置数据使用情况的`tag`，
-
-首先要讲到的是`Systrace`，之前在淘宝面试的时候被问到，如有查找`UI`绘制卡顿的问题，我没答上来。早点知道`Systrace`就好了(当然只知道工具是不够的，也要懂得里面的原理)。
-
-### Systrace    
-
-`Systrace`有什么用呢？官方文档中有一片文章的标题是：使用`Systrace`进行`UI`性能分析。    
-
-在应用程序开发的过程中，你需要检查用户交互是否平滑流畅，运行在稳定的60fps。如果中间出了些问题，导致某一帧延迟，我们想要解决该问题的第一步就是理解系统如何操作的。     
-
-`Systrace`工具可以让你来手机和观察整个`android`设备的时间信息，也称为`trace`。它会显示每个时间点上的`CPU`消耗图，显示每个线程在显示的内容以及每个进程当时在做的操作。
-
-在使用`Systracv`来分析应用之前，你需要手机应用的`trace log`信息。生成的`trace`能够让你清晰的观察系统在该时间内所做的任何事情。 
-
-##### 生成Trace    
-
-为了能创建一个`trace`，你必须要执行如下几个操作。 首先，你要有一个`Android 4.1`及以上的设备。将该设备设置为`debugging`，连接你的设备并且安装应用。有些类型的信息，特别是一些硬盘的活动和内核工作队列，需要设备获取`root`权限才可以。 然而，大多数的`Systrace log`的数据只需要设备开启开发者`debugging`就可以了。     
-
-`Systrace`可以通过命令行或者图形化界面的方式来运行，在`Studio`中打开`Android Device Monitor`然后选择`Systracv`图标![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/systrace-button.png?raw=true)。 
-
-
-下面以命令行的方式为例，这里只讲解一下`Android 4.3`及以上的使用方式:     
-
-- 确保设备已经通过`USB`连接并且开启了`debugging`模式。 
-- 设置一些参数并执行`trace`命令，例如:      
-    ```
-    $ cd android-sdk/platform-tools/systrace
-    $ python systrace.py --time=10 -o mynewtrace.html sched gfx view wm
-    ```  
-    执行完上面的命令后就会在`sdk/platform-tools/systrace/mynewtrace.html`生成对应的`html`文件。 
-- 在设备上执行一些你想要`trace`的过程。     
-
-悲剧了，生成了对应的`html`文件，但是我死活打不开。打开是白屏，折腾了我半天，最后终于找到了解决方法:   
-
->  Firstly, if anyone is using Chrome v50.0+ on OS X, just try this please.
-
-> open chrome browser and go to "chrome://tracing"
-> in the tracing page, click load and select the systrace generated html file.
-> Secondly, I think it's a bug which is confirmed by Google.
-
-`OK`了。 
-
-
-![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/systrace_file.png?raw=true =)。 
+image。
 
 看不懂！！！
 
-##### 分析Trace
+分析Trace
+用浏览器打开上面生成的mynewtrace.html。 下面为了能明显的说明，我就用官网提供的例子来说明了。
 
-用浏览器打开上面生成的`mynewtrace.html`。    下面为了能明显的说明，我就用官网提供的例子来说明了。   
+查看Frames
+从打开的文件中我们能看到每个应用都有一行frame的圆圈来标示渲染的帧，通常都是绿色的。黄色或者红的圆圈标示超过了我们对保障60fps所需的16毫秒绘制时间。。 可以在文件上面按w键来放大文件以便能更好的观看查找。
 
-###### 查看Frames
-从打开的文件中我们能看到每个应用都有一行`frame`的圆圈来标示渲染的帧，通常都是绿色的。黄色或者红的圆圈标示超过了我们对保障60fps所需的16毫秒绘制时间。。 可以在文件上面按`w`键来放大文件以便能更好的观看查找。   
-> ***提示:***在文件上面按`?`键可以查看对应的快捷键。  
+***提示:***在文件上面按?键可以查看对应的快捷键。
 
-![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/frame-unselected.png?raw=true)。 
+image。
 
-在`Android 5.0`以上的设备上，显示工作呗分为`UI Thread`和`Render Thread`。在之前的版本，所有工作都是在`UI Thread`进行的。 点击某个单独的`frame`图标来查看它们所需的时间。
+在Android 5.0以上的设备上，显示工作呗分为UI Thread和Render Thread。在之前的版本，所有工作都是在UI Thread进行的。 点击某个单独的frame图标来查看它们所需的时间。
 
-###### 观看Alerts    
+观看Alerts
+Systracv会自动分析trace过程的时间，并且通过alerts提示该展现问题，以及建议如何处理。
 
-`Systracv`会自动分析`trace`过程的时间，并且通过`alerts`提示该展现问题，以及建议如何处理。    
+image
 
-![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/frame-selected.png?raw=true) 
+如上图所示，在你点击一个比较慢的frame时，下面就会显示一个alert。在这种情况下，它直说可能是ListView服用以及重复渲染的问题。 如果你发现UI Thread做了太多的工作，你可以使用TraceView进行代码分析，来找到具体哪些操作导致了消耗时间。
 
-如上图所示，在你点击一个比较慢的`frame`时，下面就会显示一个`alert`。在这种情况下，它直说可能是`ListView`服用以及重复渲染的问题。 如果你发现`UI Thread`做了太多的工作，你可以使用`TraceView`进行代码分析，来找到具体哪些操作导致了消耗时间。
+如下，你也可以通过点击窗口右边的Alerts来查看当前所有的alert。这样会直接展开Alert窗口。
 
-如下，你也可以通过点击窗口右边的`Alerts`来查看当前所有的`alert`。这样会直接展开`Alert`窗口。   
+image
 
-![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/frame-selected-alert-tab.png?raw=true)
+下面我们以另外一个例子来分析一下它的Frame：
 
-下面我们以另外一个例子来分析一下它的`Frame`：    
+我们点击某一红色frame来查看这一阵的一些相关警告:
+image 可以看到这里说耗时32毫秒，这已经远远超过了16毫秒的绘制时间。 我们可以通过Description来查看描述内容。
+下面是另外一个渲染过慢的例子:
 
-我们点击某一红色`frame`来查看这一阵的一些相关警告:   
-![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/systrace-frame-zoomin.png?raw=true)
-可以看到这里说耗时32毫秒，这已经远远超过了16毫秒的绘制时间。 我们可以通过`Description`来查看描述内容。   
-下面是另外一个渲染过慢的例子:     
+image 从上图，我们发现了Scheduling delay的警告，加起来能看到总的绘制时间大约是19毫秒。
+Scheduling delay的意思是调度延迟，也就是说一个县城在处理这部分操作时，在很长时间内没有被分配到CPU上面进行运算，这样就导致了很长时间内没有完成操作。 我们选择这一帧中最长的一块，来观察下:
+image
 
-![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/systrace-2-frame.png?raw=true)
-从上图，我们发现了`Scheduling delay`的警告，加起来能看到总的绘制时间大约是19毫秒。   
-`Scheduling delay`的意思是调度延迟，也就是说一个县城在处理这部分操作时，在很长时间内没有被分配到`CPU`上面进行运算，这样就导致了很长时间内没有完成操作。    我们选择这一帧中最长的一块，来观察下:    
-![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/systrace-2-slice.png?raw=true)
+我们在上图看到了Wall duration，他代表着这一块开始到结束的总耗时。而在CPU Duration这里显示了CPU在处理该部分消耗的时间。 很明显，真个区域用了18毫秒，但是CPU实际处理只用了4毫秒，也就是说剩下的14毫秒就可能有问题了。
+image
 
-我们在上图看到了`Wall duration`，他代表着这一块开始到结束的总耗时。而在`CPU Duration`这里显示了`CPU`在处理该部分消耗的时间。 很明显，真个区域用了18毫秒，但是`CPU`实际处理只用了4毫秒，也就是说剩下的14毫秒就可能有问题了。     
-![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/systrace-2-cpu.png?raw=true)
+可以看到，4个线程都比较忙。
 
-可以看到，4个线程都比较忙。  
+选择其中一个线程来查看是哪个应用在使用它，这里看到了一个包名为com.udinic.keepbusyapp的应用。也就是说由于另外一个应用占用了CPU,，导致了我们的应用未能获取到足够的CPU资源。
 
-选择其中一个线程来查看是哪个应用在使用它，这里看到了一个包名为`com.udinic.keepbusyapp`的应用。也就是说由于另外一个应用占用了`CPU`,，导致了我们的应用未能获取到足够的`CPU`资源。      
+追踪代码
+在Android 4.3以上你可以使用Trace类来在代码中添加(很熟悉有木有，在看源码的时候经常看到)。这样能查看到此时你的应用线程都做了哪些操作。 下面的代码展示了如何使用Trace类来追踪两个代码块部分:
 
-
-##### 追踪代码
-
-在`Android 4.3`以上你可以使用`Trace`类来在代码中添加(很熟悉有木有，在看源码的时候经常看到)。这样能查看到此时你的应用线程都做了哪些操作。 
-下面的代码展示了如何使用`Trace`类来追踪两个代码块部分:   
-```java
 public void ProcessPeople() {
     Trace.beginSection("ProcessPeople");
     try {
@@ -181,240 +150,190 @@ public void ProcessPeople() {
         Trace.endSection(); // ends "ProcessPeople"
     }
 }
-```
-
-### Traceview
+Traceview
+Traceview是一个性能测试工具，展示了所有方法的运行时间。
 
-`Traceview`是一个性能测试工具，展示了所有方法的运行时间。    
-> Traceview is a graphical viewer for execution logs that you create by using the Debug class to log tracing information in your code. Traceview can help you debug your application and profile its performance.
+Traceview is a graphical viewer for execution logs that you create by using the Debug class to log tracing information in your code. Traceview can help you debug your application and profile its performance.
 
+创建Trace文件
+想要使用Traceview你需要创建一个包含你想分析部分的trace信息的log文件。 有两种方式来生成trace logs：
 
-##### 创建Trace文件  
+在你测试的类中添加startMethodTracing()和stopMethodTracing()的代码，来指定开始和结束获取trace信息。这种方式是非常精确的，因为你可以在代码中指定开始和结束的位置。
 
-想要使用`Traceview`你需要创建一个包含你想分析部分的`trace`信息的`log`文件。 
-有两种方式来生成`trace logs`：    
+使用DDMS中的方法来生成。这种方式就不太精确。虽然这种方式不能精确的指定起始和结束位置，但是如果在你无法修改源代码或者不需要精确时间的时候是非常有用的。
 
-- 在你测试的类中添加`startMethodTracing()`和`stopMethodTracing()`的代码，来指定开始和结束获取`trace`信息。这种方式是非常精确的，因为你可以在代码中指定开始和结束的位置。     
+在开始生成trace log信息时，你需要知道如下的限制条件:
 
-- 使用`DDMS`中的方法来生成。这种方式就不太精确。虽然这种方式不能精确的指定起始和结束位置，但是如果在你无法修改源代码或者不需要精确时间的时候是非常有用的。 
+如果你在测试代码中使用，你的应用必须要用WRITE_EXTERNAL_STORAGE的权限。
 
-在开始生成`trace log`信息时，你需要知道如下的限制条件:    
+如果你使用DDMS生成:
 
-- 如果你在测试代码中使用，你的应用必须要用`WRITE_EXTERNAL_STORAGE`的权限。 
-- 如果你使用`DDMS`生成:     
+Android 2.1之前必须有SD卡，并且你的应用也要有写入SD卡的权限。
+Android 2.2之后不需要SD卡，trace log文件会直接生成到你的开发机上。
+在测试代码中调用startMethodTracing()方法的时候，你可以指定系统生成trace文件的名字。结束的时候调用stopMethodTracing()方法。这些方法开始和结束时贯穿整个虚拟中的。例如你可以在你activity的onCreate()方法中调用startMethodTracing()方法，然后在activity的onDestroy()方法中调用stopMethodTracing()方法。
 
-    - `Android 2.1`之前必须有`SD`卡，并且你的应用也要有写入`SD`卡的权限。 
-    - `Android 2.2`之后不需要`SD`卡，`trace log`文件会直接生成到你的开发机上。   
-
-在测试代码中调用`startMethodTracing()`方法的时候，你可以指定系统生成`trace`文件的名字。结束的时候调用`stopMethodTracing()`方法。这些方法开始和结束时贯穿整个虚拟中的。例如你可以在你`activity`的`onCreate()`方法中调用`startMethodTracing()`方法，然后在`activity`的`onDestroy()`方法中调用`stopMethodTracing()`方法。   
-```java
     // start tracing to "/sdcard/calc.trace"
     Debug.startMethodTracing("calc");
     // ...
     // stop tracing
     Debug.stopMethodTracing();
-```
-
-在调用`startMethodTracing()`方法的时候，系统创建一个名为`<trace-base-name>.trace`的文件。它包含方法的二进制`trace`数据和一个线程与方法名的对应集合。   
-然后系统就开始生成`trace`数据，直到调用`stopMethodTracing()`方法。如果在你调用`stopMethodTracing()`方法之前系统已经达到了最大的缓冲大小，系统就会停止`trace`并且在控制台发出一个通知。     
-
-##### 拷贝Trace文件到电脑上
+在调用startMethodTracing()方法的时候，系统创建一个名为<trace-base-name>.trace的文件。它包含方法的二进制trace数据和一个线程与方法名的对应集合。
+然后系统就开始生成trace数据，直到调用stopMethodTracing()方法。如果在你调用stopMethodTracing()方法之前系统已经达到了最大的缓冲大小，系统就会停止trace并且在控制台发出一个通知。
 
-在模拟器或者机器上生成`<trace-base-name>.trace`文件后，你需要拷贝他们到你的电脑上，你可以使用`adb pull`命令来拷贝：   
-`adb pull /sdcard/calc.trace /tmp`
+拷贝Trace文件到电脑上
+在模拟器或者机器上生成<trace-base-name>.trace文件后，你需要拷贝他们到你的电脑上，你可以使用adb pull命令来拷贝：
+adb pull /sdcard/calc.trace /tmp
 
-##### 在Traceview中查看trace文件    
+在Traceview中查看trace文件
+运行Traceview并且查看trace文件:
 
-运行`Traceview`并且查看`trace`文件:     
+打开Android Device Monitor。
+在Android Device Monitor的状态栏中点击DDMS并且选择一个进程。
+点击Start Method Profiling图标开始查看。
+在查看完后点击Stop Method Profiling图标来显示traceview。
+大体的样子如下:
 
-1. 打开`Android Device Monitor`。
-2. 在`Android Device Monitor`的状态栏中点击`DDMS`并且选择一个进程。 
-3. 点击`Start Method Profiling`图标开始查看。
-4. 在查看完后点击`Stop Method Profiling`图标来显示`traceview`。  
+image
 
-大体的样子如下:    
-
-![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/traceview_1.png?raw=true) 
-
-##### Traceview Layout     
-
-如果你有一个`trace log`文件(通过添加`tracing`代码或者用DDMS生成)，你可以把该文件加载到`Traceview`中，这将会把`log`数据显示为两部分:    
-
-- `timeline panel`-展示了每个线程和方法的起始和结束
-- `profile panel`-提供了一个方法中的执行内容的简述
-
-##### Timeline Panel
+Traceview Layout
+如果你有一个trace log文件(通过添加tracing代码或者用DDMS生成)，你可以把该文件加载到Traceview中，这将会把log数据显示为两部分:
 
+timeline panel-展示了每个线程和方法的起始和结束
+profile panel-提供了一个方法中的执行内容的简述
+Timeline Panel
 每个线程都会以时间从左往右递增的方式在单独的一行中显示它的执行情况，
 
-![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/traceview_timeline.png?raw=true)
-
-##### Profile Panel
-
-显示了一个方法所消耗的时间的概要情况。在表格中会同时显示`inclusive`和`exclusive`的时间。`Exclusive`的时间是该方法所消耗的时间。`InClusive`的时间是该方法消耗的时间加上任何调的方法所消耗的时间。我们简单的将调用的方法叫做`parents`，被调用的方法叫做`children`。如果一个方法被调用，它会显示对应的`parents`和`children`。`parents`会显示一个紫色的背景，`children`会显示一个黄色的背景。最后一列显示了该方法所调用的总数的调用数。在下面的图中我们能看到一共有14个地方调用了`LoadListener.nativeFinished()` . 
+image
 
-![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/traceview_profile.png?raw=true)
+Profile Panel
+显示了一个方法所消耗的时间的概要情况。在表格中会同时显示inclusive和exclusive的时间。Exclusive的时间是该方法所消耗的时间。InClusive的时间是该方法消耗的时间加上任何调的方法所消耗的时间。我们简单的将调用的方法叫做parents，被调用的方法叫做children。如果一个方法被调用，它会显示对应的parents和children。parents会显示一个紫色的背景，children会显示一个黄色的背景。最后一列显示了该方法所调用的总数的调用数。在下面的图中我们能看到一共有14个地方调用了LoadListener.nativeFinished() .
 
-- Name 方法名
-- Inclusive CPU Time， CPU在处理该方法以及所有子方法(被它调用的所有方法)所消耗的时间。
-- Exlusive CPU Time, CPU在处理该方法的耗时。
-- Inclusive/Exclusive Real Time， 从方法开始执行到执行结束的耗时。 
-- Cal+Rec, 这个方法被调用的次数，以及递归被调用的次数。 
-- CPU/Real time per Call, 在处理这个方法时的`CPU`耗时的平均值。
+image
 
-![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/traceview-getview.png?raw=true)
+Name 方法名
+Inclusive CPU Time， CPU在处理该方法以及所有子方法(被它调用的所有方法)所消耗的时间。
+Exlusive CPU Time, CPU在处理该方法的耗时。
+Inclusive/Exclusive Real Time， 从方法开始执行到执行结束的耗时。
+Cal+Rec, 这个方法被调用的次数，以及递归被调用的次数。
+CPU/Real time per Call, 在处理这个方法时的CPU耗时的平均值。
+image
 
-上图中`getView`方法被调用了12次，每次`CPU`消耗2.8秒，但是每次调用的总耗时是162秒，这里肯定有问题。
-而看看这个方法的children，我们可以看到这其中的每个方法在耗时方面是如何分布的。Thread.join()方法战局了98%的inclusive real time。这个方法在等待另一个线程结束的时候被调用。在Children中另外一个方法就是Tread.start()方法，而之所以整个方法耗时很长，我猜测是因为在getView()方法中启动了线程并且在等待它的结束。
+上图中getView方法被调用了12次，每次CPU消耗2.8秒，但是每次调用的总耗时是162秒，这里肯定有问题。 而看看这个方法的children，我们可以看到这其中的每个方法在耗时方面是如何分布的。Thread.join()方法战局了98%的inclusive real time。这个方法在等待另一个线程结束的时候被调用。在Children中另外一个方法就是Tread.start()方法，而之所以整个方法耗时很长，我猜测是因为在getView()方法中启动了线程并且在等待它的结束。
 
 但是这个线程在哪儿？
 
 我们在getView()方法中并不能看到这个线程做了什么，因为这段逻辑不在getView()方法之中。于是我找到了Thread.run()方法，就是在线程被创建出来时候所运行的方法。而跟随这个方法一路向下，我找到了问题的元凶。
 
-![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/traceview-thread.png?raw=true)
+image
 
 我发现了BgService.doWork()方法的每次调用花费了将近14毫秒，并且有四十个这东西！而且getView()中还有可能调用多次这个方法，这就解释了为什么getView()方法执行时间如此之长。这个方法让CPU长时间的保持在了繁忙状态。而看看Exclusive CPU time，我们可以看到他占据了80%的CPU时间！此外，根据Exclusive CPU time排序，可以帮我们更好的定位那些耗时很长的方法，而他们很有可能就是造成性能问题的罪魁祸首。
 
 关注这些耗时方法，例如getView()，View#onDraw()等方法，可以很好的帮助我们寻找为什么应用运行缓慢的原因。但有些时候，还会有一些其他的东西来占用宝贵的CPU资源，而这些资源如果被运用在UI的绘制上，也许我们的应用会更加流畅。Garbage Collector垃圾回收机制会不时的运行，回收那些没用的对象，通常来讲这不会影响我们在前台运行的程序。但如果GC被运行的过于频繁，他同样可以影响我们应用的执行效率。而我们该如何知道回收的是否过于频繁了呢…
 
-### Monitors
+Monitors
+在Android Studio中下方的Android Monitor中可以看到Monitors工具栏，它能不断的去检测内存、网络、CPU的消耗情况。
 
-在`Android Studio`中下方的`Android Monitor`中可以看到`Monitors`工具栏，它能不断的去检测内存、网络、CPU的消耗情况。
+image
 
-![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/monitor.png?raw=true)
+我们可以直接点击Dump Java Heap或者Call GC等按钮，以便更好的去观察内存的使用情况。点击后会生成一个.hprof的文件。生成后直接使用Studio打开.hprof文件即可。
 
-我们可以直接点击`Dump Java Heap`或者`Call GC`等按钮，以便更好的去观察内存的使用情况。点击后会生成一个`.hprof`的文件。生成后直接使用`Studio`打开`.hprof`文件即可。  
+说到这里插一嘴,有关Java垃圾回收机制请参考
 
-说到这里插一嘴,[有关Java垃圾回收机制请参考][3]
+image 在左边能看到所有堆内存中的实例。后面会显示他所占用的内存大小。
 
-![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/dump_href.png?raw=true)
-在左边能看到所有堆内存中的实例。后面会显示他所占用的内存大小。
-   
-对于内存泄漏的分析可以使用`MAT`或者`LeakCanary`来进行。这里就不仔细说了。   
+对于内存泄漏的分析可以使用MAT或者LeakCanary来进行。这里就不仔细说了。
 
-##### 不同虚拟机的内存管理 
+不同虚拟机的内存管理
+Android Monitor使用的Virtual Machine(VM):
 
-`Android Monitor`使用的`Virtual Machine(VM)`:    
+Android 4.3(API Level 18)及以前的版本使用Dalvik VM .
+Android 4.4(API Level 19)默认使用Dalvik VM，Android RunTime(ART)是可选的。
+Android 4.3(API Level 18)及更高的版本使用ART VM.
+虚拟之执行垃圾回收。Dalvik虚拟机使用一个标记和清除垃圾收集方案。ART虚拟机使用分代收集算法与标记和清楚手机算法相结合的方式。 Logcat会显示一些垃圾回收相关的信息。
 
-- `Android 4.3(API Level 18)`及以前的版本使用`Dalvik VM` .
-- `Android 4.4(API Level 19)`默认使用`Dalvik VM`，`Android RunTime(ART)`是可选的。
-- `Android 4.3(API Level 18)`及更高的版本使用`ART VM`.
+GPU使用情况
+上面也显示了GPU的使用情况，这里要说一句，如果想要显示它，必须要在手机的开发者中心中开启GPU显示配置文件选项，将其设置为显示与adb shell dumpsys gfxinfo。然后再点击Studio中的按钮重新开始就可以看到了。 每一条线意味着一帧被绘制出来了。而线的颜色又代表不同的阶段：
 
-虚拟之执行垃圾回收。Dalvik虚拟机使用一个标记和清除垃圾收集方案。`ART`虚拟机使用分代收集算法与标记和清楚手机算法相结合的方式。 `Logcat`会显示一些垃圾回收相关的信息。     
+Draw(蓝色)代表着View.onDraw()方法。如果这个值很高就说明可能是该View比较复杂。 在这个环节会创建/刷新DisplayList中的对象，这些对象在后面会被转换成GPU可以明白的OpenGL命令。而这个值比较高可能是因为view比较复杂，需要更多的时间去创建他们的display list，或者是因为有太多的view在很短的时间内被创建。
 
-##### GPU使用情况
+Prepare(紫色)，从Android 6.0开始，一个新的线程被引进来帮助UI线程进行绘制。 这个线程叫做Render Thread。它负责转换它负责转换display list到OpenGL命令并且送至GPU。在这过程中，UI线程可以继续开始处理后面的帧。而在UI线程将所有资源传递给RenderThread过程中所消耗的时间，就是紫色阶段所消耗的时间。如果在这过程中有很多的资源都要进行传递，display list会变得过多过于沉重，从而导致在这一阶段过长的耗时。
 
-上面也显示了`GPU`的使用情况，这里要说一句，如果想要显示它，必须要在手机的开发者中心中开启`GPU显示配置文件`选项，将其设置为显示与`adb shell dumpsys gfxinfo`。然后再点击`Studio`中的按钮重新开始就可以看到了。 每一条线意味着一帧被绘制出来了。而线的颜色又代表不同的阶段：    
+Process(红色) 执行Display list中的内容并创建OpenGL命令。如果有过多或者过于复杂的display list需要执行的话，那么这阶段会消耗较长的时间，因为这样的话会有很多的view被重绘。而重绘往往发生在界面的刷新或是被移动出了被覆盖的区域。
 
-- Draw(蓝色)代表着`View.onDraw()`方法。如果这个值很高就说明可能是该`View`比较复杂。 在这个环节会创建/刷新DisplayList中的对象，这些对象在后面会被转换成GPU可以明白的OpenGL命令。而这个值比较高可能是因为view比较复杂，需要更多的时间去创建他们的display list，或者是因为有太多的view在很短的时间内被创建。
-- Prepare(紫色)，从`Android 6.0`开始，一个新的线程被引进来帮助`UI`线程进行绘制。 这个线程叫做`Render Thread`。它负责转换它负责转换display list到OpenGL命令并且送至GPU。在这过程中，UI线程可以继续开始处理后面的帧。而在UI线程将所有资源传递给RenderThread过程中所消耗的时间，就是紫色阶段所消耗的时间。如果在这过程中有很多的资源都要进行传递，display list会变得过多过于沉重，从而导致在这一阶段过长的耗时。
+Execute (黄色) – 发送OpenGL命令到GPU。这个阶段是一个阻塞调用，因为CPU在这里只会发送一个含有一些OpenGL命令的缓冲区给GPU，并且等待GPU返回空的缓冲区以便再次传递下一帧的OpenGL命令。而这些缓冲区的总量是一定的，如果GPU太过于繁忙，那么CPU则会去等待下一个空缓冲区。所以，如果我们看到这一阶段耗时比较长，那可能是因为GPU过于繁忙的绘制UI，而造成这个的原因则可能是在短时间内绘制了过于复杂的view。
 
-- Process(红色) 执行Display list中的内容并创建OpenGL命令。如果有过多或者过于复杂的display list需要执行的话，那么这阶段会消耗较长的时间，因为这样的话会有很多的view被重绘。而重绘往往发生在界面的刷新或是被移动出了被覆盖的区域。
-
-- Execute (黄色) – 发送OpenGL命令到GPU。这个阶段是一个阻塞调用，因为CPU在这里只会发送一个含有一些OpenGL命令的缓冲区给GPU，并且等待GPU返回空的缓冲区以便再次传递下一帧的OpenGL命令。而这些缓冲区的总量是一定的，如果GPU太过于繁忙，那么CPU则会去等待下一个空缓冲区。所以，如果我们看到这一阶段耗时比较长，那可能是因为GPU过于繁忙的绘制UI，而造成这个的原因则可能是在短时间内绘制了过于复杂的view。
-
-- Measure/Layout(绿色) 代表`Measure`和`Layout`的时间。 
-
-### Hierarchy Viewer
+Measure/Layout(绿色) 代表Measure和Layout的时间。
 
+Hierarchy Viewer
 布局分析工具，非常常用。
 
-在`Android Device Monitor`中打开`Hierarchy Viewer`即可。
-
-- 连接你的手机或者模拟器。 
-    出于安全性考虑，`Hierarchy Viewer`只能连接开发者版的系统的手机。 
-- 运行程序，并且让界面显示出来。
-- 启动`hierarchy view`工具，接着就能看到左边栏显示出了对应的设备，展开后可以看到一些组件的名称。这个页面包含了应用的界面以及系统的界面。选择你的应用中想要查看的界面直接双击就可以了。    
-
-![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/gettingstarted_image005.png?raw=true)
-如果你的界面显示的不是这个样子，少一些东西的话，你可以使用`Window>Reset Perspective`来重置样式。 
-
+在Android Device Monitor中打开Hierarchy Viewer即可。
 
-但是我并打不开。   
-如果你的手机是`Android 4.1`及以上版本你必须要在你的电脑上设置一个`ANDROID_HVPROTO`DE 环境变量才可以。
+连接你的手机或者模拟器。 出于安全性考虑，Hierarchy Viewer只能连接开发者版的系统的手机。
+运行程序，并且让界面显示出来。
+启动hierarchy view工具，接着就能看到左边栏显示出了对应的设备，展开后可以看到一些组件的名称。这个页面包含了应用的界面以及系统的界面。选择你的应用中想要查看的界面直接双击就可以了。
+image 如果你的界面显示的不是这个样子，少一些东西的话，你可以使用Window>Reset Perspective来重置样式。
 
-- Windows 
-    增加一个名为`ANDROID_HVPROTO`值为`ddm`的环境变量就可以了。 
-- Mac 
-    - 打开`.bash_profile`
-        - `touch .bash_profile`创建
-        - `open -e .bash_profile`打开
-    - 添加    
-        ```java 
-        #Hierarchy Viewer Variable              
-        export ANDROID_HVPROTO=ddm
-        ```
-    - `source .bash_profile`
+但是我并打不开。
+如果你的手机是Android 4.1及以上版本你必须要在你的电脑上设置一个ANDROID_HVPROTODE 环境变量才可以。
 
-如果配置完成后仍然不能用的话，你可以:   
+Windows 增加一个名为ANDROID_HVPROTO值为ddm的环境变量就可以了。
+Mac
+打开.bash_profile
+touch .bash_profile创建
+open -e .bash_profile打开
+添加
+#Hierarchy Viewer Variable              
+export ANDROID_HVPROTO=ddm
+source .bash_profile
+如果配置完成后仍然不能用的话，你可以:
 
-- 关闭`Android Studio`.
-- 执行`add kill-server`，然后`adb start-server`.
-- 通过命令行开始`hierarchyviewer`.
+关闭Android Studio.
+执行add kill-server，然后adb start-server.
+通过命令行开始hierarchyviewer.
+好了，我们直接打开自己的页面进行查看布局吧(有点慢)。
+它是介个样子滴 ：
+image
 
-好了，我们直接打开自己的页面进行查看布局吧(有点慢)。   
-它是介个样子滴 ：     
-![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/hierarchy_vierwe_page.png?raw=true)
+我们可以看到所有结构，点击对一个的节点，能直接看到该界面的UI效果，并展示该布局包含多少个View，以及该布局measure,draw,layout所消耗的时间。选中Show Extras选项可以看到在右下角看到界面效果。
 
-我们可以看到所有结构，点击对一个的节点，能直接看到该界面的`UI`效果，并展示该布局包含多少个`View`，以及该布局`measure,draw,layout`所消耗的时间。选中`Show Extras`选项可以看到在右下角看到界面效果。   
+选中要查看的节点后点击Profile Node选项，可以看到如下界面:
 
-选中要查看的节点后点击`Profile Node`选项，可以看到如下界面:    
+image
 
-![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/hierarchy_profile_node.png?raw=true)
+可以看到每个布局都出现了三个点。有不同的颜色,从左到右这三个点分别表示:
 
-可以看到每个布局都出现了三个点。有不同的颜色,从左到右这三个点分别表示:   
+左边的点代表Draw阶段。
+中间的点代表了Layout阶段。
+右边的点代表了Execute阶段。
+这三个点有分别对应了pipeline中的不同阶段，如下图:
+image
 
-- 左边的点代表`Draw`阶段。
-- 中间的点代表了`Layout`阶段。
-- 右边的点代表了`Execute`阶段。
+不同的颜色代表不同的性能:
 
-这三个点有分别对应了`pipeline`中的不同阶段，如下图:    
-![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/gettingstarted_image015.png?raw=true)
+绿色代表渲染的非常快，至少是其他View的一半。
+黄色代表View渲染比最后那一半的View快。
+红色代表View渲染是几乎是在最慢的那部分中间。
+Hierarchy Viewer测量的是相对的表现能力，所以总会有一个红色的节点，它并不意味者该View一定是绘制的太慢。
 
-不同的颜色代表不同的性能:    
+过度绘制
+在开发者选项中将调试GPU过度绘制设置为显示过度绘制区域，就能看到程序的绘制情况。
+过度绘制往往发生在我们需要在一个东西上面绘制另外一个东西，例如在一个红色的背景上画一个黄色的按钮。那么GPU就需要先画出红色背景，再在他上面绘制黄色按钮，此时过度绘制就是不可避免的了。如果我们有太多层需要绘制，那么则会过度的占用GPU导致我们每帧消耗的时间超过16毫秒。 这些过度绘制可能发生在我们给Activity或Fragment设置了全屏的背景，同时又给ListView以及ListView的条目设置了背景色。而通过只设置一次背景色即可解决这样的问题。
 
-- 绿色代表渲染的非常快，至少是其他`View`的一半。
-- 黄色代表`View`渲染比最后那一半的`View`快。
-- 红色代表`View`渲染是几乎是在最慢的那部分中间。
-
-
-`Hierarchy Viewer`测量的是相对的表现能力，所以总会有一个红色的节点，它并不意味者该`View`一定是绘制的太慢。 
-
-### 过度绘制
-
-在开发者选项中将调试GPU过度绘制设置为显示过度绘制区域，就能看到程序的绘制情况。  
-过度绘制往往发生在我们需要在一个东西上面绘制另外一个东西，例如在一个红色的背景上画一个黄色的按钮。那么GPU就需要先画出红色背景，再在他上面绘制黄色按钮，此时过度绘制就是不可避免的了。如果我们有太多层需要绘制，那么则会过度的占用GPU导致我们每帧消耗的时间超过16毫秒。
-这些过度绘制可能发生在我们给Activity或Fragment设置了全屏的背景，同时又给ListView以及ListView的条目设置了背景色。而通过只设置一次背景色即可解决这样的问题。
-
-注意：默认的主题会为你指定一个默认的全屏背景色，如果你的activity又一个不透平的背景盖住了默认的背景色，那么你可以移除主题默认的背景色，这样也会移除一层的过度绘制。这可以通过配置主题配置或是通过代码的方法，在onCreate()方法中调用getWindow().setBackgroundDrawable(null)方法来实现。
-![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/overdraw-gif.gif?raw=true)
-
-
-### Hardware Acceleration
+注意：默认的主题会为你指定一个默认的全屏背景色，如果你的activity又一个不透平的背景盖住了默认的背景色，那么你可以移除主题默认的背景色，这样也会移除一层的过度绘制。这可以通过配置主题配置或是通过代码的方法，在onCreate()方法中调用getWindow().setBackgroundDrawable(null)方法来实现。 image
 
+Hardware Acceleration
 在Honeycomb版本中引入了硬件加速（Hardware Accleration）后，我们的应用在绘制的时候就有了全新的绘制模型。它引入了DisplayList结构，用来记录View的绘制命令，以便更快的进行渲染。但还有一些很好的功能开发者们往往会忽略或者使用不当——View layers。
 
-使用View layers（硬件层），我们可以将view渲染入一个非屏幕区域缓冲区（off-screen buffer，前面透明度部分提到过），并且根据我们的需求来操控它。这个功能主要是针对动画，因为它能让复杂的动画效果更加的流畅。而不使用硬件层的话，View会在动画属性（例如coordinate, scale, alpha值等）改变之后进行一次刷新。而对于相对复杂的view，这一次刷新又会连带它所有的子view进行刷新，并各自重新绘制，相当的耗费性能。使用View layers，通过调用硬件层，GPU直接为我们的view创建一个结构，并且不会造成view的刷新。而我们可以在避免刷新的情况下对这个结构进行进行很多种的操作，例如x/y位置变换，旋转，透明度等等。总之，这意味着我们可以对一个让一个复杂view执行动画的同时，又不会刷新！这会让动画看起来更加的流畅。
-在阅读了ViewPager的源码后，我发现了在滑动的时候会自动为左右两页启动一个硬件层，并且在滑动结束后移除掉。
+使用View layers（硬件层），我们可以将view渲染入一个非屏幕区域缓冲区（off-screen buffer，前面透明度部分提到过），并且根据我们的需求来操控它。这个功能主要是针对动画，因为它能让复杂的动画效果更加的流畅。而不使用硬件层的话，View会在动画属性（例如coordinate, scale, alpha值等）改变之后进行一次刷新。而对于相对复杂的view，这一次刷新又会连带它所有的子view进行刷新，并各自重新绘制，相当的耗费性能。使用View layers，通过调用硬件层，GPU直接为我们的view创建一个结构，并且不会造成view的刷新。而我们可以在避免刷新的情况下对这个结构进行进行很多种的操作，例如x/y位置变换，旋转，透明度等等。总之，这意味着我们可以对一个让一个复杂view执行动画的同时，又不会刷新！这会让动画看起来更加的流畅。 在阅读了ViewPager的源码后，我发现了在滑动的时候会自动为左右两页启动一个硬件层，并且在滑动结束后移除掉。
 
 在两页间滑动的时候创建硬件层也是可以理解的，但对我来说小有不幸。通常来讲加入硬件层是为了让ViewPager的滑动更加流畅，毕竟它们相对复杂。
 
-
 是的，但是再使用硬件layers的时候还是有几点要牢记在心：
 
-- 回收 – 硬件层会占用GPU中的一块内存。只在必要的时候使用他们，比如动画，并且事后注意回收。例如在上面ObjectAnimator的例子中，我们增加了一个动画结束监听以便在动画结束后可以移除硬件层。而在Property animator的例子中，我们使用了withLayers()，这会在动画开始时候自动创建硬件层并且在结束的时候自动移除。
-- 如果你在调用了硬件View layers后改变了View，那么会造成硬件硬件层的刷新并且再次重头渲染一遍view到非屏幕区域缓存中。这种情况通常发生在我们使用了硬件层暂时还不支持的属性（目前为止，硬件层只针对以下几种属性做了优化：otation、scale、x/y、translation、pivot和alpha）。例如，如果你另一个view执行动画，并且使用硬件层，在屏幕滑动他们的同时改变他的背景颜色，这就会造成硬件层的持续刷新。而以硬件层的持续刷新所造成的性能消耗来说，可能让它在这里的使用变得并不那么值。
-
-有关如何使用`Hardware Layer`请参考之前写的文章:[通过Hardware Layer提高动画性能][4]
-
-
-
-[1]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/%E6%80%A7%E8%83%BD%E4%BC%98%E5%8C%96.md "性能优化"
-[2]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/%E5%B8%83%E5%B1%80%E4%BC%98%E5%8C%96.md "布局优化"
-[3]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/JVM%E5%9E%83%E5%9C%BE%E5%9B%9E%E6%94%B6%E6%9C%BA%E5%88%B6.md "有关Java垃圾回收机制请参考"
-[4]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/%E9%80%9A%E8%BF%87Hardware%20Layer%E6%8F%90%E9%AB%98%E5%8A%A8%E7%94%BB%E6%80%A7%E8%83%BD.md "通过Hardware Layer提高动画性能"
-    	
----
+回收 – 硬件层会占用GPU中的一块内存。只在必要的时候使用他们，比如动画，并且事后注意回收。例如在上面ObjectAnimator的例子中，我们增加了一个动画结束监听以便在动画结束后可以移除硬件层。而在Property animator的例子中，我们使用了withLayers()，这会在动画开始时候自动创建硬件层并且在结束的时候自动移除。
+如果你在调用了硬件View layers后改变了View，那么会造成硬件硬件层的刷新并且再次重头渲染一遍view到非屏幕区域缓存中。这种情况通常发生在我们使用了硬件层暂时还不支持的属性（目前为止，硬件层只针对以下几种属性做了优化：otation、scale、x/y、translation、pivot和alpha）。例如，如果你另一个view执行动画，并且使用硬件层，在屏幕滑动他们的同时改变他的背景颜色，这就会造成硬件层的持续刷新。而以硬件层的持续刷新所造成的性能消耗来说，可能让它在这里的使用变得并不那么值。
+有关如何使用Hardware Layer请参考之前写的文章:通过Hardware Layer提高动画性能
 
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
+邮箱 ：charon.chui@gmail.com
+Good Luck!
\ No newline at end of file

From 51d0b32977f50e6bd47aab1368bff5d60c23fec1 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 6 Mar 2023 20:46:04 +0800
Subject: [PATCH 093/213] update notes

---
 JavaKnowledge/.DS_Store                       | Bin 6148 -> 6148 bytes
 ...36\346\224\266\346\234\272\345\210\266.md" | 191 ++++++++-----
 .../JVM\346\236\266\346\236\204.md"           | 137 +++++----
 .../MVC\344\270\216MVP\345\217\212MVVM.md"    |  22 +-
 .../Top-K\351\227\256\351\242\230.md"         |  17 +-
 ...77\347\224\250\346\225\231\347\250\213.md" |  22 +-
 ...60\346\215\256\347\273\223\346\236\204.md" | 130 ++++-----
 ...&\347\261\273&\346\216\245\345\217\243.md" | 265 ++++++++++--------
 VideoDevelopment/.DS_Store                    | Bin 0 -> 6148 bytes
 9 files changed, 443 insertions(+), 341 deletions(-)
 create mode 100644 VideoDevelopment/.DS_Store

diff --git a/JavaKnowledge/.DS_Store b/JavaKnowledge/.DS_Store
index bf3070814d6f3de67d704daffef65ea47ad99cae..a157e1c898881dcc71838e834593d0a947bcfb97 100644
GIT binary patch
delta 22
dcmZoMXffC@kBQUR(nv?a(8SPi^KzzGQ2<P|20;J-

delta 22
dcmZoMXffC@kBQUV)J#Xg(8$1Y^KzzGQ2<Q=21)<`

diff --git "a/JavaKnowledge/JVM\345\236\203\345\234\276\345\233\236\346\224\266\346\234\272\345\210\266.md" "b/JavaKnowledge/JVM\345\236\203\345\234\276\345\233\236\346\224\266\346\234\272\345\210\266.md"
index 704c9c55..7c964b63 100644
--- "a/JavaKnowledge/JVM\345\236\203\345\234\276\345\233\236\346\224\266\346\234\272\345\210\266.md"
+++ "b/JavaKnowledge/JVM\345\236\203\345\234\276\345\233\236\346\224\266\346\234\272\345\210\266.md"
@@ -6,15 +6,19 @@
 
 ### 堆（Heap）
 
-Java 堆是垃圾收集器管理的主要区域，因此也被称作GC 堆（Garbage Collected Heap)。Java的自动内存管理主要是针对对象内存的回收和对象内存的分配。同时，Java 自动内存管理最核心的功能是堆内存中对象的分配与回收。从垃圾回收的角度，由于现在收集器基本都采用分代垃圾收集算法，所以 Java 堆还可以细分为：新生代和老年代：再细致一点有：Eden 空间、From Survivor、To Survivor 空间等。进一步划分的目的是更好地回收内存，或者更快地分配内存。
+Java堆是垃圾收集器管理的主要区域，因此也被称作GC堆（Garbage Collected Heap)。Java的自动内存管理主要是针对对象内存的回收和对象
+内存的分配。同时，Java自动内存管理最核心的功能是堆内存中对象的分配与回收。从垃圾回收的角度，由于现在收集器基本都采用分代垃圾收集算法，
+所以Java堆还可以细分为：新生代和老年代，再细致一点有：Eden空间、From Survivor、To Survivor空间等。进一步划分的目的是更好地回收
+内存，或者更快地分配内存。
 
 **堆空间的基本结构：**
 
 ![](http://raw.githubusercontent.com/CharonChui/Pictures/master/java_heap.png)
 
-在我们垃圾回收的时候，我们往往将堆内存分成**新生代和老生代（大小比例1：2）**，新生代中由Eden和Survivor0，Survivor1组成，**三者的比例是8：1：1**，新生代的回收机制采用**复制算法**，大部分情况，对象都会首先在Eden区域分配，在一次新生代垃圾回收后，如果对象还存活，则会进入s0或者s1，并且对象的年龄还会加 1(Eden区->Survivor区后对象的初始年龄变为1)，当它的年龄增加到一定程度（默认为15  岁），就会被晋升到老年代中。对象晋升到老年代的年龄阈值，可以通过参数 `-XX:MaxTenuringThreshold` 来设置。老生代采用的回收算法是**标记整理算法。**
-
-
+在垃圾回收的时候，我们往往将堆内存分成**新生代和老生代（大小比例1：2）**，新生代中由Eden和Survivor0，Survivor1组成，**三者的比例是8：1：1**，
+新生代的回收机制采用**复制算法**，大部分情况，对象都会首先在Eden区域分配，在一次新生代垃圾回收后，如果对象还存活，则会进入s0或者s1，并且对象的
+年龄还会加1(Eden区->Survivor区后对象的初始年龄变为1)，当它的年龄增加到一定程度（默认为15岁），就会被晋升到老年代中。对象晋升到老年代的年龄
+阈值，可以通过参数`-XX:MaxTenuringThreshold`来设置。老生代采用的回收算法是**标记整理算法。**
 
 #### 对象优先在eden区分配
 
@@ -22,10 +26,10 @@ Java 堆是垃圾收集器管理的主要区域，因此也被称作GC 堆（Gar
 
 大多数情况下，对象在新生代中eden区分配。当eden区没有足够空间进行分配时，虚拟机将发起一次Minor GC.
 
-这里说一下Minor GC 和 Full GC 有什么不同呢？
+这里说一下Minor GC和Full GC有什么不同呢？
 
-- 新生代 GC（Minor GC）:指发生新生代的的垃圾收集动作，Minor GC 非常频繁，回收速度一般也比较快。
-- 老年代 GC（Major GC/Full GC）:指发生在老年代的 GC，出现了 Major GC 经常会伴随至少一次的 Minor GC（并非绝对），Major GC 的速度一般会比 Minor GC 的慢 10 倍以上。
+- 新生代GC（Minor GC）:指发生新生代的的垃圾收集动作，Minor GC非常频繁，回收速度一般也比较快。
+- 老年代GC（Major GC/Full GC）:指发生在老年代的GC，出现了Major GC经常会伴随至少一次的Minor GC（并非绝对），Major GC的速度一般会比Minor GC的慢10倍以上。
 
 #### 大对象直接进入老年代
 
@@ -33,12 +37,12 @@ Java 堆是垃圾收集器管理的主要区域，因此也被称作GC 堆（Gar
 
 #### 长期存活的对象将进入老年代
 
-既然虚拟机采用了分代收集的思想来管理内存，那么内存回收时就必须能识别哪些对象应放在新生代，哪些对象应放在老年代中。为了做到这一点，虚拟机给每个对象一个对象年龄（Age）计数器。
-
-如果对象在Eden出生并经过第一次Minor GC后仍然能够存活，并且能被Survivor容纳的话，将被移动到Survivor空间中，并将对象年龄设为1.对象在Survivor中每熬过一次MinorGC,年龄就增加1岁，当它的年龄增加到一定程度（一般都会说默认为 15 岁，其实默认晋升年龄并不都是15，这个是要区分垃圾收集器的，CMS就是6.），就会被晋升到老年代中。对象晋升到老年代的年龄阈值，可以通过参数 `-XX:MaxTenuringThreshold` 来设置。
-
-
+既然虚拟机采用了分代收集的思想来管理内存，那么内存回收时就必须能识别哪些对象应放在新生代，哪些对象应放在老年代中。为了做到这一点，虚拟机给每个对
+象一个对象年龄（Age）计数器。
 
+如果对象在Eden出生并经过第一次Minor GC后仍然能够存活，并且能被Survivor容纳的话，将被移动到Survivor空间中，并将对象年龄设为1.对象在
+Survivor中每熬过一次MinorGC,年龄就增加1岁，当它的年龄增加到一定程度（一般都会说默认为 15 岁，其实默认晋升年龄并不都是15，这个是要区分垃圾收集器的，CMS就是6），
+就会被晋升到老年代中。对象晋升到老年代的年龄阈值，可以通过参数`-XX:MaxTenuringThreshold`来设置。
 
 
 ## 如何判断对象是垃圾
@@ -63,9 +67,6 @@ ObjB.obj - ObjA
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/yinyongjishu.jpg)
 
 
-
-
-
 ### 根搜索算法
 
 根搜索算法是从离散数学中的图论引入的，程序把所有的引用关系看作一张图，
@@ -83,7 +84,7 @@ ObjB.obj - ObjA
 垃圾回收算法
 ---
 
-而手机后的垃圾是通过什么算法来回收的呢：   
+而收集后的垃圾是通过什么算法来回收的呢：   
 
 - 标记-清除算法
 - 复制算法
@@ -108,7 +109,9 @@ ObjB.obj - ObjA
 ### 标记复制算法(mark-copy)           
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/fuzhisuanfa.png)
 
-原理：思路也很简单，将内存对半分，总是保留一块空着（上图中的右侧），将左侧存活的对象（浅灰色区域）复制到右侧，然后左侧全部清空。避免了内存碎片问题，但是内存浪费很严重，相当于只能使用 50% 的内存。。从根集合节点进行扫描，标记出所有的存活对象，并将这些存活的对象复制到一块儿新的内存（图中下边的那一块儿内存）上去，之后将原来的那一块儿内存（图中上边的那一块儿内存）全部回收掉 
+原理：思路也很简单，将内存对半分，总是保留一块空着（上图中的右侧），将左侧存活的对象（浅灰色区域）复制到右侧，然后左侧全部清空。避免了内存碎片
+问题，但是内存浪费很严重，相当于只能使用50%的内存。从根集合节点进行扫描，标记出所有的存活对象，并将这些存活的对象复制到一块儿新的内存
+（图中下边的那一块儿内存）上去，之后将原来的那一块儿内存（图中上边的那一块儿内存）全部回收掉 
 
 适用场合：
 
@@ -124,7 +127,9 @@ ObjB.obj - ObjA
 ### 标记-整理算法(Mark-Compact)              
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/biaoji_zhengli.png)
 
-原理：从根集合节点进行扫描，标记出所有的存活对象，最后扫描整个内存空间并清除没有标记的对象（即死亡对象）（可以发现前边这些就是标记-清除算法的原理），清除完之后，将所有的存活对象左移到一起。 避免了上述两种算法的缺点，将垃圾对象清理掉后，同时将剩下的存活对象进行整理挪动（类似于 windows 的磁盘碎片整理），保证它们占用的空间连续，这样就避免了内存碎片问题，但是整理过程也会降低 GC 的效率。
+原理：从根集合节点进行扫描，标记出所有的存活对象，最后扫描整个内存空间并清除没有标记的对象（即死亡对象）（可以发现前边这些就是标记-清除算法的原理），
+清除完之后，将所有的存活对象左移到一起。避免了上述两种算法的缺点，将垃圾对象清理掉后，同时将剩下的存活对象进行整理挪动（类似于 windows 的磁盘碎片整理），
+保证它们占用的空间连续，这样就避免了内存碎片问题，但是整理过程也会降低GC的效率。
 
 适用场合：
 
@@ -141,75 +146,84 @@ ObjB.obj - ObjA
 
 ### 分代收集算法(Generational Collection)
 
-上述三种算法，每种都有各自的优缺点，都不完美。在现代 JVM  中，往往是综合使用的，经过大量实际分析，发现内存中的对象，大致可以分为两类：有些生命周期很短，比如一些局部变量 /  临时对象，而另一些则会存活很久，典型的比如 websocket 长连接中的 connection 对象，如下图：
+上述三种算法，每种都有各自的优缺点，都不完美。在现代JVM中，往往是综合使用的，经过大量实际分析，发现内存中的对象，大致可以分为两类：
+有些生命周期很短，比如一些局部变量/临时对象，而另一些则会存活很久，典型的比如websocket长连接中的connection对象，如下图：
 
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/62226d097ac54148804119b4c239c802.png)
 
-纵向 y 轴可以理解分配内存的字节数，横向 x 轴理解为随着时间流逝（伴随着 GC），可以发现大部分对象其实相当短命，很少有对象能在 GC 后活下来。因此诞生了分代的思想，以 Hotspot 为例（JDK 7）：
+纵向y轴可以理解分配内存的字节数，横向x轴理解为随着时间流逝（伴随着 GC），可以发现大部分对象其实相当短命，很少有对象能在GC后活下来。
+因此诞生了分代的思想，以Hotspot为例（JDK 7）：
 
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/e4ff361d409b6939e6da49a06b6dc677.png)
 
-将内存分成了三大块：年青代（Young Genaration），老年代（Old Generation）, 永久代（Permanent Generation），其中 Young Genaration 更是又细为分 eden，S0，S1 三个区。
+将内存分成了三大块：年青代（Young Genaration），老年代（Old Generation）, 永久代（Permanent Generation），其中Young Genaration更是又细分为eden，
+S0，S1三个区。
 
-结合我们经常使用的一些 jvm 调优参数后，一些参数能影响的各区域内存大小值，示意图如下：
+结合我们经常使用的一些jvm调优参数后，一些参数能影响的各区域内存大小值，示意图如下：
 
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/d4e6583cd0ecfa60622526e7a4f13634.png)
 
-注：jdk8 开始，用 MetaSpace 区取代了 Perm 区（永久代），所以相应的 jvm 参数变成 -XX:MetaspaceSize 及 -XX:MaxMetaspaceSize。
+注：jdk8开始，用MetaSpace区取代了Perm区（永久代），所以相应的jvm参数变成-XX:MetaspaceSize及-XX:MaxMetaspaceSize。
 
-以 Hotspot 为例，我们来分析下 GC 的主要过程：
+以Hotspot为例，我们来分析下GC的主要过程：
 
-刚开始时，对象分配在 eden 区，s0（即：from）及 s1（即：to）区，几乎是空着。
+刚开始时，对象分配在eden区，s0（即：from）及s1（即：to）区，几乎是空着。
 
 ![一文看懂JVM内存布局及GC原理](https://raw.githubusercontent.com/CharonChui/Pictures/master/8dc1423cc9f85658a946e204dc85ec18.png)
 
-随着应用的运行，越来越多的对象被分配到 eden 区。
+随着应用的运行，越来越多的对象被分配到eden区。
 
 ![一文看懂JVM内存布局及GC原理](https://raw.githubusercontent.com/CharonChui/Pictures/master/c9138916377192a8a2590aca3e888049.png)
 
-当 eden 区放不下时，就会发生 minor GC（也被称为 young GC），第 1  步当然是要先标识出不可达垃圾对象（即：下图中的黄色块），然后将可达对象，移动到 s0 区（即：4 个淡蓝色的方块挪到 s0  区），然后将黄色的垃圾块清理掉，这一轮过后，eden 区就成空的了。
+当eden区放不下时，就会发生minor GC（也被称为young GC），第1步当然是要先标识出不可达垃圾对象（即：下图中的黄色块），然后将可达对象，
+移动到s0区（即：4个淡蓝色的方块挪到s0区），然后将黄色的垃圾块清理掉，这一轮过后，eden区就成空的了。
 
 注：这里其实已经综合运用了“【标记 - 清理 eden】 + 【标记 - 复制 eden->s0】”算法。
 
 ![一文看懂JVM内存布局及GC原理](https://raw.githubusercontent.com/CharonChui/Pictures/master/adc376cad0670c6993da8f32f3a88aba.png)
 
-随着时间推移，eden 如果又满了，再次触发 minor GC，同样还是先做标记，这时 eden 和 s0  区可能都有垃圾对象了（下图中的黄色块），注意：这时 s1（即：to）区是空的，s0 区和 eden 区的存活对象，将直接搬到 s1 区。然后将  eden 和 s0 区的垃圾清理掉，这一轮 minor GC 后，eden 和 s0 区就变成了空的了。
+随着时间推移，eden如果又满了，再次触发minor GC，同样还是先做标记，这时eden和s0区可能都有垃圾对象了（下图中的黄色块），注意：这时s1（即：to）区是空的，
+s0区和eden区的存活对象，将直接搬到s1区。然后将eden和s0区的垃圾清理掉，这一轮minor GC后，eden和s0区就变成了空的了。
 
 ![一文看懂JVM内存布局及GC原理](https://raw.githubusercontent.com/CharonChui/Pictures/master/f21d18a0736d0976c4ecf14e82236cb2.png)
 
-继续，随着对象的不断分配，eden 空可能又满了，这时会重复刚才的 minor GC 过程，不过要注意的是，这时候 s0 是空的，所以  s0 与 s1 的角色其实会互换，即：存活的对象，会从 eden 和 s1 区，向 s0 区移动。然后再把 eden 和 s1  区中的垃圾清除，这一轮完成后，eden 与 s1 区变成空的，如下图。
+继续，随着对象的不断分配，eden区可能又满了，这时会重复刚才的minor GC过程，不过要注意的是，这时候s0是空的，所以s0与s1的角色其实会互换，
+即：存活的对象，会从eden和s1区，向s0区移动。然后再把eden和s1区中的垃圾清除，这一轮完成后，eden与s1区变成空的，如下图。
 
 ![一文看懂JVM内存布局及GC原理](https://raw.githubusercontent.com/CharonChui/Pictures/master/f765eb0f46635ae093516f35fb1eee66.png)
 
-对于那些比较“长寿”的对象一直在 s0 与 s1 中挪来挪去，一来很占地方，而且也会造成一定开销，降低 gc 效率，于是有了“代龄 (age)”及“晋升”。
+对于那些比较“长寿”的对象一直在s0与s1中挪来挪去，一来很占地方，而且也会造成一定开销，降低gc效率，于是有了“代龄 (age)”及“晋升”。
 
-对象在年青代的 3 个区 (edge,s0,s1) 之间，每次从 1 个区移到另 1 区，年龄 +1，在 young  区达到一定的年龄阈值后，将晋升到老年代。下图中是 8，即：挪动 8 次后，如果还活着，下次 minor GC 时，将移动到 Tenured 区。
+对象在年青代的3个区 (edge,s0,s1) 之间，每次从1个区移到另1区，年龄+1，在young区达到一定的年龄阈值后，将晋升到老年代。下图中是8，即：挪动8次后，
+如果还活着，下次minor GC时，将移动到Tenured区。
 
 ![一文看懂JVM内存布局及GC原理](https://raw.githubusercontent.com/CharonChui/Pictures/master/2705a4ba41ed37bd535adab5b91ffb8f.png)
 
-下图是晋升的主要过程：对象先分配在年青代，经过多次 Young GC 后，如果对象还活着，晋升到老年代。
+下图是晋升的主要过程：对象先分配在年青代，经过多次Young GC后，如果对象还活着，晋升到老年代。
 
 ![一文看懂JVM内存布局及GC原理](https://raw.githubusercontent.com/CharonChui/Pictures/master/6d24d96eb137f805c867736a750c2bd9.png)
 
-如果老年代，最终也放满了，就会发生 major GC（即 Full GC），由于老年代的的对象通常会比较多，因为标记 - 清理 - 整理（压缩）的耗时通常会比较长，会让应用出现卡顿的现象，这也是为什么很多应用要优化，尽量避免或减少 Full GC 的原因。
+如果老年代，最终也放满了，就会发生major GC（即 Full GC），由于老年代的的对象通常会比较多，因为标记 - 清理 - 整理（压缩）的耗时通常会比较长，
+会让应用出现卡顿的现象，这也是为什么很多应用要优化，尽量避免或减少Full GC的原因。
 
 ![一文看懂JVM内存布局及GC原理](https://raw.githubusercontent.com/CharonChui/Pictures/master/ebad989a70f78a40c561df9943234441.png)
 
-注：上面的过程主要来自 oracle 官网的资料，但是有一个细节官网没有提到，如果分配的新对象比较大，eden 区放不下，但是 old 区可以放下时，会直接分配到 old 区（即没有晋升这一过程，直接到老年代了）。
+注：上面的过程主要来自oracle官网的资料，但是有一个细节官网没有提到，如果分配的新对象比较大，eden区放不下，但是old区可以放下时，会直接分配到
+old区（即没有晋升这一过程，直接到老年代了）。
 
 下图引自阿里出品的《码出高效 -Java 开发手册》一书，梳理了 GC 的主要过程。
 
 ![一文看懂JVM内存布局及GC原理](https://raw.githubusercontent.com/CharonChui/Pictures/master/e663bd3043c6b3465edc1e7313671d69.png)
 
 
-
 ##  垃圾回收器
 
-不算最新出现的神器 ZGC，历史上出现过 7 种经典的垃圾回收器。
+不算最新出现的神器ZGC，历史上出现过7种经典的垃圾回收器。
 
 ![一文看懂JVM内存布局及GC原理](https://raw.githubusercontent.com/CharonChui/Pictures/master/ab1c7be2fa4b5d180ffa1f43bf9dfce7.png)
 
-这些回收器都是基于分代的，把 G1 除外，按回收的分代划分，横线以上的 3 种：Serial ,ParNew, Parellel  Scavenge 都是回收年青代的，横线以下的 3 种：CMS，Serial Old, Parallel Old 都是回收老年代的。
+这些回收器都是基于分代的，把G1除外，按回收的分代划分，横线以上的3种：Serial ,ParNew, Parellel  Scavenge都是回收年青代的，
+横线以下的3种：CMS，Serial Old, Parallel Old都是回收老年代的。
 
 
 
@@ -225,66 +239,90 @@ ObjB.obj - ObjA
 
 ParNew收集器是Serial收集器新生代的多线程实现，注意在进行垃圾回收的时候依然会stop the world，只是相比较Serial收集器而言它会运行多条进程进行垃圾回收。
 
-ParNew收集器在单CPU的环境中绝对不会有比Serial收集器更好的效果，甚至由于存在线程交互的开销，该收集器在通过超线程技术实现的两个CPU的环境中都不能百分之百的保证能超越Serial收集器。当然，随着可以使用的CPU的数量增加，它对于GC时系统资源的利用还是很有好处的。它默认开启的收集线程数与CPU的数量相同，在CPU非常多（譬如32个，现在CPU动辄4核加超线程，服务器超过32个逻辑CPU的情况越来越多了）的环境下，可以使用-XX:ParallelGCThreads参数来限制垃圾收集的线程数。
+ParNew收集器在单CPU的环境中绝对不会有比Serial收集器更好的效果，甚至由于存在线程交互的开销，该收集器在通过超线程技术实现的两个CPU的环境中都不
+能百分之百的保证能超越Serial收集器。当然，随着可以使用的CPU的数量增加，它对于GC时系统资源的利用还是很有好处的。它默认开启的收集线程数与CPU的数
+量相同，在CPU非常多（譬如32个，现在CPU动辄4核加超线程，服务器超过32个逻辑CPU的情况越来越多了）的环境下，可以使用-XX:ParallelGCThreads参数
+来限制垃圾收集的线程数。
 
 ### Parallel Scavenge	
-Parallel是采用复制算法的多线程新生代垃圾回收器，似乎和ParNew收集器有很多的相似的地方。但是Parallel  Scanvenge收集器的一个特点是它所关注的目标是吞吐量(Throughput)。所谓吞吐量就是CPU用于运行用户代码的时间与CPU总消耗时间的比值，即吞吐量=运行用户代码时间 / (运行用户代码时间 +  垃圾收集时间)。停顿时间越短就越适合需要与用户交互的程序，良好的响应速度能够提升用户的体验；而高吞吐量则可以最高效率地利用CPU时间，尽快地完成程序的运算任务，主要适合在后台运算而不需要太多交互的任务。
+Parallel是采用复制算法的多线程新生代垃圾回收器，似乎和ParNew收集器有很多的相似的地方。但是Parallel  Scanvenge收集器的一个特点是它所关注的
+目标是吞吐量(Throughput)。所谓吞吐量就是CPU用于运行用户代码的时间与CPU总消耗时间的比值，即吞吐量=运行用户代码时间 / (运行用户代码时间 +  垃圾收集时间)。
+停顿时间越短就越适合需要与用户交互的程序，良好的响应速度能够提升用户的体验；而高吞吐量则可以最高效率地利用CPU时间，尽快地完成程序的运算任务，
+主要适合在后台运算而不需要太多交互的任务。
 
 ### CMS	
 
-全称：Concurrent Mark Sweep，从名字上看，就能猜出它是并发多线程的。这是 JDK 7 中广泛使用的收集器，有必要多说一下，借一张网友的图说话：
+全称：Concurrent Mark Sweep，从名字上看，就能猜出它是并发多线程的。这是JDK 7中广泛使用的收集器，有必要多说一下，借一张网友的图说话：
 
 ![一文看懂JVM内存布局及GC原理](https://static001.infoq.cn/resource/image/e8/4e/e8b152cf510b06544c2a13bfb4fc564e.png)
 
-相对Serial Old 收集器或Parallel Old 收集器而言，这个明显要复杂多了，从名字(Mark Swep)就可以看出，CMS收集器是基于标记清除算法实现的。它的收集过程分为四个步骤：
+相对Serial Old收集器或Parallel Old 收集器而言，这个明显要复杂多了，从名字(Mark Swep)就可以看出，CMS收集器是基于标记清除算法实现的。
+它的收集过程分为四个步骤：
 
 1. 初始标记(initial mark) 
 2. 并发标记(concurrent mark) 
 3. 重新标记(remark) 
 4. 并发清除(concurrent sweep) 
 
-分为 4 个阶段：
-
-1）Inital Mark 初始标记：主要是标记 GC Root 开始的下级（注：仅下一级）对象，这个过程会 STW，但是跟 GC Root 直接关联的下级对象不会很多，因此这个过程其实很快。
+分为4个阶段：
 
-2）Concurrent Mark 并发标记：根据上一步的结果，继续向下标识所有关联的对象，直到这条链上的最尽头。这个过程是多线程的，虽然耗时理论上会比较长，但是其它工作线程并不会阻塞，没有 STW。
+- Inital Mark 初始标记
+    主要是标记GC Root开始的下级（注：仅下一级）对象，这个过程会STW，但是跟GC Root直接关联的下级对象不会很多，因此这个过程其实很快。
 
-3）Remark 再标志：为啥还要再标记一次？因为第 2 步并没有阻塞其它工作线程，其它线程在标识过程中，很有可能会产生新的垃圾。
+- Concurrent Mark 并发标记
+    根据上一步的结果，继续向下标识所有关联的对象，直到这条链上的最尽头。这个过程是多线程的，虽然耗时理论上会比较长，但是其它工作线程并不会阻塞，没有STW。
 
-试想下，高铁上的垃圾清理员，从车厢一头开始吆喝“有需要扔垃圾的乘客，请把垃圾扔一下”，一边工作一边向前走，等走到车厢另一头时，刚才走过的位置上，可能又有乘客产生了新的空瓶垃圾。所以，要完全把这个车厢清理干净的话，她应该喊一下：所有乘客不要再扔垃圾了（STW），然后把新产生的垃圾收走。当然，因为刚才已经把收过一遍垃圾，所以这次收集新产生的垃圾，用不了多长时间（即：STW 时间不会很长）。
+- Remark 再标志
+    为啥还要再标记一次？因为第2步并没有阻塞其它工作线程，其它线程在标识过程中，很有可能会产生新的垃圾。
+    试想下，高铁上的垃圾清理员，从车厢一头开始吆喝“有需要扔垃圾的乘客，请把垃圾扔一下”，一边工作一边向前走，等走到车厢另一头时，刚才走过的位置上，
+    可能又有乘客产生了新的空瓶垃圾。所以，要完全把这个车厢清理干净的话，她应该喊一下：所有乘客不要再扔垃圾了（STW），然后把新产生的垃圾收走。
+    当然，因为刚才已经把收过一遍垃圾，所以这次收集新产生的垃圾，用不了多长时间（即：STW 时间不会很长）。
 
-4）Concurrent Sweep：并行清理，这里使用多线程以“Mark Sweep- 标记清理”算法，把垃圾清掉，其它工作线程仍然能继续支行，不会造成卡顿。
+- Concurrent Sweep
+    并行清理，这里使用多线程以“Mark Sweep- 标记清理”算法，把垃圾清掉，其它工作线程仍然能继续支行，不会造成卡顿。
 
-等等，刚才我们不是提到过“标记清理”法，会留下很多内存碎片吗？确实，但是也没办法，如果换成“Mark Compact 标记 -  整理”法，把垃圾清理后，剩下的对象也顺便排整理，会导致这些对象的内存地址发生变化，别忘了，此时其它线程还在工作，如果引用的对象地址变了，就天下大乱了。
+等等，刚才我们不是提到过“标记清理”法，会留下很多内存碎片吗？确实，但是也没办法，如果换成“Mark Compact标记 -  整理”法，把垃圾清理后，
+剩下的对象也顺便排整理，会导致这些对象的内存地址发生变化，别忘了，此时其它线程还在工作，如果引用的对象地址变了，就天下大乱了。
 
-另外，由于这一步是并行处理，并不阻塞其它线程，所以还有一个副使用，在清理的过程中，仍然可能会有新垃圾对象产生，只能等到下一轮 GC，才会被清理掉。不过由于CMS收集器是基于标记清除算法实现的，会导致有大量的空间碎片产生，在为大对象分配内存的时候，往往会出现老年代还有很大的空间剩余，但是无法找到足够大的连续空间来分配当前对象，不得不提前开启一次Full GC。
+另外，由于这一步是并行处理，并不阻塞其它线程，所以还有一个副使用，在清理的过程中，仍然可能会有新垃圾对象产生，只能等到下一轮GC，才会被清理掉。
+不过由于CMS收集器是基于标记清除算法实现的，会导致有大量的空间碎片产生，在为大对象分配内存的时候，往往会出现老年代还有很大的空间剩余，但是无法找
+到足够大的连续空间来分配当前对象，不得不提前开启一次Full GC。
 
-为了解决这个问题，CMS收集器默认提供了一个-XX:+UseCMSCompactAtFullCollection收集开关参数（默认就是开启的)，用于在CMS收集器进行FullGC完开启内存碎片的合并整理过程，内存整理的过程是无法并发的，这样内存碎片问题倒是没有了，不过停顿时间不得不变长。虚拟机设计者还提供了另外一个参数-XX:CMSFullGCsBeforeCompaction参数用于设置执行多少次不压缩的FULL GC后跟着来一次带压缩的（默认值为0，表示每次进入Full GC时都进行碎片整理）。
+为了解决这个问题，CMS收集器默认提供了一个-XX:+UseCMSCompactAtFullCollection收集开关参数（默认就是开启的)，用于在CMS收集器进行Full GC完
+开启内存碎片的合并整理过程，内存整理的过程是无法并发的，这样内存碎片问题倒是没有了，不过停顿时间不得不变长。虚拟机设计者还提供了另外一个参
+数-XX:CMSFullGCsBeforeCompaction参数用于设置执行多少次不压缩的FULL GC后跟着来一次带压缩的（默认值为0，表示每次进入Full GC时都进行碎片整理）。
 
-不幸的是，它作为老年代的收集器，却无法与jdk1.4中已经存在的新生代收集器Parallel  Scavenge配合工作，所以在jdk1.5中使用cms来收集老年代的时候，新生代只能选择ParNew或Serial收集器中的一个。ParNew收集器是使用-XX:+UseConcMarkSweepGC选项启用CMS收集器之后的默认新生代收集器，也可以使用-XX:+UseParNewGC选项来强制指定它。
+不幸的是，它作为老年代的收集器，却无法与jdk1.4中已经存在的新生代收集器Parallel  Scavenge配合工作，所以在jdk1.5中使用cms来收集老年代的时候，
+新生代只能选择ParNew或Serial收集器中的一个。ParNew收集器是使用-XX:+UseConcMarkSweepGC选项启用CMS收集器之后的默认新生代收集器，也可以使用
+-XX:+UseParNewGC选项来强制指定它。
 
-虽然仍不完美，但是从这 4 步的处理过程来看，以往收集器中最让人诟病的长时间 STW，通过上述设计，被分解成二次短暂的 STW，所以从总体效果上看，应用在 GC 期间卡顿的情况会大大改善，这也是 CMS 一度十分流行的重要原因。
+虽然仍不完美，但是从这4步的处理过程来看，以往收集器中最让人诟病的长时间STW，通过上述设计，被分解成二次短暂的STW，所以从总体效果上看，应用在GC期间
+卡顿的情况会大大改善，这也是CMS一度十分流行的重要原因。
 
 ### G1
 
-G1 的全称是 Garbage-First，为什么叫这个名字，呆会儿会详细说明。鉴于 CMS 的一些不足之外，比如:  老年代内存碎片化，STW 时间虽然已经改善了很多，但是仍然有提升空间。G1 就横空出世了，它对于 heap  区的内存划思路很新颖，有点算法中分治法“分而治之”的味道。G1收集器是一款面向服务端应用的垃圾收集器。HotSpot团队赋予它的使命是在未来替换掉JDK1.5中发布的CMS收集器。与其他GC收集器相比，G1具备如下特点：
+G1的全称是Garbage-First，为什么叫这个名字，呆会儿会详细说明。鉴于CMS的一些不足之外，比如:老年代内存碎片化，STW时间虽然已经改善了很多，
+但是仍然有提升空间。G1就横空出世了，它对于heap区的内存划思路很新颖，有点算法中分治法“分而治之”的味道。G1收集器是一款面向服务端应用的垃圾收集器。
+HotSpot团队赋予它的使命是在未来替换掉JDK1.5中发布的CMS收集器。与其他GC收集器相比，G1具备如下特点：
 
 1. 并行与并发：G1能更充分的利用CPU，多核环境下的硬件优势来缩短stop the world的停顿时间。 
 2. 分代收集：和其他收集器一样，分代的概念在G1中依然存在，不过G1不需要其他的垃圾回收器的配合就可以独自管理整个GC堆。 
 3. 空间整合：G1收集器有利于程序长时间运行，分配大对象时不会无法得到连续的空间而提前触发一次GC。 
-4. 可预测的非停顿：这是G1相对于CMS的另一大优势，降低停顿时间是G1和CMS共同的关注点，能让使用者明确指定在一个长度为M毫秒的时间片段内，消耗在垃圾收集上的时间不得超过N毫秒。 
+4. 可预测的非停顿：这是G1相对于CMS的另一大优势，降低停顿时间是G1和CMS共同的关注点，能让使用者明确指定在一个长度为M毫秒的时间片段内，
+    消耗在垃圾收集上的时间不得超过N毫秒。 
 
-在使用G1收集器时，Java堆的内存布局和其他收集器有很大的差别，它将这个Java堆分为多个大小相等的独立区域，虽然还保留新生代和老年代的概念，但是新生代和老年代不再是物理隔离的了，它们都是一部分Region（不需要连续）的集合。
+在使用G1收集器时，Java堆的内存布局和其他收集器有很大的差别，它将这个Java堆分为多个大小相等的独立区域，虽然还保留新生代和老年代的概念，但是新生
+代和老年代不再是物理隔离的了，它们都是一部分Region（不需要连续）的集合。
 
 虽然G1看起来有很多优点，实际上CMS还是主流。
 
 
+如下图，G1将heap内存区，划分为一个个大小相等（1-32M，2的n次方）、内存连续的Region区域，每个region都对应Eden、Survivor、Old、Humongous
+四种角色之一，但是region与region之间不要求连续。
 
-如下图，G1 将 heap 内存区，划分为一个个大小相等（1-32M，2 的 n 次方）、内存连续的 Region 区域，每个  region 都对应 Eden、Survivor 、Old、Humongous 四种角色之一，但是 region 与 region  之间不要求连续。
+注：Humongous，简称H区是专用于存放超大对象的区域，通常>= 1/2 Region Size，且只有Full GC阶段，才会回收H区，避免了频繁扫描、复制 / 移动大对象。
 
-注：Humongous，简称 H 区是专用于存放超大对象的区域，通常 >= 1/2 Region Size，且只有 Full GC 阶段，才会回收 H 区，避免了频繁扫描、复制 / 移动大对象。
-
-所有的垃圾回收，都是基于 1 个个 region 的。JVM 内部知道，哪些 region  的对象最少（即：该区域最空），总是会优先收集这些 region（因为对象少，内存相对较空，肯定快），这也是 Garbage-First  得名的由来，G 即是 Garbage 的缩写， 1 即 First。
+所有的垃圾回收，都是基于1个个region的。JVM内部知道，哪些region的对象最少（即：该区域最空），总是会优先收集这些 region（因为对象少，内存相对较空，肯定快），这也是 Garbage-First  得名的由来，G 即是 Garbage 的缩写， 1 即 First。
 
 ![一文看懂JVM内存布局及GC原理](https://raw.githubusercontent.com/CharonChui/Pictures/master/f1a1bdecf4e56a4440707ce073d73f61.png)
 
@@ -392,25 +430,24 @@ NUMA 是一种多核服务器的架构，简单来讲，一个多核服务器（
 
 
 
-
-
-
-
 # 	与GC相关的常用参数 
 
-​	除了上面提及的一些参数，下面补充一些和GC相关的常用参数：
-
-- ​		-Xmx: 设置堆内存的最大值。 
-- ​		-Xms: 设置堆内存的初始值。 
-- ​		-Xmn: 设置新生代的大小。 
-- ​		-Xss: 设置栈的大小。 
-- ​		-PretenureSizeThreshold: 直接晋升到老年代的对象大小，设置这个参数后，大于这个参数的对象将直接在老年代分配。 
-- ​		-MaxTenuringThrehold: 晋升到老年代的对象年龄。每个对象在坚持过一次Minor GC之后，年龄就会加1，当超过这个参数值时就进入老年代。 
-- ​		-UseAdaptiveSizePolicy:  在这种模式下，新生代的大小、eden 和 survivor  的比例、晋升老年代的对象年龄等参数会被自动调整，以达到在堆大小、吞吐量和停顿时间之间的平衡点。在手工调优比较困难的场合，可以直接使用这种自适应的方式，仅指定虚拟机的最大堆、目标的吞吐量 (GCTimeRatio) 和停顿时间 (MaxGCPauseMills)，让虚拟机自己完成调优工作。 
-- ​		-SurvivorRattio: 新生代Eden区域与Survivor区域的容量比值，默认为8，代表Eden: Suvivor= 8: 1。 
-- ​		-XX:ParallelGCThreads：设置用于垃圾回收的线程数。通常情况下可以和 CPU 数量相等。但在 CPU 数量比较多的情况下，设置相对较小的数值也是合理的。 
-- ​		-XX:MaxGCPauseMills：设置最大垃圾收集停顿时间。它的值是一个大于 0 的整数。收集器在工作时，会调整 Java 堆大小或者其他一些参数，尽可能地把停顿时间控制在 MaxGCPauseMills 以内。 
-- ​		-XX:GCTimeRatio:设置吞吐量大小，它的值是一个 0-100 之间的整数。假设 GCTimeRatio 的值为 n，那么系统将花费不超过 1/(1+n) 的时间用于垃圾收集。 
+除了上面提及的一些参数，下面补充一些和GC相关的常用参数：
+
+- -Xmx: 设置堆内存的最大值。 
+- -Xms: 设置堆内存的初始值。 
+- -Xmn: 设置新生代的大小。 
+- -Xss: 设置栈的大小。 
+- -PretenureSizeThreshold: 直接晋升到老年代的对象大小，设置这个参数后，大于这个参数的对象将直接在老年代分配。 
+- -MaxTenuringThrehold: 晋升到老年代的对象年龄。每个对象在坚持过一次Minor GC之后，年龄就会加1，当超过这个参数值时就进入老年代。 
+- -UseAdaptiveSizePolicy: 在这种模式下，新生代的大小、eden和survivor的比例、晋升老年代的对象年龄等参数会被自动调整，以达到在堆大小、
+    吞吐量和停顿时间之间的平衡点。在手工调优比较困难的场合，可以直接使用这种自适应的方式，仅指定虚拟机的最大堆、目标的吞吐量 (GCTimeRatio) 和
+    停顿时间 (MaxGCPauseMills)，让虚拟机自己完成调优工作。 
+- -SurvivorRattio: 新生代Eden区域与Survivor区域的容量比值，默认为8，代表Eden: Suvivor= 8: 1。 
+- -XX:ParallelGCThreads：设置用于垃圾回收的线程数。通常情况下可以和CPU数量相等。但在CPU数量比较多的情况下，设置相对较小的数值也是合理的。 
+- -XX:MaxGCPauseMills：设置最大垃圾收集停顿时间。它的值是一个大于0的整数。收集器在工作时，会调整Java堆大小或者其他一些参数，尽可能地把
+    停顿时间控制在MaxGCPauseMills以内。 
+- -XX:GCTimeRatio:设置吞吐量大小，它的值是一个0-100之间的整数。假设GCTimeRatio的值为n，那么系统将花费不超过1/(1+n)的时间用于垃圾收集。 
 
 
 
diff --git "a/JavaKnowledge/JVM\346\236\266\346\236\204.md" "b/JavaKnowledge/JVM\346\236\266\346\236\204.md"
index 33da8edb..34304137 100644
--- "a/JavaKnowledge/JVM\346\236\266\346\236\204.md"
+++ "b/JavaKnowledge/JVM\346\236\266\346\236\204.md"
@@ -4,21 +4,26 @@ Java的主要优势在于，它被设计为可在具有WORA(write once, run anyw
 
 Java源代码会被JDK内置的Java编译器(javac)编译成称为字节码(即.class文件)的中间状态，
 
-这些字节码是带有操作码操作数的十六进制格式，并且JVM可以将这些指令（无需进一步重新编译）解释为操作系统和底层硬件平台可以理解的本地语言。因此，字节码充当独立于平台的中间状态，该状态可在任何JVM之间移植，而与底层操作系统和硬件体系结构无关。
+这些字节码是带有操作码操作数的十六进制格式，并且JVM可以将这些指令（无需进一步重新编译）解释为操作系统和底层硬件平台可以理解的本地语言。
+因此，字节码充当独立于平台的中间状态，该状态可在任何JVM之间移植，而与底层操作系统和硬件体系结构无关。
 
-但是，由于JVM是为运行基础硬件和OS结构并与之通信而开发的，因此我们需要为我们的OS版本（Windows，Linux，Mac）和处理器体系结构（x86，x64）选择适当的JVM版本。
+但是，由于JVM是为运行基础硬件和OS结构并与之通信而开发的，因此我们需要为我们的OS版本（Windows，Linux，Mac）和处理器体系结构（x86，x64）
+选择适当的JVM版本。
 
-我们大多数人都知道Java的上述故事，这里的问题是该过程中最重要的组成部分-JVM被当作一个黑匣子教给我们，它可以神奇地解释字节码并执行许多运行时活动，例如JIT（程序执行期间进行实时）编译和GC（垃圾收集）。
+我们大多数人都知道Java的上述故事，这里的问题是该过程中最重要的组成部分-JVM被当作一个黑匣子教给我们，它可以神奇地解释字节码并执行许多运行时活动，
+例如JIT（程序执行期间进行实时）编译和GC（垃圾收集）。
 
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/JVM_Architecture.png)
 
 ## Class Loader子系统
 
-JVM驻留在内存(RAM)上。在执行过程中，会使用Class Loader子系统将class文件加载到内存中。这称为Java的动态类加载(dynamic class loading)功能。当它在运行时(而非编译时)首次引用类时，它将加载、链接和初始化类文件(.class)。
+JVM驻留在内存(RAM)上。在执行过程中，会使用Class Loader子系统将class文件加载到内存中。这称为Java的动态类加载(dynamic class loading)功能。
+当它在运行时(而非编译时)首次引用类时，它将加载、链接和初始化类文件(.class)。
 
 - 加载
 
-    Class Loader的主要任务就是把编译后的.class文件加载到内存中。通常，class加载过程会从加载main类(有声明static main()的类)。所有后续的类加载尝试都是根据已运行的类中的类引用完成的，如以下情况所述：
+    Class Loader的主要任务就是把编译后的.class文件加载到内存中。通常，class加载过程会从加载main类(有声明static main()的类)。所有后续的
+    类加载尝试都是根据已运行的类中的类引用完成的，如以下情况所述：
 
     - 当字节码静态引用一个类时
     - 当字节码创建一个类对象时(例如: Person person = new Person("John"))
@@ -27,19 +32,24 @@ JVM驻留在内存(RAM)上。在执行过程中，会使用Class Loader子系统
 
     - Bootstrap Class Loader
 
-        加载来自rt.jar的标准JDK类，例如引导路径中存在的核心Java API类-$ JAVA_HOME/jre/lib目录（例如java.lang。*包类）。它以C / C ++之类的本地语言实现，并是Java中所有类加载器的父级。
+        加载来自rt.jar的标准JDK类，例如引导路径中存在的核心Java API类-$ JAVA_HOME/jre/lib目录（例如java.lang。*包类）。它以C / C ++
+        之类的本地语言实现，并是Java中所有类加载器的父级。
 
     - Extension Class Loader
 
-        将类加载请求委托给其父类Bootstrap，如果不成功，则从扩展路径中的扩展目录（例如，安全扩展功能）中加载-JAVA_HOME/jre/ext或java.ext.dirs系统指定的任何其他目录的类。该类加载器由Java中的sun.misc.Launcher$ExtClassLoader类实现。
+        将类加载请求委托给其父类Bootstrap，如果不成功，则从扩展路径中的扩展目录（例如，安全扩展功能）中加载-JAVA_HOME/jre/ext或java.ext.dirs
+        系统指定的任何其他目录的类。该类加载器由Java中的sun.misc.Launcher$ExtClassLoader类实现。
 
     - System/Application Class Loader
 
-        从系统类路径加载应用程序特定的类，可以使用-cp或-classpath命令来在程序执行时动态设置。它在内部使用映射到java.class.path的环境变量。该类加载器由sun.misc.Launcher$AppClassLoader类用Java实现。
+        从系统类路径加载应用程序特定的类，可以使用-cp或-classpath命令来在程序执行时动态设置。它在内部使用映射到java.class.path的环境变量。
+        该类加载器由sun.misc.Launcher$AppClassLoader类用Java实现。
 
-    除了上面讨论的3个主要的类加载器，程序员还可以直接在代码本身上创建用户定义的类加载器。这通过类加载器委托模型保证了应用程序的独立性。这种方法用于Tomcat之类的Web应用程序服务器中，以使Web应用程序和企业解决方案独立运行。
+    除了上面讨论的3个主要的类加载器，程序员还可以直接在代码本身上创建用户定义的类加载器。这通过类加载器委托模型保证了应用程序的独立性。这种方法
+    用于Tomcat之类的Web应用程序服务器中，以使Web应用程序和企业解决方案独立运行。
 
-    每个类加载器都有自己的名称空间来保存已加载的类。当类加载器加载类时，它将基于存储在名称空间中的完全合格的类名称（FQCN：Fully Qualified Class Name）搜索该类，以检查该类是否已被加载。即使该类具有相同的FQCN但具有不同的名称空间，也将其视为不同的类。不同的名称空间意味着该类已由另一个类加载器加载。
+    每个类加载器都有自己的名称空间来保存已加载的类。当类加载器加载类时，它将基于存储在名称空间中的完全合格的类名称（FQCN：Fully Qualified Class Name）
+    搜索该类，以检查该类是否已被加载。即使该类具有相同的FQCN但具有不同的名称空间，也将其视为不同的类。不同的名称空间意味着该类已由另一个类加载器加载。
 
     它们遵循4个主要原则： 
 
@@ -53,7 +63,11 @@ JVM驻留在内存(RAM)上。在执行过程中，会使用Class Loader子系统
 
     - 委托层次结构原则
 
-        为了满足上述2个原则，JVM遵循一个委托层次结构来为每个请求装入的类选择类加载器。首先从最低的子级别开始，Application Class Loader将接收到的类加载请求委托给Extension Class Loader，然后Extension Class Loader将该请求委托给Bootstrap Class Loader。如果在Bootstrap路径中找到了所请求的类，则将加载该类。否则，该请求将再次被转移回Extension Class Loader加载器中从该Loader的扩展路径或自定义指定的路径中查找类。如果它也失败，则请求将返回到Application Class Loader中从该Loader的System类路径中查找该类，并且如果Application Class Loader也未能加载所请求的类，则将获得运行时异常— java.lang.ClassNotFoundException。
+        为了满足上述2个原则，JVM遵循一个委托层次结构来为每个请求装入的类选择类加载器。首先从最低的子级别开始，Application Class Loader将
+        接收到的类加载请求委托给Extension Class Loader，然后Extension Class Loader将该请求委托给Bootstrap Class Loader。如果在
+        Bootstrap路径中找到了所请求的类，则将加载该类。否则，该请求将再次被转移回Extension Class Loader加载器中从该Loader的扩展路径或
+        自定义指定的路径中查找类。如果它也失败，则请求将返回到Application Class Loader中从该Loader的System类路径中查找该类，并且如果
+        Application Class Loader也未能加载所请求的类，则将获得运行时异常— java.lang.ClassNotFoundException。
 
     - 无法卸载原则
 
@@ -73,7 +87,9 @@ JVM驻留在内存(RAM)上。在执行过程中，会使用Class Loader子系统
 
     - Verification
 
-        确保.class文件的正确性（代码是否根据Java语言规范正确编写？它是由有效的编译器根据JVM规范生成的吗？）。这是类加载过程中最复杂的测试过程，并且耗时最长。即使链接减慢了类加载过程的速度，它也避免了在执行字节码时多次执行这些检查的需要，从而使整体执行高效而有效。如果验证失败，则会引发运行时错误（java.lang.VerifyError）。例如，执行以下检查: 
+        确保.class文件的正确性（代码是否根据Java语言规范正确编写？它是由有效的编译器根据JVM规范生成的吗？）。这是类加载过程中最复杂的测试过程，
+        并且耗时最长。即使链接减慢了类加载过程的速度，它也避免了在执行字节码时多次执行这些检查的需要，从而使整体执行高效而有效。如果验证失败，
+        则会引发运行时错误（java.lang.VerifyError）。例如，执行以下检查: 
 
         ```java
         - consistent and correctly formatted symbol table
@@ -84,12 +100,10 @@ JVM驻留在内存(RAM)上。在执行过程中，会使用Class Loader子系统
         - variables are initialized before being read
         - variables are a value of the correct type
         ```
-
-        
-
     - Preparation
 
-        为静态存储和JVM使用的任何数据结构（例如方法表）分配内存。静态字段已创建并初始化为其默认值，但是，在此阶段不执行任何初始化程序或代码，因为这是初始化的一部分。
+        为静态存储和JVM使用的任何数据结构（例如方法表）分配内存。静态字段已创建并初始化为其默认值，但是，在此阶段不执行任何初始化程序或代码，
+        因为这是初始化的一部分。
 
     - Resolution
 
@@ -97,46 +111,52 @@ JVM驻留在内存(RAM)上。在执行过程中，会使用Class Loader子系统
 
 - 初始化
 
-    在这里，将执行每个加载的类或接口的初始化逻辑（例如，调用类的构造函数）。由于JVM是多线程的，因此应在适当同步的情况下非常仔细地进行类或接口的初始化，以避免其他线程尝试同时初始化同一类或接口（即使其成为线程安全的）。
+    在这里，将执行每个加载的类或接口的初始化逻辑（例如，调用类的构造函数）。由于JVM是多线程的，因此应在适当同步的情况下非常仔细地进行类或接口的
+    初始化，以避免其他线程尝试同时初始化同一类或接口（即使其成为线程安全的）。
 
     这是类加载的最后阶段，所有静态变量都分配有代码中定义的原始值，并且将执行静态块（如果有）。这是在类中从上到下，从类层次结构中的父级到子级逐行执行的。
 
 ### 对象的创建
-
- Java 对象的创建过程： 
-1. 类加载检查
-    虚拟机遇到一条 new 指令时，首先将去检查这个指令的参数是否能在常量池中定位到这个类的符号引用，并且检查这个符号引用代表的类是否已被加载过、解析和初始化过。如果没有，那必须先执行相应的类加载过程。
-2. 分配内存
-    在类加载检查通过后，接下来虚拟机将为新生对象分配内存。对象所需的内存大小在类加载完成后便可确定，为对象分配空间的任务等同于把一块确定大小的内存从 Java 堆中划分出来。分配方式有 “指针碰撞” 和 “空闲列表” 两种，选择那种分配方式由 Java 堆是否规整决定，而Java堆是否规整又由所采用的垃圾收集器是否带有压缩整理功能决定。
-3. 初始化零值
+ Java对象的创建过程： 
+1. 类加载检查    
+    虚拟机遇到一条new指令时，首先将去检查这个指令的参数是否能在常量池中定位到这个类的符号引用，并且检查这个符号引用代表的类是否已被加载过、解析
+    和初始化过。如果没有，那必须先执行相应的类加载过程。
+2. 分配内存    
+    在类加载检查通过后，接下来虚拟机将为新生对象分配内存。对象所需的内存大小在类加载完成后便可确定，为对象分配空间的任务等同于把一块确定大小的内
+    存从Java堆中划分出来。分配方式有 “指针碰撞” 和 “空闲列表” 两种，选择那种分配方式由 Java 堆是否规整决定，而Java堆是否规整又由所采用的垃圾收集器是否带有压缩整理功能决定。
+3. 初始化零值    
     内存分配完成后，虚拟机需要将分配到的内存空间都初始化为零值（不包括对象头），这一步操作保证了对象的实例字段在 Java 代码中可以不赋初始值就直接使用，程序能访问到这些字段的数据类型所对应的零值。
-4. 设置对象头
-    初始化零值完成之后，虚拟机要对对象进行必要的设置，例如这个对象是那个类的实例、如何才能找到类的元数据信息、对象的哈希吗、对象的 GC 分代年龄等信息。 这些信息存放在对象头中。 另外，根据虚拟机当前运行状态的不同，如是否启用偏向锁等，对象头会有不同的设置方式。
-5. 执行init方法
-    在上面工作都完成之后，从虚拟机的视角来看，一个新的对象已经产生了，但从 Java 程序的视角来看，对象创建才刚开始，<init> 方法还没有执行，所有的字段都还为零。所以一般来说，执行 new 指令之后会接着执行 <init> 方法，把对象按照程序员的意愿进行初始化，这样一个真正可用的对象才算完全产生出来。
+4. 设置对象头    
+    初始化零值完成之后，虚拟机要对对象进行必要的设置，例如这个对象是那个类的实例、如何才能找到类的元数据信息、对象的哈希吗、对象的 GC 分代年龄等信息。
+    这些信息存放在对象头中。 另外，根据虚拟机当前运行状态的不同，如是否启用偏向锁等，对象头会有不同的设置方式。
+5. 执行init方法    
+    在上面工作都完成之后，从虚拟机的视角来看，一个新的对象已经产生了，但从 Java 程序的视角来看，对象创建才刚开始，<init> 方法还没有执行，
+    所有的字段都还为零。所以一般来说，执行 new 指令之后会接着执行 <init> 方法，把对象按照程序员的意愿进行初始化，这样一个真正可用的对象才算完全产生出来。
 
 
 ### 对象的内存布局
-在 Hotspot 虚拟机中，对象在内存中的布局可以分为3快区域：对象头、实例数据和对齐填充。
-Hotspot虚拟机的对象头包括两部分信息，第一部分用于存储对象自身的自身运行时数据（哈希吗、GC分代年龄、锁状态标志等等），另一部分是类型指针，即对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是那个类的实例。
+在Hotspot虚拟机中，对象在内存中的布局可以分为3快区域：对象头、实例数据和对齐填充。
+Hotspot虚拟机的对象头包括两部分信息，第一部分用于存储对象自身的自身运行时数据（哈希吗、GC分代年龄、锁状态标志等等），另一部分是类型指针，即对象
+指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是那个类的实例。
 实例数据部分是对象真正存储的有效信息，也是在程序中所定义的各种类型的字段内容。
-对齐填充部分不是必然存在的，也没有什么特别的含义，仅仅起占位作用。 因为Hotspot虚拟机的自动内存管理系统要求对象起始地址必须是8字节的整数倍，换句话说就是对象的大小必须是8字节的整数倍。而对象头部分正好是8字节的倍数（1倍或2倍），因此，当对象实例数据部分没有对齐时，就需要通过对齐填充来补全。
+对齐填充部分不是必然存在的，也没有什么特别的含义，仅仅起占位作用。 因为Hotspot虚拟机的自动内存管理系统要求对象起始地址必须是8字节的整数倍，
+换句话说就是对象的大小必须是8字节的整数倍。而对象头部分正好是8字节的倍数（1倍或2倍），因此，当对象实例数据部分没有对齐时，就需要通过对齐填充来补全。
 
 
 ### 对象的访问定位
-建立对象就是为了使用对象，我们的Java程序通过栈上的 reference 数据来操作堆上的具体对象。对象的访问方式有虚拟机实现而定，目前主流的访问方式有①使用句柄和②直接指针两种：
-1. 句柄
-    如果使用句柄的话，那么Java堆中将会划分出一块内存来作为句柄池，reference 中存储的就是对象的句柄地址，而句柄中包含了对象实例数据与类型数据各自的具体地址信息；
+建立对象就是为了使用对象，我们的Java程序通过栈上的reference数据来操作堆上的具体对象。对象的访问方式有虚拟机实现而定，目前主流的访问方式有使用句柄和直接指针两种：
+1. 句柄     
+    如果使用句柄的话，那么Java堆中将会划分出一块内存来作为句柄池，reference中存储的就是对象的句柄地址，而句柄中包含了对象实例数据与类型数据各自的具体地址信息；
     
     ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/java_refe_jubing.png)
     
-2. **直接指针：** 如果使用直接指针访问，那么 Java 堆对像的布局中就必须考虑如何防止访问类型数据的相关信息，reference 中存储的直接就是对象的地址。
+2. 直接指针    
+    如果使用直接指针访问，那么 Java 堆对像的布局中就必须考虑如何防止访问类型数据的相关信息，reference 中存储的直接就是对象的地址。
 
     ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/java_refe_direct.png)
 
-这两种对象访问方式各有优势。使用句柄来访问的最大好处是 reference 中存储的是稳定的句柄地址，在对象被移动时只会改变句柄中的实例数据指针，而 reference 本身不需要修改。使用直接指针访问方式最大的好处就是速度快，它节省了一次指针定位的时间开销。
-
-
+这两种对象访问方式各有优势。使用句柄来访问的最大好处是reference中存储的是稳定的句柄地址，在对象被移动时只会改变句柄中的实例数据指针，
+而reference本身不需要修改。使用直接指针访问方式最大的好处就是速度快，它节省了一次指针定位的时间开销。
 
 ## Runtime Data Area
 
@@ -146,7 +166,8 @@ Hotspot虚拟机的对象头包括两部分信息，第一部分用于存储对
 - .class文件是否与Class / Interface / Enum相关
 - 修饰符，静态变量和方法信息等。
 
-然后，对于每个已加载的.class文件，它都会按照java.lang包中的定义，恰好创建一个Class对象来表示堆内存中的文件。稍后，在我们的代码中，可以使用此Class对象读取类级别的信息（类名称，父名称，方法，变量信息，静态变量等）。
+然后，对于每个已加载的.class文件，它都会按照java.lang包中的定义，恰好创建一个Class对象来表示堆内存中的文件。稍后，在我们的代码中，可以使用此
+Class对象读取类级别的信息（类名称，父名称，方法，变量信息，静态变量等）。
 
 [具体可参考Java内存模型](https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/Java%E5%86%85%E5%AD%98%E6%A8%A1%E5%9E%8B.md)
 
@@ -156,21 +177,23 @@ Hotspot虚拟机的对象头包括两部分信息，第一部分用于存储对
 
 字节码的实际执行在这里进行。执行引擎通过读取分配给上述运行时数据区域的数据逐行执行字节码中的指令。
 
-
-
 ### Interpreter
 
 解释器解释字节码并一对一执行指令。因此，它可以快速解释一个字节码行，但是执行解释后的结果是一项较慢的任务。缺点是，当多次调用一个方法时，每次都需要新的解释和较慢的执行速度。
 
 ### Just-In-Time (JIT) Compiler
 
-如果只有解释器可用，则当多次调用一个方法时，每次也会进行解释，如果有效处理，这将是多余的操作。使用JIT编译器已经可以做到这一点。首先，它将整个字节码编译为本地代码（机器代码）。然后，对于重复的方法调用，它直接提供了本机代码，使用本机代码的执行比单步解释指令要快得多。本机代码存储在缓存中，因此可以更快地执行编译后的代码。
+如果只有解释器可用，则当多次调用一个方法时，每次也会进行解释，如果有效处理，这将是多余的操作。使用JIT编译器已经可以做到这一点。首先，它将整个字
+节码编译为本地代码（机器代码）。然后，对于重复的方法调用，它直接提供了本机代码，使用本机代码的执行比单步解释指令要快得多。本机代码存储在缓存中，
+因此可以更快地执行编译后的代码。
 
-但是，即使对于JIT编译器，编译所花费的时间也要比解释器所花费的时间更多。对于仅执行一次的代码段，最好对其进行解释而不是进行编译。同样，本机代码也存储在高速缓存中，这是一种昂贵的资源。在这种情况下，JIT编译器会在内部检查每个方法调用的频率，并仅在所选方法发生超过特定时间级别时才决定编译每个方法。自适应编译的想法已在Oracle Hotspot VM中使用。
+但是，即使对于JIT编译器，编译所花费的时间也要比解释器所花费的时间更多。对于仅执行一次的代码段，最好对其进行解释而不是进行编译。同样，本机代码也
+存储在高速缓存中，这是一种昂贵的资源。在这种情况下，JIT编译器会在内部检查每个方法调用的频率，并仅在所选方法发生超过特定时间级别时才决定编译每个
+方法。自适应编译的想法已在Oracle Hotspot VM中使用。
 
-当JVM供应商引入性能优化时，执行引擎有资格成为关键子系统。在这些工作中，以下4个组件可以大大提高其性能： 
+当JVM供应商引入性能优化时，执行引擎有资格成为关键子系统。在这些工作中，以下4个组件可以大大提高其性能：    
 
-- 中间代码生成器生成中间代码。
+- 中间代码生成器生成中间代码。  
 - 代码优化器负责优化上面生成的中间代码。
 - 目标代码生成器负责生成本机代码（即机器代码）。
 - Profiler是一个特殊的组件，负责查找性能热点（例如，多次调用一种方法的实例）
@@ -179,31 +202,40 @@ Hotspot虚拟机的对象头包括两部分信息，第一部分用于存储对
 
 - Oracle Hotspot VMs
 
-    Oracle通过流行的JIT编译器模型Hotspot Compiler实现了其标准Java VM的2种实现。通过分析，它可以确定最需要JIT编译的热点，然后将代码的那些性能关键部分编译为本机代码。随着时间的流逝，如果不再频繁调用这种已编译的方法，它将把该方法标识为不再是热点，并迅速从缓存中删除本机代码，并开始在解释器模式下运行。这种方法可以提高性能，同时避免不必要地编译很少使用的代码。此外，Hotspot Compiler可以即时确定使用lining等技术来优化已编译代码的最佳方式。编译器执行的运行时分析使它可以消除在确定哪些优化将产生最大性能收益方面的猜测。
+    Oracle通过流行的JIT编译器模型Hotspot Compiler实现了其标准Java VM的2种实现。通过分析，它可以确定最需要JIT编译的热点，然后将代码的那些
+    性能关键部分编译为本机代码。随着时间的流逝，如果不再频繁调用这种已编译的方法，它将把该方法标识为不再是热点，并迅速从缓存中删除本机代码，并开
+    始在解释器模式下运行。这种方法可以提高性能，同时避免不必要地编译很少使用的代码。此外，Hotspot Compiler可以即时确定使用lining等技术来优化
+    已编译代码的最佳方式。编译器执行的运行时分析使它可以消除在确定哪些优化将产生最大性能收益方面的猜测。
     这些虚拟机使用相同的运行时（解释器，内存，线程），但是将自定义构建JIT编译器的实现，如下所述。
 
     Oracle Java Hotspot Client VM是Oracle JDK和JRE的默认VM技术。它通过减少应用程序启动时间和内存占用量而在客户端环境中运行应用程序时进行了优化，以实现最佳性能。
-    Oracle Java Hotspot Server VM旨在为在服务器环境中运行的应用程序提供最高的程序执行速度。此处使用的JIT编译器称为“高级动态优化编译器”，它使用更复杂和多样化的性能优化技术。通过使用服务器命令行选项（例如Java服务器MyApp）来调用Java HotSpot Server VM。
+    Oracle Java Hotspot Server VM旨在为在服务器环境中运行的应用程序提供最高的程序执行速度。此处使用的JIT编译器称为“高级动态优化编译器”，
+    它使用更复杂和多样化的性能优化技术。通过使用服务器命令行选项（例如Java服务器MyApp）来调用Java HotSpot Server VM。
 
     Oracle的Java Hotspot技术以其快速的内存分配，快速高效的GC以及易于在大型共享内存多处理器服务器中扩展的线程处理能力而闻名。
 
 - IBM AOT (Ahead-Of-Time) Compiling
 
-    这里的特长是这些JVM共享通过共享缓存编译的本机代码，因此已经通过AOT编译器编译的代码可以由另一个JVM使用，而无需编译。另外，IBM JVM通过使用AOT编译器将代码预编译为JXE（Java可执行文件）文件格式，提供了一种快速的执行方式。
+    这里的特长是这些JVM共享通过共享缓存编译的本机代码，因此已经通过AOT编译器编译的代码可以由另一个JVM使用，而无需编译。另外，IBM JVM通过使用
+    AOT编译器将代码预编译为JXE（Java可执行文件）文件格式，提供了一种快速的执行方式。
 
 
 
 ### Garbage Collector (GC)
 
-只要引用了一个对象，JVM就会认为它是活动的。一旦不再引用对象，因此应用程序代码无法访问该对象，则垃圾收集器将其删除并回收未使用的内存。通常，垃圾回收是在后台进行的，但是我们可以通过调用System.gc()方法来触发垃圾回收（同样，无法保证执行。因此，请调用Thread.sleep（1000）并等待GC完成）。[具体内存回收部分请看JVM垃圾回收机制](https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/JVM%E5%9E%83%E5%9C%BE%E5%9B%9E%E6%94%B6%E6%9C%BA%E5%88%B6.md)
+只要引用了一个对象，JVM就会认为它是活动的。一旦不再引用对象，因此应用程序代码无法访问该对象，则垃圾收集器将其删除并回收未使用的内存。通常，垃圾
+回收是在后台进行的，但是我们可以通过调用System.gc()方法来触发垃圾回收（同样，无法保证执行。因此，请调用Thread.sleep（1000）并等待GC完成）。
+[具体内存回收部分请看JVM垃圾回收机制](https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/JVM%E5%9E%83%E5%9C%BE%E5%9B%9E%E6%94%B6%E6%9C%BA%E5%88%B6.md)
 
 
 
 ### JVM线程
 
-我们讨论了如何执行Java程序，但没有具体提及执行程序。实际上，为了执行我们前面讨论的每个任务，JVM并发运行多个线程。这些线程中的一些带有编程逻辑，并且是由程序（应用程序线程）创建的，而其余的则是由JVM本身创建的，以承担系统中的后台任务（系统线程）。
+我们讨论了如何执行Java程序，但没有具体提及执行程序。实际上，为了执行我们前面讨论的每个任务，JVM并发运行多个线程。这些线程中的一些带有编程逻辑，
+并且是由程序（应用程序线程）创建的，而其余的则是由JVM本身创建的，以承担系统中的后台任务（系统线程）。
 
-主应用程序线程是作为调用公共静态void main（String []）的一部分而创建的主线程，而所有其他应用程序线程都是由该主线程创建的。应用程序线程执行诸如执行以main（）方法开头的指令，在Heap区域中创建对象（如果它在任何方法逻辑中找到新关键字）之类的任务等。
+主应用程序线程是作为调用公共静态void main（String []）的一部分而创建的主线程，而所有其他应用程序线程都是由该主线程创建的。
+应用程序线程执行诸如执行以main（）方法开头的指令，在Heap区域中创建对象（如果它在任何方法逻辑中找到新关键字）之类的任务等。
 
 主要的系统线程有： 
 
@@ -225,7 +257,8 @@ Hotspot虚拟机的对象头包括两部分信息，第一部分用于存储对
 
 - VM thread
 
-    前提条件是，某些操作需要JVM到达安全点才能执行，在该点不再进行对Heap区域的修改。这种情况的示例是“世界停止”垃圾回收，线程堆栈转储，线程挂起和有偏向的锁吊销。这些操作可以在称为VM线程的特殊线程上执行。
+    前提条件是，某些操作需要JVM到达安全点才能执行，在该点不再进行对Heap区域的修改。这种情况的示例是“世界停止”垃圾回收，线程堆栈转储，线程挂起
+    和有偏向的锁吊销。这些操作可以在称为VM线程的特殊线程上执行。
 
 
 
diff --git "a/JavaKnowledge/MVC\344\270\216MVP\345\217\212MVVM.md" "b/JavaKnowledge/MVC\344\270\216MVP\345\217\212MVVM.md"
index 428ac290..02a3ad83 100644
--- "a/JavaKnowledge/MVC\344\270\216MVP\345\217\212MVVM.md"
+++ "b/JavaKnowledge/MVC\344\270\216MVP\345\217\212MVVM.md"
@@ -15,10 +15,10 @@ MVC 分层同时也简化了分组开发。不同的开发人员可同时开发
 
 - 优点
     - 耦合性低
-	- 重用性高
-	- 可维护性高
-	- 有利软件工程化管理
-	
+    - 重用性高
+    - 可维护性高
+    - 有利软件工程化管理
+    
 - 缺点
     - 没有明确的定义
     - 视图与控制器间的过于紧密的连接
@@ -34,7 +34,7 @@ MVP
 所有的交互都发生在`Presenter`内部，而在`MVC`中`View`会直接从`Model`中读取数据而不是通过`Controller`。
 在`MVC`里,`View`是可以直接访问`Model`的！从而，`View`里会包含`Model`信息，不可避免的还要包括一些业务逻辑。 
 在`MVC`模型里，更关注的`Model`的不变，而同时有多个对`Model`的不同显示及`View`。所以，在`MVC`模型里，`Model`不依赖于`View`，但是`View`是依赖于`Model`的。
-不仅如此，因为有一些业务逻辑在`View`里实现了，导致要更改`View`也是比较困难的，至少那些业务逻辑是无法重用的。	
+不仅如此，因为有一些业务逻辑在`View`里实现了，导致要更改`View`也是比较困难的，至少那些业务逻辑是无法重用的。    
 
 ![image](https://github.com/CharonChui/Pictures/blob/master/is-activity-god-the-mvp-architecture-10-638.jpg?raw=true)
 
@@ -56,8 +56,8 @@ MVP
 
 - 缺点
     由于对视图的渲染放在了`Presenter`中，所以视图和`Presenter`的交互会过于频繁。还有一点需要明白，如果`Presenter`过多地渲染了视图，
-	往往会使得它与特定的视图的联系过于紧密。一旦视图需要变更，那么`Presenter`也需要变更了。
-	比如说，原本用来呈现`Html`的`Presenter`现在也需要用于呈现Pdf了，那么视图很有可能也需要变更。
+    往往会使得它与特定的视图的联系过于紧密。一旦视图需要变更，那么`Presenter`也需要变更了。
+    比如说，原本用来呈现`Html`的`Presenter`现在也需要用于呈现Pdf了，那么视图很有可能也需要变更。
 
 MVVM
 ---
@@ -66,9 +66,11 @@ MVVM是Model-View-ViewModel的简写。
 
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/MVVM.png)
 
-MVVM模式将Presener改名为View Model，基本上与MVP模式完全一致，同样是以VM为核心，但是不同于MVP，MVVM采用了数据双向绑定的方案，替代了繁琐复杂的DOM操作。该模型中，View与VM保持同步，View绑定到VM的属性上，如果VM数据发生变化，通过数据绑定的方式，View会自动更新视图；VM同样也暴露出Model中的数据。
+MVVM模式将Presener改名为View Model，基本上与MVP模式完全一致，同样是以VM为核心，但是不同于MVP，MVVM采用了数据双向绑定的方案，替代了繁琐复杂的DOM操作。
+该模型中，View与VM保持同步，View绑定到VM的属性上，如果VM数据发生变化，通过数据绑定的方式，View会自动更新视图；VM同样也暴露出Model中的数据。
 
-看起来MVVM很好的解决了MVC和MVP的不足，但是由于数据和视图的双向绑定，导致出现问题时不太好定位来源，有可能数据问题导致，也有可能业务逻辑中对视图属性的修改导致。如果项目中打算用MVVM的话可以考虑使用官方的架构组件ViewModel、LiveData、DataBinding去实现MVVM
+看起来MVVM很好的解决了MVC和MVP的不足，但是由于数据和视图的双向绑定，导致出现问题时不太好定位来源，有可能数据问题导致，也有可能业务逻辑中对视图
+属性的修改导致。如果项目中打算用MVVM的话可以考虑使用官方的架构组件ViewModel、LiveData、DataBinding去实现MVVM
 
 
 
@@ -83,4 +85,4 @@ MVVM模式将Presener改名为View Model，基本上与MVP模式完全一致，
 - 邮箱 ：charon.chui@gmail.com  
 - Good Luck! 
 
-	
+    
diff --git "a/JavaKnowledge/Top-K\351\227\256\351\242\230.md" "b/JavaKnowledge/Top-K\351\227\256\351\242\230.md"
index 4acb0c67..d716c354 100644
--- "a/JavaKnowledge/Top-K\351\227\256\351\242\230.md"
+++ "b/JavaKnowledge/Top-K\351\227\256\351\242\230.md"
@@ -21,19 +21,28 @@ Top-K问题
 
 - 局部淘汰法
 
-    该方法与排序方法类似，用一个容器保存前`10000`个数，然后将剩余的所有数字逐一与容器内的最小数字相比，如果所有后续的元素都比容器内的`10000`个数还小，那么容器内这个`10000`个数就是最大`10000`个数。如果某一后续元素比容器内最小数字大，则删掉容器内最小元素，并将该元素插入容器，最后遍历完这`1`亿个数，得到的结果容器中保存的数即为最终结果了。此时的时间复杂度为`O（n+m^2）`，其中`m`为容器的大小，即`10000`。   
+    该方法与排序方法类似，用一个容器保存前`10000`个数，然后将剩余的所有数字逐一与容器内的最小数字相比，如果所有后续的元素都比容器内的`10000`个数还小，
+    那么容器内这个`10000`个数就是最大`10000`个数。如果某一后续元素比容器内最小数字大，则删掉容器内最小元素，并将该元素插入容器，最后遍历完这`1`
+    亿个数，得到的结果容器中保存的数即为最终结果了。此时的时间复杂度为`O（n+m^2）`，其中`m`为容器的大小，即`10000`。   
 
 - 分治法
 
-    将`1`亿个数据分成`100`份，每份`100`万个数据，找到每份数据中最大的`10000`个，最后在剩下的`100*10000`个数据里面找出最大的`10000`个。如果`100`万数据选择足够理想，那么可以过滤掉`1`亿数据里面`99%`的数据。`100`万个数据里面查找最大的`10000`个数据的方法如下：用快速排序的方法，将数据分为`2`堆，如果大的那堆个数`N`大于`10000`个，继续对大堆快速排序一次分成`2`堆，如果大的那堆个数`N`大于`10000`个，继续对大堆快速排序一次分成`2`堆，如果大堆个数`N`小于`10000`个，就在小的那堆里面快速排序一次，找第`10000-n`大的数字；递归以上过程，就可以找到第`10000`大的数。一共需要101次这样的比较。
+    将`1`亿个数据分成`100`份，每份`100`万个数据，找到每份数据中最大的`10000`个，最后在剩下的`100*10000`个数据里面找出最大的`10000`个。
+    如果`100`万数据选择足够理想，那么可以过滤掉`1`亿数据里面`99%`的数据。`100`万个数据里面查找最大的`10000`个数据的方法如下：
+    用快速排序的方法，将数据分为`2`堆，如果大的那堆个数`N`大于`10000`个，继续对大堆快速排序一次分成`2`堆，如果大的那堆个数`N`大于`10000`个，
+    继续对大堆快速排序一次分成`2`堆，如果大堆个数`N`小于`10000`个，就在小的那堆里面快速排序一次，找第`10000-n`大的数字；递归以上过程，就可
+    以找到第`10000`大的数。一共需要101次这样的比较。
 
 - `Hash`法    
 
-    如果这`1`亿个书里面有很多重复的数，先通过`Hash`法，把这`1`亿个数字去重复，这样如果重复率很高的话，会减少很大的内存用量，从而缩小运算空间，然后通过分治法或最小堆法查找最大的`10000`个数。    
+    如果这`1`亿个数里面有很多重复的数，先通过`Hash`法，把这`1`亿个数字去重复，这样如果重复率很高的话，会减少很大的内存用量，从而缩小运算空间，
+    然后通过分治法或最小堆法查找最大的`10000`个数。    
 
 - 最小堆   
 
-    首先读入前`10000`个数来创建大小为`10000`的最小堆，建堆的时间复杂度为`O（mlogm）`（`m`为数组的大小即为`10000`），然后遍历后续的数字，并于堆顶（最小）数字进行比较。如果比最小的数小，则继续读取后续数字；如果比堆顶数字大，则替换堆顶元素并重新调整堆为最小堆。整个过程直至`1`亿个数全部遍历完为止。然后按照中序遍历的方式输出当前堆中的所有`10000`个数字。该算法的时间复杂度为`O（nmlogm）`，空间复杂度是10000（常数）。    
+    首先读入前`10000`个数来创建大小为`10000`的最小堆，建堆的时间复杂度为`O（mlogm）`（`m`为数组的大小即为`10000`），然后遍历后续的数字，
+    并于堆顶（最小）数字进行比较。如果比最小的数小，则继续读取后续数字；如果比堆顶数字大，则替换堆顶元素并重新调整堆为最小堆。整个过程直至`1`亿
+    个数全部遍历完为止。然后按照中序遍历的方式输出当前堆中的所有`10000`个数字。该算法的时间复杂度为`O（nmlogm）`，空间复杂度是10000（常数）。    
 
 
 解决`Top K`问题有两种思路:   
diff --git "a/JavaKnowledge/Vim\344\275\277\347\224\250\346\225\231\347\250\213.md" "b/JavaKnowledge/Vim\344\275\277\347\224\250\346\225\231\347\250\213.md"
index eef7b2d9..1ade6bd3 100644
--- "a/JavaKnowledge/Vim\344\275\277\347\224\250\346\225\231\347\250\213.md"
+++ "b/JavaKnowledge/Vim\344\275\277\347\224\250\346\225\231\347\250\213.md"
@@ -18,10 +18,23 @@ Vim使用教程
 - `i` 进入`insert`模式
 - `a(append)` 在光标后进行插入，直接进入`insert`模式
 - `o(open a line below)` 在当前行后插入一个新行，直接进入`insert`模式
-- `I` 从改行的最前面开始编辑
-- `A` 从改行的最后面开始编辑
+- `I` 从该行的最前面开始编辑
+- `A` 从该行的最后面开始编辑
 - `cw` 替换从光标位置开始到该单词结束位置的所有字符，直接进入`Insert`模式
 
+在VIM中，有相当一部分命令可以扩展为3部分：
+
+- 开头的部分是一个数字，代表重复次数；
+- 中间的部分是命令；
+- 最后的部分，代表命令的对象。
+
+比如，命令3de中，3表示执行3次，d是删除命令，e表示从当前位置到单词的末尾。整条命令的意思就是，从当前位置向后，删除3个单词。类似的，命令3ce表示从当前位置向后，删除三个单词，然后进入编辑模式。
+
+可以看到，命令组合的前两个部分比较简单，但第三个部分也就是命令对象，技巧就比较多了。所以接下来，我就与你详细介绍下到底有哪些命令对象可以使用。
+
+其实，对命令对象并没有一个完整的分类。但我根据经验，将其总结为光标移动命令和文本对象两种。
+
+第一种是光标移动命令。比如，$命令是移动光标到本行末尾，那么d$就表示删除到本行末尾；再比如，4}表示向下移动4个由空行隔开的段落，那么d4}就是删除这4个段落。
 
 移动光标
 ---
@@ -36,7 +49,8 @@ Vim使用教程
 - `$` $光标移动当前行尾
 - `0` 数字0光标移动当前行首
 
-- `e` 移动到单词结束位置
+- `e` 向右移动一个单词
+- `w` 向右移动一个单词，与e的区别是w是把光标放到下一个单词的开头，而e是把光标放到这一个单词的结尾。
 - `b` 移动到单词开始位置
 - `:59` 移动到59行
 - `#l` 移动光标到该行第#个字的位置，如`5l`
@@ -96,7 +110,7 @@ Vim使用教程
 - `>>` 当前行缩进
 - `#>>` 当前光标下n行缩进
 - `<<` 当前行缩出
-- `>>` 当前光标下n行缩出
+- `#<<` 当前光标下n行缩出
 
 - `: set nu` 会在文件每一行前面显示行号
 - `:wq` 保存并退出
diff --git "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\346\225\260\346\215\256\347\273\223\346\236\204.md" "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\346\225\260\346\215\256\347\273\223\346\236\204.md"
index 90661d16..f8e8413f 100644
--- "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\346\225\260\346\215\256\347\273\223\346\236\204.md"
+++ "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\346\225\260\346\215\256\347\273\223\346\236\204.md"
@@ -1,19 +1,20 @@
 数据结构
 ===
 
-结构，简单的理解就是关系，比如分子结构，就是说组成分子的原子之间的排列方式。严格点说，结构是指各个组成部分相互搭配和排列的方式。在现实世界中，不同数据元素之间不是独立的，而是存在特定的关系，我们将这些关系称为结构。那数据结构是什么？
+结构，简单的理解就是关系，比如分子结构，就是说组成分子的原子之间的排列方式。严格点说，结构是指各个组成部分相互搭配和排列的方式。在现实世界中，
+不同数据元素之间不是独立的，而是存在特定的关系，我们将这些关系称为结构。那数据结构是什么？
 
 数据结构：是相互之间存在一种或多种特定关系的数据元素的集合。
 
 在计算机中，数据元素并不是孤立、杂乱无序的，而是具有内在联系的数据集合。数据元素之间存在的一种或多种特定关系，也就是数据的组织形式。
 
-
 按照视点的不同，我们把数据结构分为逻辑结构和物理结构。
 
 #### 逻辑结构
 逻辑结构：是指数据对象中数据元素之间的相互关系。其实这也是我们今后最需要关注的问题。逻辑结构分为以下四种：
 - 集合结构
-    集合结构：集合结构中的数据元素除了同属于一个集合外，它们之间没有其他关系。各个数据元素是“平等”的，它们的共同属性是“同属于一个集合”。数据结构中的集合关系就类似于数学中的集合
+    集合结构：集合结构中的数据元素除了同属于一个集合外，它们之间没有其他关系。各个数据元素是“平等”的，它们的共同属性是"同属于一个集合"。
+    数据结构中的集合关系就类似于数学中的集合
 - 线性结构
     线性结构：线性结构中的数据元素之间是一对一的关系
 - 树形结构
@@ -22,16 +23,15 @@
     图形结构：图形结构的数据元素是多对多的关系            
 
 #### 物理结构
-物理结构(有些成为存储结构)：是指数据的逻辑结构在计算机中的存储形式。
+物理结构(也称为存储结构)：是指数据的逻辑结构在计算机中的存储形式。
 - 顺序存储结构
     顺序存储结构：是把数据元素存放在地址连续的存储单元里，其数据间的逻辑关系和物理关系是一致的
-    这种存储结构其实很简单，说白了，就是排队占位。大家都按顺序排好，每个人占一小段空间，大家谁也别插谁的队。我们之前学计算机语言时，数组就是这样的顺序存储结构。当你告诉计算机，你要建立一个有9个整型数据的数组时，计算机就在内存中找了片空地，按照一个整型所占位置的大小乘以9，开辟一段连续的空间，于是第一个数组数据就放在第一个位置，第二个数据放在第二个，这样依次摆放。
+    这种存储结构其实很简单，说白了，就是排队占位。大家都按顺序排好，每个人占一小段空间，大家谁也别插谁的队。数组就是这
+    样的顺序存储结构。当你告诉计算机，你要建立一个有9个整型数据的数组时，计算机就在内存中找了片空地，按照一个整型所占位置的大小乘以9，开辟一段
+    连续的空间，于是第一个数组数据就放在第一个位置，第二个数据放在第二个，这样依次摆放。
 - 链式存储结构
-    链式存储结构：是把数据元素存放在任意的存储单元里，这组存储单元可以是连续的，也可以是不连续的。数据元素的存储关系并不能反映其逻辑关系，因此需要用一个指针存放数据元素的地址，这样通过地址就可以找到相关联数据元素的位置
-
-    
-
-
+    链式存储结构：是把数据元素存放在任意的存储单元里，这组存储单元可以是连续的，也可以是不连续的。数据元素的存储关系并不能反映其逻辑关系，因此
+    需要用一个指针存放数据元素的地址，这样通过地址就可以找到相关联数据元素的位置
 
 常见的数据结构:    
 
@@ -47,7 +47,8 @@
 
 ## 线性表 
 
-零个或多个数据元素的有限序列。除第一个元素外，每一个元素有且只有一个直接前驱元素，除了最后一个元素外，每一个元素有且只有一个直接后继元素。数据元素之间的关系是一对一的关系。
+零个或多个数据元素的有限序列。除第一个元素外，每一个元素有且只有一个直接前驱元素，除了最后一个元素外，每一个元素有且只有一个直接后继元素。
+数据元素之间的关系是一对一的关系。
 
 - 序列
     也就是说元素之间是有顺序的。
@@ -56,14 +57,16 @@
 
 线性表的顺序存储结构，在存、读数据时，不管是哪个位置，时间复杂度都是O(1)；
 而插入或删除时，时间复杂度都是O(n)。
-这就说明，它比较适合元素个数不太变化，而更多是存取数据的应用。当然，它的优缺点还不只这些。。
+这就说明，它比较适合元素个数不太变化，而更多是存取数据的应用。当然，它的优缺点还不止这些。
 
 由于线性表的顺序存储结构在插入和删除的时候需要移动大量元素，为了解决这个问题，有了线性表的链式存储结构。
 又分为单链表和多链表。
 
 ### 数组`(Array)`
 
-数组是一种大小固定的数据结构，对线性表的所有操作都可以通过数组来实现。数组是在内存中开辟一段连续的空间，并在此空间存放元素。就像是一排出租屋，有100个房间，从001到100每个房间都有固定编号，通过编号就可以快速找到租房子的人。虽然数组一旦创建之后，它的大小就无法改变了，但是当数组不能再存储线性表中的新元素时，我们可以创建一个新的大的数组来替换当前数组。这样就可以使用数组实现动态的数据结构。
+数组是一种大小固定的数据结构，对线性表的所有操作都可以通过数组来实现。数组是在内存中开辟一段连续的空间，并在此空间存放元素。就像是一排出租屋，
+有100个房间，从001到100每个房间都有固定编号，通过编号就可以快速找到租房子的人。虽然数组一旦创建之后，它的大小就无法改变了，但是当数组不能再存储
+线性表中的新元素时，我们可以创建一个新的大的数组来替换当前数组。这样就可以使用数组实现动态的数据结构。
 
 ```java
 int[] arr = new int[10];
@@ -78,13 +81,13 @@ int[] arr = new int[10];
 缺点:    
 
 - 增删慢，插入和删除的花费开销比较大，比如当在第一个位置前插入一个元素，那么首先要把所有的元素往后移动一个位置
-- 大小固定，只能存储单一元素，
+- 大小固定，只能存储单一元素
 
 ### 链表
 
 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。
-每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，链表比较方便插入和删除操作。
+每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。相比于线性表顺序结构，链表比较方便插入和删除操作。
 
 用一组地址任意的存储单元存放线性表中的数据元素。以元素(数据元素的映象)+指针(指示后继元素存储位置) = 结点。
 以“结点的序列”表示线性表,称作线性链表（单链表）。单链表是一种顺序存取的结构，为找第`i`个数据元素，必须先找到第`i-1`个数据元素。 
@@ -95,20 +98,18 @@ int[] arr = new int[10];
          │data│next│
          └──┴──┘──┘
 ```         
-`data`域:存放结点值的数据域 　　 
+`data`域:存放结点值的数据域
 `next`域:存放结点的直接后继的地址（位置）的指针域（链域）。
 
-
-链表又分为很多种： 静态链表、循环链表、单链表、双向链表
+链表又分为很多种：静态链表、循环链表、单链表、双向链表
 
 注意:    
 
-- 链表通过每个结点的链域将线性表的n个结点按其逻辑顺序链接在一起的。 　　
+- 链表通过每个结点的链域将线性表的n个结点按其逻辑顺序链接在一起的。
 - 每个结点只有一个链域的链表称为单链表`(Single Linked List)`
 
 所谓的链表就好像火车车厢一样，从火车头开始，每一节车厢之后都连着后一节车厢。
 
-
 单链表插入和删除算法，它们其实都是由两部分组成：
 第一部分就是遍历查找第i个元素；
 第二部分就是插入和删除元素。
@@ -122,7 +123,7 @@ int[] arr = new int[10];
 优点:   
 
 - 和数组相比，链表的优势在于长度不受限制，也不需要连续的内存空间。
-- 在进行插入和删除操作时，不需要移动数据项，故尽管某些操作的时间复杂度与数组想同，实际效率上还是比数组要高很多,所以插入快，删除快
+- 在进行插入和删除操作时，不需要移动数据项，故尽管某些操作的时间复杂度与数组相同，实际效率上还是比数组要高很多,所以插入快，删除快
 
 缺点:   
 
@@ -130,14 +131,16 @@ int[] arr = new int[10];
 - 查找慢
 - 相对数组只存储元素，链表的元素还要存储其他元素地址，内存开销相对增大
 
-
 ### 栈`(Stack)`
 
 栈是限定仅在表尾进行插入和删除操作的线性表。
 我们把允许插入和删除的一端称为栈顶（top），另一端称为栈底（bottom），不含任何数据元素的栈称为空栈。栈又称为后进先出（Last In First Out）的线性表，简称LIFO结构。
 
-> The Stack class represents a last-in-first-out (LIFO) stack of objects. It extends class Vector with five operations that allow a vector to be treated as a stack. The usual push and pop operations are provided, as well as a method to peek at the top item on the stack, a method to test for whether the stack is empty, and a method to search the stack for an item and discover how far it is from the top.
-When a stack is first created, it contains no items.
+> The Stack class represents a last-in-first-out (LIFO) stack of objects. It extends class Vector with five operations 
+> that allow a vector to be treated as a stack. The usual push and pop operations are provided, as well as a method to 
+> peek at the top item on the stack, a method to test for whether the stack is empty, and a method to search the stack 
+> for an item and discover how far it is from the top. 
+> When a stack is first created, it contains no items.
 
 栈是限制插入和删除只能在一个位置上进行的表，该位置是表的末端，叫作栈顶，数据称为压栈，移除数据称为弹栈(就像子弹弹夹装弹和取弹一样)。
 对栈的基本操作有`push`(进栈)和`pop`(出栈)，前者相当于插入，后者相当于删除最后一个元素。栈有时又叫作`LIFO(Last In First Out)`表，
@@ -155,17 +158,23 @@ When a stack is first created, it contains no items.
 ### 链栈
 
 栈的顺序存储结构，我们现在来看看栈的链式存储结构，简称为链栈。
-对于链栈来说，基本不存在栈满的情况，除非内存已经没有可以使用的空间，如果真的发生，那此时的计算机操作系统已经面临死机崩溃的情况，而不是这个链栈是否溢出的问题。
-对比一下顺序栈与链栈，它们在时间复杂度上是一样的，均为O(1)。对于空间性能，顺序栈需要事先确定一个固定的长度，可能会存在内存空间浪费的问题，但它的优势是存取时定位很方便，而链栈则要求每个元素都有指针域，这同时也增加了一些内存开销，但对于栈的长度无限制。所以它们的区别和线性表中讨论的一样，如果栈的使用过程中元素变化不可预料，有时很小，有时非常大，那么最好是用链栈，反之，如果它的变化在可控范围内，建议使用顺序栈会更好一些。
+对于链栈来说，基本不存在栈满的情况，除非内存已经没有可以使用的空间，如果真的发生，那此时的计算机操作系统已经面临死机崩溃的情况，而不是这个链栈是
+否溢出的问题。
+对比一下顺序栈与链栈，它们在时间复杂度上是一样的，均为O(1)。对于空间性能，顺序栈需要事先确定一个固定的长度，可能会存在内存空间浪费的问题，
+但它的优势是存取时定位很方便，而链栈则要求每个元素都有指针域，这同时也增加了一些内存开销，但对于栈的长度无限制。所以它们的区别和线性表中讨论的
+一样，如果栈的使用过程中元素变化不可预料，有时很小，有时非常大，那么最好是用链栈，反之，如果它的变化在可控范围内，建议使用顺序栈会更好一些。
 
 
 #### 栈的应用-递归
 
-
 把一个直接调用自己或通过一系列的调用语句间接地调用自己的函数，称做递归函数。
 当然，写递归程序最怕的就是陷入永不结束的无穷递归中，所以，每个递归定义必须至少有一个条件，满足时递归不再进行，即不再引用自身而是返回值退出。
 
-那么我们讲了这么多递归的内容，和栈有什么关系呢？这得从计算机系统的内部说起。前面我们已经看到递归是如何执行它的前行和退回阶段的。递归过程退回的顺序是它前行顺序的逆序。在退回过程中，可能要执行某些动作，包括恢复在前行过程中存储起来的某些数据。这种存储某些数据，并在后面又以存储的逆序恢复这些数据，以提供之后使用的需求，显然很符合栈这样的数据结构，因此，编译器使用栈实现递归就没什么好惊讶的了。简单的说，就是在前行阶段，对于每一层递归，函数的局部变量、参数值以及返回地址都被压入栈中。在退回阶段，位于栈顶的局部变量、参数值和返回地址被弹出，用于返回调用层次中执行代码的其余部分，也就是恢复了调用的状态。
+那么我们讲了这么多递归的内容，和栈有什么关系呢？这得从计算机系统的内部说起。前面我们已经看到递归是如何执行它的前行和退回阶段的。
+递归过程退回的顺序是它前行顺序的逆序。在退回过程中，可能要执行某些动作，包括恢复在前行过程中存储起来的某些数据。这种存储某些数据，
+并在后面又以存储的逆序恢复这些数据，以提供之后使用的需求，显然很符合栈这样的数据结构，因此，编译器使用栈实现递归就没什么好惊讶的了。
+简单的说，就是在前行阶段，对于每一层递归，函数的局部变量、参数值以及返回地址都被压入栈中。在退回阶段，位于栈顶的局部变量、参数值和返回地址被弹出，
+用于返回调用层次中执行代码的其余部分，也就是恢复了调用的状态。
 
 
 ### 队列`(Queue)`
@@ -173,7 +182,8 @@ When a stack is first created, it contains no items.
 队列是只允许在一端进行插入操作、而在另一端进行删除操作的线性表。
 队列是一种先进先出（First In First Out）的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为队头。
 
-队列是一种特殊的线性表，特殊之处在于它只允许在表的前端`(front)`进行删除操作，而在表的后端`(rear)`进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。先进先出，简单暴力的理解就是吃进去拉出来   
+队列是一种特殊的线性表，特殊之处在于它只允许在表的前端`(front)`进行删除操作，而在表的后端`(rear)`进行插入操作，和栈一样，队列是一种操作受限制
+的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。先进先出，简单暴力的理解就是吃进去拉出来   
 
 
 优点:    
@@ -195,8 +205,9 @@ When a stack is first created, it contains no items.
 
 ### 树`(Tree)`
 
-
-树（Tree）是n（n≥0）个结点的有限集。n=0时称为空树。在任意一棵非空树中：（1）有且仅有一个特定的称为根（Root）的结点；（2）当n＞1时，其余结点可分为m（m＞0）个互不相交的有限集T1、T2、……、Tm，其中每一个集合本身又是一棵树，并且称为根的子树（SubTree）。
+树（Tree）是n（n≥0）个结点的有限集。n=0时称为空树。在任意一棵非空树中：    
+- 有且仅有一个特定的称为根（Root）的结点；
+- 当n＞1时，其余结点可分为m（m＞0）个互不相交的有限集T1、T2、……、Tm，其中每一个集合本身又是一棵树，并且称为根的子树（SubTree）。
 
 
 树是由`n（n>=1）`个有限节点组成一个具有层次关系的集合。       
@@ -241,7 +252,8 @@ When a stack is first created, it contains no items.
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/wanquan_binary_tree.jpg?raw=true)
 
 
-完全二叉树是效率很高的数据结构，堆是一种完全二叉树或者近似完全二叉树，所以效率极高，像十分常用的排序算法、Dijkstra算法、Prim算法等都要用堆才能优化，二叉排序树的效率也要借助平衡性来提高，而平衡性基于完全二叉树。
+完全二叉树是效率很高的数据结构，堆是一种完全二叉树或者近似完全二叉树，所以效率极高，像十分常用的排序算法、Dijkstra算法、Prim算法等都要用堆才
+能优化，二叉排序树的效率也要借助平衡性来提高，而平衡性基于完全二叉树。
 
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/man_binary_tree.png?raw=true)
@@ -250,20 +262,25 @@ When a stack is first created, it contains no items.
 
 我们知道一颗基本的二叉排序树他们都需要满足一个基本性质：即树中的任何节点的值大于它的左子节点，且小于它的右子节点。
 
-按照这个基本性质使得树的检索效率大大提高。我们知道在生成二叉排序树的过程是非常容易失衡的，最坏的情况就是一边倒（只有右/左子树），这样势必会导致二叉树的检索效率大大降低`(O(n))`，所以为了维持二叉排序树的平衡，大牛们提出了各种平衡二叉树的实现算法，在平衡二叉搜索树中，其高度一般都良好地维持在`O(log2n)`，大大降低了操作的时间复杂度。如：`AVL`，`SBT`，伸展树，`TREAP` ，红黑树等等。
+按照这个基本性质使得树的检索效率大大提高。我们知道在生成二叉排序树的过程是非常容易失衡的，最坏的情况就是一边倒（只有右/左子树），
+这样势必会导致二叉树的检索效率大大降低`(O(n))`，所以为了维持二叉排序树的平衡，大牛们提出了各种平衡二叉树的实现算法，在平衡二叉搜索树中，
+其高度一般都良好地维持在`O(log2n)`，大大降低了操作的时间复杂度。如：`AVL`，`SBT`，伸展树，`TREAP` ，红黑树等等。
 
 
 #### 平衡二叉树       
 
-平衡二叉树必须具备如下特性：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。也就是说该二叉树的任何一个子节点，其左右子树的高度都相近。下面给出平衡二叉树的示意图：
+平衡二叉树必须具备如下特性：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。也就是说该二叉树的任何一
+个子节点，其左右子树的高度都相近。下面给出平衡二叉树的示意图：
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/pingheng_binary_tree.jpg?raw=true)
 
 
-
 #### 红黑树
 
-红黑树顾名思义就是结点是红色或者是黑色的平衡二叉树，它通过颜色的约束来维持着二叉树的平衡。红黑树是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。它是在1972年由`Rudolf Bayer`发明的，他称之为"对称二叉B树"，它现代的名字是在`Leo J. Guibas`和`Robert Sedgewick`于1978年写的一篇论文中获得的。它是复杂的，但它的操作有着良好的最坏情况运行时间，并且在实践中是高效的: 它可以在`O(log n)`时间内做查找，插入和删除，这里的`n`是树中元素的数目。
+红黑树顾名思义就是结点是红色或者是黑色的平衡二叉树，它通过颜色的约束来维持着二叉树的平衡。红黑树是一种自平衡二叉查找树，是在计算机科学中用到的
+一种数据结构，典型的用途是实现关联数组。它是在1972年由`Rudolf Bayer`发明的，他称之为"对称二叉B树"，它现代的名字是在`Leo J. Guibas`和
+`Robert Sedgewick`于1978年写的一篇论文中获得的。它是复杂的，但它的操作有着良好的最坏情况运行时间，并且在实践中是高效的: 它可以在`O(log n)`
+时间内做查找，插入和删除，这里的`n`是树中元素的数目。
 
 对于一棵有效的红黑树而言我们必须增加如下规则，这也是红黑树最重要的5点规则:      
 
@@ -275,7 +292,6 @@ When a stack is first created, it contains no items.
 
 这些约束强制了红黑树的关键性质: 从根到叶子最长的可能路径不多于最短的可能路径的两倍长。结果是这棵树大致上是平衡的。
 
-
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/hongheishu.jpg?raw=true)
 
 黑红树节点的`java`表示结构:   
@@ -328,19 +344,6 @@ private boolean isRed(Node x){
 }
 ```
 
-
-
-
-
-
-
-
-
-
-
-
-
-
 哈希表`(Hash)`
 ---
 
@@ -367,13 +370,11 @@ private boolean isRed(Node x){
 - 堆是完全二叉树
 - 常常用数组实现
 
-
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/heap_1.png?raw=true)
 
 二叉堆是完全二元树或者是近似完全二元树，它分为两种：最大堆和最小堆。 
 最大堆：父结点的键值总是大于或等于任何一个子节点的键值；最小堆：父结点的键值总是小于或等于任何一个子节点的键值。
 
-
 优点:     
 
 - 插入、删除快，对最大数据项存取快  
@@ -386,8 +387,9 @@ private boolean isRed(Node x){
 图`(Graph)`
 ---
 
-
-图是一种较线性表和树更为复杂的数据结构，在线性表中，数据元素之间仅有线性关系，在树形结构中，数据元素之间有着明显的层次关系，而在图形结构中，节点之间的关系可以是任意的，图中任意两个数据元素之间都可能相关。图的应用相当广泛，特别是近年来的迅速发展，已经渗入到诸如语言学、逻辑学、物理、化学、电讯工程、计算机科学以及数学的其他分支中。
+图是一种较线性表和树更为复杂的数据结构，在线性表中，数据元素之间仅有线性关系，在树形结构中，数据元素之间有着明显的层次关系，而在图形结构中，
+节点之间的关系可以是任意的，图中任意两个数据元素之间都可能相关。图的应用相当广泛，特别是近年来的迅速发展，已经渗入到诸如语言学、逻辑学、物理、
+化学、电讯工程、计算机科学以及数学的其他分支中。
 图（Graph）是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为：G（V,E），其中，G表示一个图，V是图G中顶点的集合，E是图G中边的集合。
 
 
@@ -402,25 +404,9 @@ private boolean isRed(Node x){
 
 
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-		
+        
 ---
 - 邮箱 ：charon.chui@gmail.com  
 - Good Luck! 
 
-	
+    
diff --git "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md" "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
index a6c78e71..72fdaebe 100644
--- "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
+++ "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
@@ -13,7 +13,9 @@
 [Kotlin官网](https://kotlinlang.org/)
 
 `JetBrains`这家公司非常牛逼，开发了很多著名的软件，他们在使用`Java`的过程中发现`java`比较笨重不方便，所以就开发了`kotlin`，`kotlin`是
-一种全栈的开发语言，可以用它进行开发`web`、`web`后端、`Android`等。    但是JetBrains团队设计Kotlin所要面临的第一个问题就是必须兼容他们所拥有的数百万行Java代码库，这也代表了Kotlin基于整个Java社区所承载的使命之一，即需要与现有的Java代码完全兼容。这个背景也决定了Kotlin的核心目标--为Java程序员提供一门更好的编程语言。
+一种全栈的开发语言，可以用它进行开发`web`、`web`后端、`Android`等。    
+但是JetBrains团队设计Kotlin所要面临的第一个问题就是必须兼容他们所拥有的数百万行Java代码库，这也代表了Kotlin基于整个Java社区所承载的使命之一，
+即需要与现有的Java代码完全兼容。这个背景也决定了Kotlin的核心目标--为Java程序员提供一门更好的编程语言。
 
 很多开发者都说`Google`学什么不好，非要学苹果，出个`android`的`swift`版本，一定会搞不起来没人用，所以不用浪费时间去学习。在这里想引用马云
 的一句话: 
@@ -143,11 +145,12 @@ class MainActivity : AppCompatActivity() {
 }
 ```
 
-
-
 ## 变量
 
-变量可以很简单地定义成可变`var`(可读可写)和不可变`val`(只读)的变量。如果var代表了varible(变量)，那么val可看成value(值)的缩写，但是也有人觉得这样并不直观或准确，而是把val解释成varible+final，即通过val声明的变量具有Java中的final关键字的效果(我们通过查看对val语法反编译后转化的java代码，从中可以很清楚的发现它是用final实现的)，也就是引用不可变。因此，val声明的变量是只读变量，它的引用不可更改，但并不代表其引用对象也不可变。事实上，我们依然可以修改引用对象的可变成员。
+变量可以很简单地定义成可变`var`(可读可写)和不可变`val`(只读)的变量。如果var代表了variable(变量)，那么val可看成value(值)的缩写，
+但是也有人觉得这样并不直观或准确，而是把val解释成variable+final，即通过val声明的变量具有Java中的final关键字的
+效果(我们通过查看对val语法反编译后转化的java代码，从中可以很清楚的发现它是用final实现的)，也就是引用不可变。
+因此，val声明的变量是只读变量，它的引用不可更改，但并不代表其引用对象也不可变。事实上，我们依然可以修改引用对象的可变成员。
 
 声明:  
 ```kotlin
@@ -161,7 +164,8 @@ book.printName() // Diving into Kotlin
 
 再提示一下:`kotlin`中每行代码结束不需要分号了，不要和`java`是的每行都带分号
 
-字面上可以写明具体的类型。这个不是必须的，但是一个通用的`Kotlin`实践是省略变量的类型我们可以让编译器自己去推断出具体的类型，**Kotlin拥有比Java更加强大的类型推导功能，这避免了静态类型语言在编码时需要书写大量类型的弊端**:   
+字面上可以写明具体的类型。这个不是必须的，但是一个通用的`Kotlin`实践是省略变量的类型我们可以让编译器自己去推断出具体的类型，
+**Kotlin拥有比Java更加强大的类型推导功能，这避免了静态类型语言在编码时需要书写大量类型的弊端**:   
 ```kotlin
 var age = 18 // int
 val name = "charon" // string
@@ -170,40 +174,41 @@ var weight = 70.5 // double
 ```
 
 在`Kotlin`中，一切都是对象。没有像`Java`中那样的原始基本类型。
-当然，像`Integer`，`Float`或者`Boolean`等类型仍然存在，但是它们全部都会作为对象存在的。基本类型的名字和它们工作方式都是与`Java`非常相似的，但是有一些不同之处你可能需要考虑到:    
-
-- 数字类型中不会自动转型。举个例子，你不能给`Double`变量分配一个`Int`。必须要做一个明确的类型转换，可以使用众多的函数之一:   
-	```kotlin
-	private var age = 18
-	private var weight = age.toFloat()
-	```
+当然，像`Integer`，`Float`或者`Boolean`等类型仍然存在，但是它们全部都会作为对象存在的。基本类型的名字和它们工作方式都是与`Java`非常相似的，
+但是有一些不同之处你可能需要考虑到:    
+
+- 数字类型中不会自动转型。举个例子，你不能给`Double`变量分配一个`Int`。必须要做一个明确的类型转换，可以使用众多的函数之一:
+    ```kotlin
+    private var age = 18
+    private var weight = age.toFloat()
+    ```
 - 字符（`Char`）不能直接作为一个数字来处理。在需要时我们需要把他们转换为一个数字:       
-	```kotlin
-	val c: Char='c'
-	val i: Int = c.toInt()
-	```
+    ```kotlin
+    val c: Char='c'
+    val i: Int = c.toInt()
+    ```
 - 位运算也有一点不同。在`Android`中，我们经常在`flags`中使用`或`:      
-	```java
-	// Java
-	int bitwiseOr = FLAG1 | FLAG2;
-	int bitwiseAnd = FLAG1 & FLAG2;
-	```
-
-	```kotlin
-	// Kotlin
-	val bitwiseOr = FLAG1 or FLAG2
-	val bitwiseAnd = FLAG1 and FLAG2
-	```
+    ```java
+    // Java
+    int bitwiseOr = FLAG1 | FLAG2;
+    int bitwiseAnd = FLAG1 & FLAG2;
+    ```
+
+    ```kotlin
+    // Kotlin
+    val bitwiseOr = FLAG1 or FLAG2
+    val bitwiseAnd = FLAG1 and FLAG2
+    ```
 
 - 一个`String`可以像数组那样访问，并且也可以被迭代:     
-	```kotlin
-	var s = "charon"
-	var c = s[2]
+    ```kotlin
+    var s = "charon"
+    var c = s[2]
 
-	for (a in s) {
-	    Log.e("@@@", a + "");
-	}
-	```
+    for (a in s) {
+        Log.e("@@@", a + "");
+    }
+    ```
 
 
 
@@ -211,9 +216,11 @@ var weight = 70.5 // double
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/variable.jpg?raw=true)        
 
-当该对象被赋值给变量时，这个对象本身并不会被直接赋值给当前的变量。相反，该对象的引用会被赋值给该变量。因为当前的变量存储的是对象的引用，因此它可以访问该对象。
+当该对象被赋值给变量时，这个对象本身并不会被直接赋值给当前的变量。相反，该对象的引用会被赋值给该变量。
+因为当前的变量存储的是对象的引用，因此它可以访问该对象。
 
-如果你使用val来声明一个变量，那么该变量所存储的对象的引用将不可修改。然而如果你使用var声明了一个变量，你可以对该变量重新赋值。例如，如果我们使用代码： `x = 6`，将x的值赋为6，此时会创建一个值为6的新Int对象，并且x会存放该对象的引用。下面新的引用会替代原有的引用值被存放在x中： 
+如果你使用val来声明一个变量，那么该变量所存储的对象的引用将不可修改。然而如果你使用var声明了一个变量，你可以对该变量重新赋值。
+例如，如果我们使用代码： `x = 6`，将x的值赋为6，此时会创建一个值为6的新Int对象，并且x会存放该对象的引用。下面新的引用会替代原有的引用值被存放在x中： 
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/var_chage.jpg?raw=true)        
 
@@ -221,7 +228,8 @@ var weight = 70.5 // double
 
 ### 优先使用val来避免副作用
 
-在很多Kotlin的学习资料中，都会传递一个原则：优先使用val来声明变量。这相当正确，但更好的理解可以是：尽可能采用val、不可变对象及纯函数来设计程序。关于纯函数的概念，其实就是没有副作用的函数，具备引用透明性。
+在很多Kotlin的学习资料中，都会传递一个原则：优先使用val来声明变量。这相当正确，但更好的理解可以是：尽可能采用val、不可变对象及纯函数来设计程序。
+关于纯函数的概念，其实就是没有副作用的函数，具备引用透明性。
 
 简单来说，副作用就是修改了某处的某些东西，比如说：
 
@@ -282,7 +290,9 @@ var size: Int = 2
 这个例子中就会内存溢出。   
 
 `kotlin`为此提供了一种我们要说的后端变量，也就是`field`。编译器会检查函数体，如果使用到了它，就会生成一个后端变量，否则就不会生成。
-我们在使用的时候，用`field`代替属性本身进行操作。按照惯例`set`参数的名称是`value`，但是如果你喜欢你可以选择一个不同的名称。setter通过field标识更新变量属性值。field指的是属性的支持字段，你可以将其视为对属性的底层值的引用。在getter和setter中使用field代替属性名称很重要，因为这样可以阻止你陷入无限循环中。
+我们在使用的时候，用`field`代替属性本身进行操作。按照惯例`set`参数的名称是`value`，但是如果你喜欢你可以选择一个不同的名称。
+setter通过field标识更新变量属性值。field指的是属性的支持字段，你可以将其视为对属性的底层值的引用。在getter和setter中使用field代替属性名称
+很重要，因为这样可以阻止你陷入无限循环中。
 
 ```kotlin
 class A {
@@ -314,12 +324,15 @@ var myProperty: String
     }
 ```
 
-这意味着无论何时当你使用点操作符来获取或设置属性值时，实际上你总是调用了属性的getter或是setter。那么，为什么编译器要这么做呢？为属性添加getter和setter意味着有访问该属性的标准方法。getter处理获取值的所有请求，而setter处理所有属性值设置的请求。因此，如果你想要改变处理这些请求的方式，你可以在不破坏任何人代码的前提下进行。通过将其包装在getter和setter中来输出对属性的直接访问称为数据隐藏。
+这意味着无论何时当你使用点操作符来获取或设置属性值时，实际上你总是调用了属性的getter或是setter。那么，为什么编译器要这么做呢？
+为属性添加getter和setter意味着有访问该属性的标准方法。getter处理获取值的所有请求，而setter处理所有属性值设置的请求。
+因此，如果你想要改变处理这些请求的方式，你可以在不破坏任何人代码的前提下进行。通过将其包装在getter和setter中来输出对属性的直接访问称为数据隐藏。
 
 ## 延迟初始化
 
-我们说过，在类内声明的属性必须初始化，如果设置非`null`的属性，应该将此属性在构造器内进行初始化。
-假如想在类内声明一个`null`属性，在需要时再进行初始化（最典型的就是懒汉式单例模式），这就与`Kotlin`的规则是相背的，此时我们可以声明一个属性并延迟其初始化，此属性用`lateinit`修饰符修饰。
+在类内声明的属性必须初始化，如果设置非`null`的属性，应该将此属性在构造器内进行初始化。
+假如想在类内声明一个`null`属性，在需要时再进行初始化（最典型的就是懒汉式单例模式），这就与`Kotlin`的规则是相背的，此时我们可以声明一个属性并
+延迟其初始化，此属性用`lateinit`修饰符修饰。
 
 ```kotlin
 class MainActivity : AppCompatActivity() {
@@ -342,7 +355,7 @@ class MainActivity : AppCompatActivity() {
 }
 ```
 需要注意的是，我们在使用的时候，一定要确保属性是被初始化过的，通常先调用初始化方法，否则会有异常。
-如果只是用`lateinit`声明了，但是还没有调用初始化方法就使用，哪怕你判断了该变量是否为`null`也是会`crash`的。
+如果只是用`lateinit`声明了，但是还没有调用初始化方法就使用，哪怕你判断了该变量是否为`null`也是会`crash`的：
 ```kotlin
 private lateinit var test: String
 
@@ -375,7 +388,7 @@ class Test{
     }
 }
 ```
-注意: :myService.isInitialized可用于判断adapter变量是否已经初始化。虽然语法看上去有点奇怪，但这是固定的写法。`::`前缀不能省
+注意: ::myService.isInitialized可用于判断adapter变量是否已经初始化。虽然语法看上去有点奇怪，但这是固定的写法。`::`前缀不能省
 
 除了使用`lateinit`外还可以使用`by lazy {}`效果是一样的：   
 ```kotlin
@@ -400,9 +413,11 @@ test is not null haha
 - `by lazy{}`只能用在`val`类型而`lateinit`只能用在`var`类型
 - `lateinit`不能用在可空的属性上和`java`的基本类型上,否则会报`lateinit`错误   
 
-lazy的背后是接受一个lambda并返回一个Lazy<T>实例的函数，第一次访问该属性时，会执行lazy对应的Lambda表达式并记录结果，后续访问该属性时只是返回记录的结果。
+lazy的背后是接收一个lambda并返回一个Lazy<T>实例的函数，第一次访问该属性时，会执行lazy对应的Lambda表达式并记录结果，后续访问该属性时只是返回记录的结果。
 
-另外系统会给lazy属性默认加上同步锁，也就是LazyThreadSafetyMode.SYNCHRONIZED，它在同一时刻只允许一个线程对lazy属性进行初始化，所以它是线程安全的。但若你能确认该属性可以并行执行，没有线程安全问题，那么可以给lazy传递LazyThreadSafetyMode.PUBLICATION参数。你还可以给lazy传递LazyThreadSafetyMode.NONE参数，这将不会有任何线程方面的开销，当然也不会有任何线程安全的保证。例如:  
+另外系统会给lazy属性默认加上同步锁，也就是LazyThreadSafetyMode.SYNCHRONIZED，它在同一时刻只允许一个线程对lazy属性进行初始化，所以它是线程安全的。
+但若你能确认该属性可以并行执行，没有线程安全问题，那么可以给lazy传递LazyThreadSafetyMode.PUBLICATION参数。
+你还可以给lazy传递LazyThreadSafetyMode.NONE参数，这将不会有任何线程方面的开销，当然也不会有任何线程安全的保证。例如:  
 
 ```kotlin
 val sex: String by lazy(LazyThreadSafetyMode.PUBLICATION) {
@@ -416,6 +431,23 @@ val sex: String by lazy(LazyThreadSafetyMode.NONE) {
 }
 ```
 
+- 尽量不要使用lateinit来定义不可空类型的变量，可能会在使用时出现null的情况
+- 只读变量（val修饰）可以使用by lazy { }实现懒加载，可变变量（var修饰）使用改写get方法的形式实现懒加载
+```kotlin
+// 只读变量
+private val lazyImmutableValue: String by lazy {
+    "Hello"
+}
+
+// 可变变量
+private var lazyValue: Fragment? = null
+    get() {
+        if (field == null) {
+            field = Fragment()
+        }
+        return field
+    }
+```
 
 
 ## 类的定义:使用`class`关键字
@@ -424,14 +456,15 @@ val sex: String by lazy(LazyThreadSafetyMode.NONE) {
 
 - 每个对象自身的特点
 
-    对象自身的特点称为属性（properties）。它们代表了对象自身的状态（数据），并且该类中的每一个对象都有自己独特的数值。例如，一个狗（Dog）类可能有名字（name）、体重（weight）和品种（breed）属性。一个歌曲（Song）类可能有标题（title）和演唱者（artist）属性。
+    对象自身的特点称为属性（properties）。它们代表了对象自身的状态（数据），并且该类中的每一个对象都有自己独特的数值。
+    例如，一个狗（Dog）类可能有名字（name）、体重（weight）和品种（breed）属性。一个歌曲（Song）类可能有标题（title）和演唱者（artist）属性。
 
 - 每个对象的行为
 
-    对象的行为是它们的函数（functions）。它们决定了对象的行为，并且可能会使用对象的属性。例如，上面提到的Dog类，可能具有吠叫（bark）函数；Song这个类可能会有播放（play）函数。
-
-
+    对象的行为是它们的函数（functions）。它们决定了对象的行为，并且可能会使用对象的属性。例如，上面提到的Dog类，可能具有吠叫（bark）函数；
+    Song这个类可能会有播放（play）函数。
 
+  
 类可以包含:  
 
 - 构造函数和初始化块
@@ -441,17 +474,14 @@ val sex: String by lazy(LazyThreadSafetyMode.NONE) {
 - 对象声明
 
 
-
-你可以将类想象成一个对象的模板，因为它告诉编译器如何创建该特定类的对象。它还将告诉编译器每个对象应该具有哪些属性，并且从该类生成的每个对象都可以拥有自己独有的属性值。例如，每个Dog对象都有自己的名称、重量和品种属性，每个Dog的属性值都可以是不同的。
+你可以将类想象成一个对象的模板，因为它告诉编译器如何创建该特定类的对象。它还将告诉编译器每个对象应该具有哪些属性，并且从该类生成的每个对象都可以
+拥有自己独有的属性值。例如，每个Dog对象都有自己的名称、重量和品种属性，每个Dog的属性值都可以是不同的。
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/kotlin_class_1.jpg?raw=true)        
 
-
-
-
 ```kotlin
 class Dog(val name: String, var weight: Int, val breed: String){
-	fun bark() {
+    fun bark() {
         
     }
 }
@@ -493,14 +523,11 @@ var myDog = Dog("Fido", 70, "Mixed")
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/kotlin_dog_new.jpg?raw=true)        
 
 
-
-
-
-
-
 ### 构造函数
 
-构造函数包含了初始化对象所需的代码。它在对象被分配给引用之前运行，这意味着你有机会对对象进行一些内部操作以便其被使用。大多人使用构造函数来定义对象的属性，并且给这些属性赋值。每当你创建一个新的对象，该对象所属的类的构造函数将会被调用。构造函数在你初始化对象时被调用。它通常被用于定义对象的属性，并且对属性赋值。
+构造函数包含了初始化对象所需的代码。它在对象被分配给引用之前运行，这意味着你有机会对对象进行一些内部操作以便其被使用。大多人使用构造函数来定义对
+象的属性，并且给这些属性赋值。每当你创建一个新的对象，该对象所属的类的构造函数将会被调用。构造函数在你初始化对象时被调用。它通常被用于定义对象的
+属性，并且对属性赋值。
 
 在`Kotlin`中的一个类可以有一个主构造函数和一个或多个次构造函数。
 
@@ -586,7 +613,9 @@ val bird1 = Bird(color = "black")
 val bird2 = Bird(weight = 1000.00, color = "black")
 ```
 
-上面在Bird类中使用了val或者var来声明构造方法的参数。这一方面代表了参数的引用可变性，另一方面也使得我们在构造类的语法上得到了简化。事实上，构造方法的参数名前当然可以没有val和var。然而带上它们之后就等价于在Bird类内部声明了一个同名的属性，我们可以用this来进行调用。比如，上面定义的Bird类就类似于一下实现:  
+上面在Bird类中使用了val或者var来声明构造方法的参数。这一方面代表了参数的引用可变性，另一方面也使得我们在构造类的语法上得到了简化。事实上，
+构造方法的参数名前当然可以没有val和var。然而带上它们之后就等价于在Bird类内部声明了一个同名的属性，我们可以用this来进行调用。
+比如，上面定义的Bird类就类似于一下实现:  
 
 ```kotlin
 // 构造方法参数名前没有val
@@ -604,7 +633,8 @@ class Bird (weight: Double = 0.00, age: Int = 0, color: String = "blue"){
 
 #### init语句块
 
-Kotlin引入了一种叫作init语句块的语法，它属于上述构造方法的一部分，两者在表现形式上却是分离的。Bird类的构造方法在类的外部，它只能对参数进行赋值。如果我们需要在初始化时进行其他的额外操作，那么我们就可以使用init语句块来执行。比如:  
+Kotlin引入了一种叫作init语句块的语法，它属于上述构造方法的一部分，两者在表现形式上却是分离的。Bird类的构造方法在类的外部，它只能对参数进行赋值。
+如果我们需要在初始化时进行其他的额外操作，那么我们就可以使用init语句块来执行。比如:  
 
 ```kotlin
 class Bird(weight: Double, age: Int, color: String) {
@@ -643,11 +673,12 @@ class Bird(weight: Double, aget: Int, color: String) {
 
 可以发现，多个init语句块有利于进一步对初始化的操作进行职能分离，这在复杂的业务开发中显得特别有用。
 
-
-
 ## 数据类:使用`data class`定义
 
-数据类通常需要重写equals()、hashCode()、toString()这几个方法。其中，equals()方法用于判断两个数据类是否相等。hashCode()方法作为equals()的配套方法，也需要一起重写，否则会导致HashMap、HashSet等hash相关的系统类无法正常工作。toString()方法用于提供更清晰的输入日志，否则一个数据类默认打印出来的就是一行内存地址。所以我们在Java中创建一个数据类时要写很多代码，但是在Kotlin中你只需要一行代码。
+数据类通常需要重写equals()、hashCode()、toString()这几个方法。其中，equals()方法用于判断两个数据类是否相等。
+hashCode()方法作为equals()的配套方法，也需要一起重写，否则会导致HashMap、HashSet等hash相关的系统类无法正常工作。
+toString()方法用于提供更清晰的输入日志，否则一个数据类默认打印出来的就是一行内存地址。所以我们在Java中创建一个数据类时要写很多代码，
+但是在Kotlin中你只需要一行代码。
 
 数据类是一种非常强大的类:   
 
@@ -712,7 +743,8 @@ data class Artist(
     var mbid: String)
 ```
 
-数据类自动覆盖它们的equals方法以改变==操作符的行为，由此通过检查对象的每个属性值来判断是否相等。例如，假设你创建了两个属性值完全相同的Artist对象，使用==操作符对它们进行比较将返回true，因为它们存放了相同的数据：除了提供从Any父类继承的equals方法的新实现，数据类还覆盖了hashCode和toString方法。
+数据类自动覆盖它们的equals方法以改变==操作符的行为，由此通过检查对象的每个属性值来判断是否相等。例如，假设你创建了两个属性值完全相同的Artist对象，
+使用==操作符对它们进行比较将返回true，因为它们存放了相同的数据：除了提供从Any父类继承的equals方法的新实现，数据类还覆盖了hashCode和toString方法。
 
 通过数据类，会自动提供以下函数：
 
@@ -745,11 +777,11 @@ val charon2 = charon.copy(age = 19)
 - 数据类必须拥有一个构造方法，该方法至少包含一个参数，一个没有数据的数据类是没有任何用处的。
 - 与普通的类不同，数据类构造方法的参数强制使用var或者val进行声明
 - data class之前不能用abstract、open、sealed或者inner进行修饰
-- 在Kotlin 1.1版本前数据类只允许实现接口，之后的版本既可以实现接口也可以继承类，更多可看[Feedback Request: Limitations on Data Classes](https://blog.jetbrains.com/kotlin/2015/09/feedback-request-limitations-on-data-classes/)
-
+- 在Kotlin 1.1版本前数据类只允许实现接口，之后的版本既可以实现接口也可以继承类，
+    更多可看[Feedback Request: Limitations on Data Classes](https://blog.jetbrains.com/kotlin/2015/09/feedback-request-limitations-on-data-classes/)
 
-
-与任何其他类一样，你可以向数据类添加属性和方法，只需要将它们包含在类主体中。但是有一个大问题,就是在编译器生成数据类的方法实现时，比如覆盖equals方法和创建copy方法，它仅包含在主构造函数中定义的属性。因此如果你在数据类主体中定义添加的属性，则它们不会被包含到任何编译器生成的方法中。
+与任何其他类一样，你可以向数据类添加属性和方法，只需要将它们包含在类主体中。但是有一个大问题,就是在编译器生成数据类的方法实现时，
+比如覆盖equals方法和创建copy方法，它仅包含在主构造函数中定义的属性。因此如果你在数据类主体中定义添加的属性，则它们不会被包含到任何编译器生成的方法中。
 
 ### 数据类定义了componentN方法
 
@@ -761,11 +793,10 @@ val charon2 = charon.copy(age = 19)
 var personD = PersonData("PersonData", 20, "male")
 var (name, age) = personD
 
-
 Log.d("test", "name = $name, age = $age")
 
 //输出
-name = PersonData, age = 20
+// name = PersonData, age = 20
 ```
 
 上面的多声明，大概可以翻译成这样：
@@ -775,9 +806,13 @@ var name = f1.component1()
 var age = f1.component2()
 ```
 数据类的缺点，数据类虽然使用的时候很简单，但是因为它会默认帮我们自动生成很多代码，里面的有些代码其实在某些情况下我们并不需要，例如copy、component等，
-如果在项目中使用了大量的数据类，那就会引起包大小增加的问题。具体可见[Data classes in Kotlin: how do they impact application size](https://medium.com/bumble-tech/data-classes-in-kotlin-the-real-impact-of-using-it-6f1fdc909837)
+如果在项目中使用了大量的数据类，那就会引起包大小增加的问题。
+具体可见[Data classes in Kotlin: how do they impact application size](https://medium.com/bumble-tech/data-classes-in-kotlin-the-real-impact-of-using-it-6f1fdc909837)
 
-虽然对于release包，使用了R8，ProGuard，DexGuard等优化器。这些可以删除未使用的方法，这意味着它们可以优化数据类。像componentN()、copy()如果没有使用的话，会默认给删除。但是对于toString()、equals()、hashCode()方法则不会删除。对于有些不需要toString()、equals()、hashCode()方法的类如果使用数据类就会导致多生成这些代码，所以在使用数据类的时候不要去为了简单而乱用，也要去想想是否需要这些方法？是否需要设计成数据类。
+虽然对于release包，使用了R8，ProGuard，DexGuard等优化器。这些可以删除未使用的方法，这意味着它们可以优化数据类。
+像componentN()、copy()如果没有使用的话，会默认给删除。但是对于toString()、equals()、hashCode()方法则不会删除。
+对于有些不需要toString()、equals()、hashCode()方法的类如果使用数据类就会导致多生成这些代码，所以在使用数据类的时候不要去为了简单而乱用，
+也要去想想是否需要这些方法？是否需要设计成数据类。
 
 ## 继承
 
@@ -788,7 +823,8 @@ class Person // 从 Any 隐式继承
 ```
 
 `Any`不是`java.lang.Object`。它除了`equals()`、`hashCode()`和`toString()`外没有任何成员。
-`在Java中，类默认是可以被继承的，除非你主动加final修饰符。而在Kotlin中恰好相反，默认是不可被继承的，除非你主动加可以继承的修饰符，那便是open，如果不加open，那它在转化为Java代码时就是final的:   
+在Java中，类默认是可以被继承的，除非你主动加final修饰符。而在Kotlin中恰好相反，默认是不可被继承的，除非你主动加可以继承的修饰符，那便是open，
+如果不加open，那它在转化为Java代码时就是final的:   
 
 ```kotlin
 class Bird {
@@ -798,9 +834,7 @@ class Bird {
     fun fly() {}
 }
 ```
-
-将Bird类编译后转换为Java的代码:  
-
+将Bird类编译后转换为Java的代码:
 ```java
 public final class Bird {
     private final double weight = 500.0;
@@ -821,7 +855,7 @@ public final class Bird {
 }
 ```
 
-所以Kotlin`中所有的类默认都是不可继承的(`final`)，为什么要这样设计呢？引用`Effective Java`书中的第17条:要么为继承而设计，并提供文档说明，
+所以Kotlin中所有的类默认都是不可继承的(`final`)，为什么要这样设计呢？引用`Effective Java`书中的第17条:要么为继承而设计，并提供文档说明，
 要么就禁止继承。所以我们只能继承那些明确声明`open`或者`abstract`的类:要声明一个显式的超类型，我们把类型放到类头的冒号之后:   
 
 ```kotlin
@@ -830,12 +864,14 @@ open class Person(num: Int)
 class SuperPerson(num: Int) : Person(num)
 ```
 
-冒号后面的Person(num)会调用Person类的构造函数，以确保所有的初始化代码（例如给属性赋值）能够被执行。调用父类构造函数是强制性的：如果父类有主构造函数，你必须在子类头中调用它，否则代码将无法通过编译。请记住，即使你没有在父类中显式地添加构造函数，编译器也会在编译代码的时候自动创建一个空构造函数。假如我们不想为Person类添加构造函数，因此编译器在编译代码的时候创建了一个空构造函数。该构造函数通过使用Person()被调用。
-
+冒号后面的Person(num)会调用Person类的构造函数，以确保所有的初始化代码（例如给属性赋值）能够被执行。
+调用父类构造函数是强制性的：如果父类有主构造函数，你必须在子类头中调用它，否则代码将无法通过编译。
+请记住，即使你没有在父类中显式地添加构造函数，编译器也会在编译代码的时候自动创建一个空构造函数。
+假如我们不想为Person类添加构造函数，因此编译器在编译代码的时候创建了一个空构造函数。该构造函数通过使用Person()被调用。
 
-
-注意： 上面在说道继承的时候`class SuperPerson(num: Int) : Person(num)`在父类后面必须加上括号，这是为了能够调用到父类的主构造函数。Kotlin中规定，当一个类既有主构造函数又有次构造函数时，所有的次构造函数都必须调用主构造函数(包括间接调用)。
-但是如果类没有主构造函数，如果类没有主构造函数，那么每个次构造函数必须使用`super`关键字初始化其基类型，或委托给另一个构造函数做到这一点。 这里很特殊，在Kotlin
+注意： 上面在说到继承的时候`class SuperPerson(num: Int) : Person(num)`在父类后面必须加上括号，这是为了能够调用到父类的主构造函数。
+Kotlin中规定，当一个类既有主构造函数又有次构造函数时，所有的次构造函数都必须调用主构造函数(包括间接调用)。
+但是如果类没有主构造函数，那么每个次构造函数必须使用`super`关键字初始化其基类型，或委托给另一个构造函数做到这一点。 这里很特殊，在Kotlin
 中是允许类中只有次构造函数，没有主构造函数的。当一个类没有显式的定义主构造函数且定义了次构造函数时，它就是没有主构造函数的。
 
 如果该类有一个主构造函数，其基类必须用基类型的主构造函数参数就地初始化。
@@ -849,19 +885,19 @@ class MyView : View {
     constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
 }
 ```
-也就是MyView类的后面没有显式的定义主构造函数，同时又定义了次构造函数。所以现在MyView类是没有主构造函数的。那么既然没有主构造函数，继承View类的时候也就不需要再在View类后加上括号了。
-其实原因就是这么简单，只是很多人在刚开始学习Kotlin的时候没能理解这对括号的意义和规则，因此总感觉继承的写法有时候要加上括号，有时候又不要加，搞得晕头转向的，而在你真正理解了规则之后，就会发现其实还是很好懂的。
+也就是MyView类的后面没有显式的定义主构造函数，同时又定义了次构造函数。所以现在MyView类是没有主构造函数的。那么既然没有主构造函数，继承View类
+的时候也就不需要再在View类后加上括号了。其实原因就是这么简单，只是很多人在刚开始学习Kotlin的时候没能理解这对括号的意义和规则，因此总感觉继承的
+写法有时候要加上括号，有时候又不要加，搞得晕头转向的，而在你真正理解了规则之后，就会发现其实还是很好懂的。
 
 另外，由于没有主构造函数，次构造函数只能直接调用父类的构造函数，上述代码也是将this关键字换成了super关键字，这部分就很好理解了。
 
 
 ### Any
 
-我们都知道，Java并不能在真正意义上被称为一门“ 纯面向对象”语言，因为它的原始类型(如int)的值与函数等并不能被视作对象。
-
-但是Kotlin不同，在Kotlin的类型系统中，并不区分原始类型（基本数据类型）和包装类型，我们使用的始终是同一个类型。虽然从严格意义上，我们不能说Kotlin是一门纯面向对象的语言，但它显然比Java有更纯的设计。
-
+我们都知道，Java并不能在真正意义上被称为一门"纯面向对象"语言，因为它的原始类型(如int)的值与函数等并不能被视作对象。
 
+但是Kotlin不同，在Kotlin的类型系统中，并不区分原始类型（基本数据类型）和包装类型，我们使用的始终是同一个类型。虽然从严格意义上，我们不能说
+Kotlin是一门纯面向对象的语言，但它显然比Java有更纯的设计。
 
 #### Any：非空类型的跟类型
 
@@ -869,7 +905,8 @@ class MyView : View {
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/kotlin_any.png?raw=true)
 
-与Java不同的是，Kotlin不区分“原始类型”(primitive type)和其他的类型，他们都是同一类型层级结构的一部分。 如果定义了一个没有指定父类型的类型，则该类型将是Any的直接子类型。如:  
+与Java不同的是，Kotlin不区分"原始类型"(primitive type)和其他的类型，他们都是同一类型层级结构的一部分。 如果定义了一个没有指定父类型的类型，
+则该类型将是Any的直接子类型。如:  
 
 ```kotlin
 class Animal(val weight: Double)
@@ -879,13 +916,10 @@ class Animal(val weight: Double)
 
 如果说Any是所有非空类型的根类型，那么Any?才是所有类型（可空和非空类型）的根类型。这也就是说?Any?是?Any的父类型。 
 
-
-
 ## 覆盖
 
 ##### 方法覆盖
 
-
 只能重写显示标注可覆盖的方法:   
 
 ```kotlin
@@ -943,7 +977,7 @@ open class SuperPerson(num: Int) : Person(num) {
 
 ##### 属性覆盖
 
-属性覆盖与方法覆盖类似，只能覆盖显示标明`open`的属性，并且要用`override`开头:  
+属性覆盖与方法覆盖类似，只能覆盖显式标明`open`的属性，并且要用`override`开头:  
 
 ```kotlin
 open class Person(num: Int) {
@@ -969,13 +1003,12 @@ open class SuperPerson(num: Int) : Person(num) {
 }
 ```
 
-每个声明的属性可以由具有初始化器的属性或者具有`get`方法的属性覆盖，如果某个属性在父类中被定义为val，你可以在子类中使用var属性覆盖它。只需要覆盖该属性并将其声明为var即可。请注意，这只适用于这一种方式。如果尝试使用val覆盖var属性，编译器将会感到沮丧并拒绝编译你的代码。
-
-
+每个声明的属性可以由具有初始化器的属性或者具有`get`方法的属性覆盖，如果某个属性在父类中被定义为val，你可以在子类中使用var属性覆盖它。
+只需要覆盖该属性并将其声明为var即可。请注意，这只适用于这一种方式。如果尝试使用val覆盖var属性，编译器将会感到沮丧并拒绝编译你的代码。
 
 ## 抽象类
 
-类和其中的某些成员可以声明为`abstract`。抽象成员在本类中可以不用实现。 需要注意的是，我们并不需要用`open`标注一个抽象类或者函数——因为这不言而喻。
+类和其中的某些成员可以声明为`abstract`。抽象成员在本类中可以不用实现。需要注意的是，我们并不需要用`open`标注一个抽象类或者函数——因为这不言而喻。
 
 我们可以用一个抽象成员覆盖一个非抽象的开放成员:  
 
@@ -989,8 +1022,6 @@ abstract class Derived : Base() {
 }
 ```
 
-
-
 ## 注释
 
 和`Java`差不多
@@ -1002,13 +1033,11 @@ abstract class Derived : Base() {
    块注释。 */
 ```
 
-
-
-
-
 ## 接口:使用`interface`关键字
 
-接口可以让你在父类层次结构之外定义共同的行为，接口用于为共同行为定义协议，使你可以不依赖严格的继承结构却又可以利用多态。与抽象类类似，接口不能被实例化且可以定义抽象或具体的方法和属性，但两者有一个关键的不同点：类可以实现多个接口，但是只能继承于一个直接父类。所以接口不仅拥有抽象类的优点，而且使用起来更加灵活。
+接口可以让你在父类层次结构之外定义共同的行为，接口用于为共同行为定义协议，使你可以不依赖严格的继承结构却又可以利用多态。与抽象类类似，接口不能被
+实例化且可以定义抽象或具体的方法和属性，但两者有一个关键的不同点：类可以实现多个接口，但是只能继承于一个直接父类。所以接口不仅拥有抽象类的优点，
+而且使用起来更加灵活。
 
 ```kotlin
 interface FlyingAnimal {
@@ -1099,9 +1128,10 @@ Unit与Int一样，都是一种类型，然而它不代表任何信息，用面
 fun add(x: Int,y: Int) : Int = x + y // 省略了{}
 ```
 
-Kotlin支持这种单行表达式与等号的语法来定义函数，叫做表达式函数体，作为区分，普通的函数声明则可以叫做代码块函数体。如你所见，在使用表达式函数体的情况下我们可以不声明返回值类型，这进一步简化了语法。
+Kotlin支持这种单行表达式与等号的语法来定义函数，叫做表达式函数体，作为区分，普通的函数声明则可以叫做代码块函数体。如你所见，在使用表达式函数体
+的情况下我们可以不声明返回值类型，这进一步简化了语法。
 
-我们可以给参数指定一个默认值使得它们变得可选，这是非常有帮助的。这里有一个例子，在`Activity`中创建了一个函数用来`Toast`一段信息:    
+我们可以给参数指定一个默认值使的它们变的可选，这是非常有帮助的。这里有一个例子，在`Activity`中创建了一个函数用来`Toast`一段信息:    
 
 ```kotlin
 fun toast(message: String, length: Int = Toast.LENGTH_SHORT) {
@@ -1133,10 +1163,6 @@ fun main() {
 }
 ```
 
-
-
-
-
 ### 可变长参数函数:使用`vararg`关键字
 
 ```kotlin
@@ -1182,13 +1208,14 @@ val mList2 = vars(0, *myArray, 6, 7)
 - 方法声明
 - 伴生对象
 
-不要按字母顺序或者可见性对方法声明排序，也不要将常规方法与扩展方法分开。而是要把相关的东西放在一起，这样从上到下阅读类的人就能够跟进所发生事情的逻辑。选择一个顺序（高级别优先，或者相反）并坚持下去。
+不要按字母顺序或者可见性对方法声明排序，也不要将常规方法与扩展方法分开。而是要把相关的东西放在一起，这样从上到下阅读类的人就能够跟进所发生事情的
+逻辑。选择一个顺序（高级别优先，或者相反）并坚持下去。
 
 将嵌套类放在紧挨使用这些类的代码之后。如果打算在外部使用嵌套类，而且类中并没有引用这些类，那么把它们放到末尾，在伴生对象之后。
 
 ### 接口实现布局
 
-在实现一个接口时，实现成员的顺序应该与该接口的成员顺序相同（如果需要， 还要插入用于实现的额外的私有方法）
+在实现一个接口时，实现成员的顺序应该与该接口的成员顺序相同（如果需要，还要插入用于实现的额外的私有方法）
 
 ### 重载布局
 
@@ -1213,7 +1240,7 @@ interface Foo<out T : Any> : Bar {
 class Person(id: Int, name: String)
 ```
 
-具有较长类头的类应该格式化，以使每个主构造函数参数位于带有缩进的单独一行中。 此外，右括号应该另起一行。如果我们使用继承，
+具有较长类头的类应该格式化，以使每个主构造函数参数位于带有缩进的单独一行中。此外，右括号应该另起一行。如果我们使用继承，
 那么超类构造函数调用或者实现接口列表应位于与括号相同的行上：
 
 ```kotlin
@@ -1239,14 +1266,8 @@ class Person(
 }
 ```
 
-
-
-
-
-
 - [下一篇:2.Kotlin_高阶函数&Lambda&内联函数](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/2.Kotlin_%E9%AB%98%E9%98%B6%E5%87%BD%E6%95%B0%26Lambda%26%E5%86%85%E8%81%94%E5%87%BD%E6%95%B0.md)
 
-
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
diff --git a/VideoDevelopment/.DS_Store b/VideoDevelopment/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..5eb6b49d607f8326edeb9163d5c1a73b2c412c90
GIT binary patch
literal 6148
zcmeHK%}T>S5Z<-5O({YS3OxqA7K~N}@e*S70gUKDr6wfQV45vWY7V84v%Zi|;`2DO
zyEy~{-bCz7+5KkcXE*af_lGgY-DP;ln8_G3pdoTp8U)Rat}Pvm$mJXnn+8QT4-yeH
zO!OB``0X8b1-}`av-<ac1oI@$a@+poTdnqXr)zYLzVYZii^9wOe3`la;vPpgLL@<@
z`@wA-6%%v!LZrDLr_n+t#9;&>4|j1IiozAkG|XhKryNGl=uOPQYBjR$p*1?O*F$S{
zb_DwI=ybjA8GHK&=hu^$WR{9IMI;B#rR->|;2o4&O|RY}O+-2cdzDkg5)uQ%05L!e
zY#sypEHL_;S2|Tp3=ji9Fo64m1r5>BSSplT2XuISMt>U-1$2B%AX*w7jio~HfN+%x
zs8YFpVsMoXc1y=O8cT&LopHG`%%fMX9xq(34t7h1Gwvv)o){no>I}5h(8Tlq68<uc
zkNkQHjfeqa;GZ$T+hcF+LQ(o`{Z<~HwHCA|Xebz0q5=YX?GgY3+(!n|sr(k|5a(zt
V72+&tm+63X5s-vXM-2P|17AffOLG7K

literal 0
HcmV?d00001


From 4ac2e82b53680fb9c662c90adde22a246397bbc7 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Tue, 7 Mar 2023 21:57:29 +0800
Subject: [PATCH 094/213] format file style

---
 JavaKnowledge/.DS_Store                       | Bin 6148 -> 6148 bytes
 .../Base64\345\212\240\345\257\206.md"        |   6 +-
 .../Git\347\256\200\344\273\213.md"           | 104 ++--
 ...37\347\220\206\345\210\206\346\236\220.md" |  95 ++-
 ...12\346\234\211\345\272\217\346\200\247.md" |   5 +-
 "JavaKnowledge/hashCode\344\270\216equals.md" |  11 +-
 ...14Synchronized\345\214\272\345\210\253.md" |   8 +-
 ...50\346\200\201\344\273\243\347\220\206.md" |   9 +-
 ...01\350\231\232\345\274\225\347\224\250.md" |  13 +-
 .../\347\256\227\346\263\225.md"              |  29 +-
 ...13\346\261\240\347\256\200\344\273\213.md" |  11 +-
 ...76\350\256\241\346\250\241\345\274\217.md" | 549 ++++++++++--------
 12 files changed, 452 insertions(+), 388 deletions(-)

diff --git a/JavaKnowledge/.DS_Store b/JavaKnowledge/.DS_Store
index a157e1c898881dcc71838e834593d0a947bcfb97..1e695797205fc3a8c581396873b3ebfb6bf032c3 100644
GIT binary patch
delta 95
zcmZoMXffEJ$;7y0vKCXJyF_)hk)ffEf{~?Bt&T#qrICS-f{C$NZ7nB<sItCwP<(by
fZeD&D0~jzeLTCnFC=H{!H$P@lVcpEe@sA$>8Zi?2

delta 96
zcmZoMXffEJ$;7yGvKCXJhh%lNv89oYf}x3_VXclrwWX1Pj)IA?S#2#Rhp4i?bx?eE
gPHtX)Hv<?jGD2tuUMLNtdNw~|QeoZ9&heKY05Jd)F#rGn

diff --git "a/JavaKnowledge/Base64\345\212\240\345\257\206.md" "b/JavaKnowledge/Base64\345\212\240\345\257\206.md"
index 81a600f9..1dbe14c9 100644
--- "a/JavaKnowledge/Base64\345\212\240\345\257\206.md"
+++ "b/JavaKnowledge/Base64\345\212\240\345\257\206.md"
@@ -29,9 +29,7 @@ Base64加密
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/base64_man.png?raw=true)   
 
 
-正式因为这，所以
-想要转换成`Base64`最少要三个字节才可以，转换出来的`Base64`最少是4个字节，但是如果我要转换的字节不够3个怎么办？比如我想对字符`A`进行`Base64`
-加密。，`A`对应的第二个`Base64`的二进制位只有两个，把后边的四个补0就是了。
+正是因为这，所以想要转换成`Base64`最少要三个字节才可以，转换出来的`Base64`最少是4个字节，但是如果我要转换的字节不够3个怎么办？比如我想对字符`A`进行`Base64`加密。，`A`对应的第二个`Base64`的二进制位只有两个，把后边的四个补0就是了。
 所以`A`对应的`Base64`字符就是QQ。上边已经说过了，原则是`Base64`字符的最小单位是四个字符一组，那这才两个字符，后边补两个"="吧。
 其实不用"="也不耽误解码，之所以用"="，可能是考虑到多段编码后的Base64字符串拼起来也不会引起混淆。
 由此可见 Base64字符串只可能最后出现一个或两个"="，中间是不可能出现"="的。下图中字符"BC"的编码过程也是一样的。
@@ -50,4 +48,4 @@ Base64加密
 - 邮箱 ：charon.chui@gmail.com  
 - Good Luck! 
 
-	
\ No newline at end of file
+	
diff --git "a/JavaKnowledge/Git\347\256\200\344\273\213.md" "b/JavaKnowledge/Git\347\256\200\344\273\213.md"
index fbba61fb..2d427891 100644
--- "a/JavaKnowledge/Git\347\256\200\344\273\213.md"
+++ "b/JavaKnowledge/Git\347\256\200\344\273\213.md"
@@ -39,9 +39,9 @@ Git简介
 所以，创建一个版本库非常简单:
 
 - 创建一个空目录
-- 通过`git init`命令把这个目录变成`Git`可以管理的仓库：
-  瞬间`Git`就把仓库建好了，而且告诉你是一个空的仓库`（empty Git repository）`，细心的读者可以发现当前目录下多了一个`.git`的目录，
-  这个目录是`Git`来跟踪管理版本库的，没事千万不要手动修改这个目录里面的文件，不然改乱了，就把`Git`仓库给破坏了。
+- 通过`git init`命令把这个目录变成`Git`可以管理的仓库
+    瞬间`Git`就把仓库建好了，而且告诉你是一个空的仓库`（empty Git repository）`，细心的读者可以发现当前目录下多了一个`.git`的目录，
+    这个目录是`Git`来跟踪管理版本库的，没事千万不要手动修改这个目录里面的文件，不然改乱了，就把`Git`仓库给破坏了。
 - 使用命令`git add <file>`，注意，可反复多次使用，添加多个文件；
 - 使用命令`git commit`，完成。
 
@@ -123,12 +123,13 @@ HEAD是当前分支引用的指针，它总是指向该分支上的最后一次
 
 #### Git目录下文件的状态:
 
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_file_lifecycle.png?raw=true)你工作目录下的每一个文件都不外乎这两种状态:
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_file_lifecycle.png?raw=true)
+你工作目录下的每一个文件都不外乎这两种状态:
 
-- 已跟踪(Tracked)
+- 已跟踪(Tracked)    
   已跟踪的文件是指那些被纳入了版本控制的文件，在上一次快照中有他们的记录，在工作一段时间后，它们的状态可能是未修改，已修改或
   已放入暂存区。简而言之，已跟踪的文件就是Git已经知道的文件
-- 未跟踪(Untracked)
+- 未跟踪(Untracked)     
   工作目录中除已跟踪文件外的其它所有文件都属于未跟踪文件，它们即不存在与上次快照的记录中，也没有被放入暂存区。
 
 ## 常用命令
@@ -136,7 +137,10 @@ HEAD是当前分支引用的指针，它总是指向该分支上的最后一次
 ### git config
 
 安装好git后我们要先配置一下。以便`git`跟踪。
-```git config --global user.name "xxx"             git config --global user.email "xxx@xxx.com"```
+```
+    git config --global user.name "xxx"
+    git config --global user.email "xxx@xxx.com"
+```
 上面修改后可以使用`cat ~/.gitconfig`查看
 如果指向修改仓库中的用户名时可以不加`--global`，这样可以用`cat .git/config`来查看
 `git config --list`来查看所有的配置。
@@ -156,7 +160,7 @@ git init
 
 在某一目录下执行.
 `git clone [git path]`
-只是后`Git`会自动把当地仓库的`master`分支和远程仓库的`master`分支对应起来，远程仓库默认的名称是`origin`。
+执行后`Git`会自动把当地仓库的`master`分支和远程仓库的`master`分支对应起来，远程仓库默认的名称是`origin`。
 
 ### git add提交文件更改(修改和新增),把当前的修改添加到暂存区
 
@@ -181,21 +185,22 @@ git init
 就是对已经存在的`commit`进行 再次提交；
 简单用法:
 `git cherry-pick <commit id>`
+
 `git rebase`命令基本是是一个自动化的`cherry-pick`命令。它计算出一系列的提交，然后再以它们在其他地方以同样的顺序一个一个的`cherry-picks`出它们。
 
 ### `git status`查看当前仓库的状态和信息，会提示哪些内容做了改变已经当前所在的分支。
 
 ### `git diff`
 
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_diff.webp?raw=true)`git diff`直接查看当前修改未add(暂存staged)的差别
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_diff.webp?raw=true)
+`git diff`直接查看当前修改未add(暂存staged)的差别
 `git diff --staged`查看已add(到暂存区)的差别`git diff HEAD -- xx.txt`查看工作区与版本库最新版的差别。
 
 - 首先如果我们只是本地修改了一个文件，但是还没有执行`git add .`之前，该如何查看有那些修改。这种情况下直接执行`git diff`就可以了。
 - 那如果我们执行了`git add .`操作，然后你再执行`git diff`这时就会发现没有任何结果，这时因为`git diff`这个命令只是检查工作区和暂存区之间的差异。
-  如果我们要查看暂存区和本地仓库之间的差异就需要加一个参数使用`--staged`参数或者`--cached`，`git diff --cached`。这样再执行就可以看到暂存区和本地仓库之间的差异。
+    如果我们要查看暂存区和本地仓库之间的差异就需要加一个参数使用`--staged`参数或者`--cached`，`git diff --cached`。这样再执行就可以看到暂存区和本地仓库之间的差异。
 - 现在如果我们把修改使用`git commit`从暂存区提交到本地仓库，再看一下差异。这时候再执行`git diff --cached`就会发现没有任何差异。
-  如果我们行查看本地仓库和远程仓库的差异，就要换另一个参数，执行`git diff master origin/master`这样就可以看到差异了。 这里面`master`是本地的仓库，而`origin/master`是
-  远程仓库，因为默认都是在主分支上工作，所以两边都是`master`而`origin`代表远程。
+    如果我们行查看本地仓库和远程仓库的差异，就要换另一个参数，执行`git diff master origin/master`这样就可以看到差异了。 这里面`master`是本地的仓库，而`origin/master`是远程仓库，因为默认都是在主分支上工作，所以两边都是`master`而`origin`代表远程。
 
 ### `git push` 提交到远程仓库
 
@@ -205,8 +210,7 @@ git init
 ### `git log`查看当前分支下的提交记录
 
 用`git log`可以查看提交历史，以便确定要回退到哪个版本。
-如果已经使用`git log`查出版本`commit id`后`reset`到某一次提交后，又要重返回来，
-用`git reflog`查看命令历史，以便确定要回到未来的哪个版本。
+如果已经使用`git log`查出版本`commit id`后`reset`到某一次提交后，又要重返回来，用`git reflog`查看命令历史，以便确定要回到未来的哪个版本。
 
 ```
 git log -p -2 // -p 是仅显示最近的x次提交   
@@ -314,8 +318,7 @@ reset 要做的的第三件事情就是让工作目录看起来像索引。 如
 
 必须注意，--hard 标记是 reset 命令唯一的危险用法，它也是 Git 会真正地销毁数据的仅有的几个操作之一。 其他任何形式的 reset 调用都可以轻松撤消，但是 --hard 选项不能，因为它强制覆盖了工作目录中的文件。 在这种特殊情况下，我们的 Git 数据库中的一个提交内还留有该文件的 v3 版本， 我们可以通过 reflog 来找回它。但是若该文件还未提交，Git 仍会覆盖它从而导致无法恢复。
 
-回顾
-reset 命令会以特定的顺序重写这三棵树，在你指定以下选项时停止：
+回顾reset 命令会以特定的顺序重写这三棵树，在你指定以下选项时停止：
 
 - 移动 HEAD 分支的指向 （若指定了 --soft，则到此停止）
 - 使索引看起来像 HEAD （若未指定 --hard，则到此停止）
@@ -362,30 +365,28 @@ reset 命令会以特定的顺序重写这三棵树，在你指定以下选项
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/git_reset_checkout.png?raw=true)
 
 - 已经修改，但是并未执行`git add .`进行暂存
-  如果只是修改了本地文件，但是还没有执行`git add .`这时候我们的修改还是再工作区，并未进入暂存区，我们可以使用:`git checkouot .`或者`git reset --hard`来进行
-  撤销操作。
+    如果只是修改了本地文件，但是还没有执行`git add .`这时候我们的修改还是在工作区，并未进入暂存区，我们可以使用:`git checkouot .`或者`git reset --hard`来进行撤销操作。
 
-  `git add .`的反义词是`git checkout .`做完修改后，如果想要向前一步，让修改进入暂存区执行`git add .`如果想退后一步，撤销修改就执行`git checkout .`。
+    `git add .`的反义词是`git checkout .`做完修改后，如果想要向前一步，让修改进入暂存区执行`git add .`如果想退后一步，撤销修改就执行`git checkout .`。
 - 已暂存，未提交
-  如果已经执行了`git add .`但是还没有执行`git commit -m "comment"`这时候你意识到了错误，想要撤销，可以执行:
+    如果已经执行了`git add .`但是还没有执行`git commit -m "comment"`这时候你意识到了错误，想要撤销，可以执行:
 
   ```
   git reset   // git reset 只是把修改退回到了git add .之前的状态，也就是让文件还处于已修改未暂存的状态
   git checkout .   // 上面让文件处于已修改未暂存的状态，还要执行git checkout .来撤销工作区的状态
   ```
-  或`git reset --hard`
+    或`git reset --hard`
 
-  上面两个例子中都使用了`git reset --hard`这个命令也可以完成，这个命令可以一步到位的把你的修改完全恢复到本地仓库的未修改的状态。
+    上面两个例子中都使用了`git reset --hard`这个命令也可以完成，这个命令可以一步到位的把你的修改完全恢复到本地仓库的未修改的状态。
 - 已提交，未推送
-  如果执行了`git add .`又执行了`git commit -m "comment"`提交了代码，这时候代码已经进入到了本地仓库，然而你发现问题了，想要撤销，怎么办？
-  执行`git reset --hard origin/master`还是`git reset --hard`命令，只不过这次多了一个参数`origin/master`，这代表远程仓库，既然本地仓库已经有了
-  你提交的脏代码，那么就从远程仓库中把代码恢复把。
+    如果执行了`git add .`又执行了`git commit -m "comment"`提交了代码，这时候代码已经进入到了本地仓库，然而你发现问题了，想要撤销，怎么办？
+    执行`git reset --hard origin/master`还是`git reset --hard`命令，只不过这次多了一个参数`origin/master`，这代表远程仓库，既然本地仓库已经有了
+    你提交的脏代码，那么就从远程仓库中把代码恢复把。
 
-  但是上面这样会导致你之前修改的代码都没有了，如果我只是想撤回提交，还想要我之前修改的东西重新回到本地仓库呢？
-  `git reset --soft HEAD^`，这样就成功的撤销了你的commit。注意，仅仅是撤回commit操作，您写的代码仍然保留。
+    但是上面这样会导致你之前修改的代码都没有了，如果我只是想撤回提交，还想要我之前修改的东西重新回到本地仓库呢？
+    `git reset --soft HEAD^`，这样就成功的撤销了你的commit。注意，仅仅是撤回commit操作，您写的代码仍然保留。
 - 已推送到远程仓库
-  如果你执行`git add .`后又`commit`又执行了`git push`操作了，这时候你的代码已经进入到了远程仓库中，如果你发现你提交的代码又问题想恢复的话，那你只能先把本地仓库的
-  代码恢复，然后再强制执行`git push`仓做，`push`到远程仓库就可以了。
+    如果你执行`git add .`后又`commit`又执行了`git push`操作了，这时候你的代码已经进入到了远程仓库中，如果你发现你提交的代码又问题想恢复的话，那你只能先把本地仓库的代码恢复，然后再强制执行`git push`仓做，`push`到远程仓库就可以了。
 
   ```
   git reset --hard HEAD^  // HEAD^代表最新提交的前一次  
@@ -396,11 +397,10 @@ reset 命令会以特定的顺序重写这三棵树，在你指定以下选项
 
 你大概还想知道 checkout 和 reset 之间的区别。 和 reset 一样，checkout 也操纵三棵树，不过它有一点不同，这取决于你是否传给该命令一个文件路径。
 
-不带路径
-运行 git checkout [branch] 与运行 git reset --hard [branch] 非常相似，它会更新所有三棵树使其看起来像 [branch]，不过有两点重要的区别。
+不带路径运行 git checkout [branch] 与运行 git reset --hard [branch] 非常相似，它会更新所有三棵树使其看起来像 [branch]，不过有两点重要的区别。
 
 首先不同于 reset --hard，checkout 对工作目录是安全的，它会通过检查来确保不会将已更改的文件弄丢。 其实它还更聪明一些。它会在工作目录中先试着
-简单合并一下，这样所有 还未修改过的 文件都会被更新。 而 reset --hard 则会不做检查就全面地替换所有东西。
+简单合并一下，这样所有还未修改过的 文件都会被更新。而 reset --hard 则会不做检查就全面地替换所有东西。
 
 第二个重要的区别是 checkout 如何更新 HEAD。 reset 会移动 HEAD 分支的指向，而 checkout 只会移动 HEAD 自身来指向另一个分支。
 
@@ -408,8 +408,7 @@ reset 命令会以特定的顺序重写这三棵树，在你指定以下选项
 如果我们运行 git reset master，那么 develop 自身现在会和 master 指向同一个提交。 而如果我们运行 git checkout master 的话，
 develop 不会移动，HEAD 自身会移动。 现在 HEAD 将会指向 master。
 
-所以，虽然在这两种情况下我们都移动 HEAD 使其指向了提交 A，但做法是非常不同的。 reset 会移动 HEAD 分支的指向，而checkout则移动
-HEAD自身。
+所以，虽然在这两种情况下我们都移动 HEAD 使其指向了提交 A，但做法是非常不同的。 reset 会移动 HEAD 分支的指向，而checkout则移动HEAD自身。
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reset-checkout.png?raw=true)
 
 #### 带路径
@@ -425,8 +424,7 @@ HEAD自身。
 - `git revert`是生成一个新的提交来撤销某次提交，此次提交之前的`commit`都会被保留
 - `git reset`是回到某次提交，提交及之前的`commit`都会被保留，但是此次之后的修改都会被退回到暂存区
 
-相比`git reset`它不会改变现在得提交历史。`git reset`是直接删除制定的`commit`
-并把`HEAD`向后移动了一下。而`git revert`是一次新的特殊的`commit`，`HEAD`继续前进，本质和普通`add commit`一样，仅仅是`commit`内容很特殊。内容是与前面普通`commit`变化的反操作。
+相比`git reset`它不会改变现在得提交历史。`git reset`是直接删除指定的`commit`并把`HEAD`向后移动了一下。而`git revert`是一次新的特殊的`commit`，`HEAD`继续前进，本质和普通`add commit`一样，仅仅是`commit`内容很特殊。内容是与前面普通`commit`变化的反操作。
 比如前面普通`commit`是增加一行`a`，那么`revert`内容就是删除一行`a`。
 在 Git 开发中通常会控制主干分支的质量，但有时还是会把错误的代码合入到远程主干。虽然可以直接回滚远程分支，但有时新的代码也已经合入，
 直接回滚后最近的提交都要重新操作。 那么有没有只移除某些Commit的方式呢？可以用一次revert操作来完成。
@@ -469,8 +467,7 @@ git commit -a -m 'This reverts commit 7e345c9 and 551c408'
 ```
 现在的 HEAD（8fef80a）就是我们想要的版本，把它 Push 到远程即可。
 
-git revert 命令本质上就是一个逆向的 git cherry-pick 操作。 它将你提交中的变更的以完全相反的方式的应用到一个新创建的提交中，
-本质上就是撤销或者倒转。
+git revert 命令本质上就是一个逆向的 git cherry-pick 操作。 它将你提交中的变更的以完全相反的方式的应用到一个新创建的提交中，本质上就是撤销或者倒转。
 
 ### `git rm`删除文件
 
@@ -502,8 +499,7 @@ origin/master_sg
 origin/offline
 ```
 `git branch -d devBranch`删除`devBranch`分支。
-当时如果在新建了一个分支后进行修改但是还没有合并到其他分支的时候就去使用`git branch -d xxx`删除的时候系统会手提示说这个分支没有
-被合并，删除失败。
+当时如果在新建了一个分支后进行修改但是还没有合并到其他分支的时候就去使用`git branch -d xxx`删除的时候系统会手提示说这个分支没有被合并，删除失败。
 这时如果你要强行删除的话可以使用命令`git branch -D xxx`.
 如何删除远程分支呢？
 
@@ -546,13 +542,13 @@ git push origin frommaster// 推送到远程仓库所要使用的名字
 `git show tagName`来查看某`tag`的详细信息。
 
 - 打完`tag`后怎么推送到远程仓库
-  `git push origin tagName`
+    `git push origin tagName`
 - 删除`tag`
-  `git tag -d tagName`
+    `git tag -d tagName`
 - 删除完`tag`后怎么推送到远程仓库，这个写法有点复杂
-  `git push origin:refs/tags/tagName`
+    `git push origin:refs/tags/tagName`
 - 忽略文件
-  在`git`根目录下创建一个特殊的`.gitignore`文件，把想要忽略的文件名填进去就可以了,匹配模式最后跟斜杠(/)说明要忽略的是目录,#是注释 。
+    在`git`根目录下创建一个特殊的`.gitignore`文件，把想要忽略的文件名填进去就可以了,匹配模式最后跟斜杠(/)说明要忽略的是目录,#是注释 。
 
 ### amend修改最后一次提交
 
@@ -566,10 +562,7 @@ $ git commit --amend --no-edit
 
 #### 修改多个提交信息
 
-为了修改在提交历史中较远的提交，必须使用更复杂的工具。 Git 没有一个改变历史工具，但是可以使用变基工具来变基一系列提交，
-基于它们原来的 HEAD 而不是将其移动到另一个新的上面。 通过交互式变基工具，可以在任何想要修改的提交后停止，然后修改信息、添加文件或
-做任何想做的事情。 可以通过给 git rebase 增加 -i 选项来交互式地运行变基。 必须指定想要重写多久远的历史，这可以通过告诉命令将要变
-基到的提交来做到。
+为了修改在提交历史中较远的提交，必须使用更复杂的工具。 Git 没有一个改变历史工具，但是可以使用变基工具来变基一系列提交，基于它们原来的 HEAD 而不是将其移动到另一个新的上面。 通过交互式变基工具，可以在任何想要修改的提交后停止，然后修改信息、添加文件或做任何想做的事情。 可以通过给 git rebase 增加 -i 选项来交互式地运行变基。 必须指定想要重写多久远的历史，这可以通过告诉命令将要变基到的提交来做到。
 
 例如，如果想要修改最近三次提交信息，或者那组提交中的任意一个提交信息， 将想要修改的最近一次提交的父提交作为参数传递给 git rebase -i 命令，即 HEAD~2^ 或 HEAD~3。 记住 ~3 可能比较容易，因为你正尝试修改最后三次提交；但是注意实际上指定了以前的四次提交，即想要修改提交的父提交：
 
@@ -632,7 +625,7 @@ git log master..experiment
 ```
 #### 三点
 
-这个语法可以选择出被两个引用 之一 包含但又不被两者同时包含的提交。 再看看之前双点例子中的提交历史。 如果你想看 master 或者 experiment 中包含的但不是两者共有的提交，你可以执行：
+这个语法可以选择出被两个引用之一包含但又不被两者同时包含的提交。 再看看之前双点例子中的提交历史。 如果你想看 master 或者 experiment 中包含的但不是两者共有的提交，你可以执行：
 
 ```shell
 git log master...experiment
@@ -654,8 +647,7 @@ git log master...experiment
 git checkout experiment
 git rebase master
 ```
-它的原理是首先找到这两个分支(即当前分支experiment、变基操作的目标基底分支master)的最近共同祖先C2，然后对比当前分支相对于该祖
-先的历次提交，提取相应的修改并存为临时文件，然后将当前分支指向目标基底C3，最后以此将之前另存为临时文件的修改依序引用。
+它的原理是首先找到这两个分支(即当前分支experiment、变基操作的目标基底分支master)的最近共同祖先C2，然后对比当前分支相对于该祖先的历次提交，提取相应的修改并存为临时文件，然后将当前分支指向目标基底C3，最后以此将之前另存为临时文件的修改依序引用。
 ![将C4中的修改变基到C3上](https://raw.githubusercontent.com/CharonChui/Pictures/master/basic-rebase-3.png?raw=true)
 现在回到master分支，进行一次快进合并。
 
@@ -691,8 +683,7 @@ git checkout master
 git merge client
 ```
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/interesting-rebase-3.png?raw=true)
-接下来你决定将server分支中的修改也整合进来，使用git rebase <basebranch> <topicbranch>命令可以直接将主题分支
-(即这里的server)变基到基分支(即这里的master)上。这样做能省去你先切换到server分支，再对其进行变基命令的多个步骤。
+接下来你决定将server分支中的修改也整合进来，使用git rebase <basebranch> <topicbranch>命令可以直接将主题分支(即这里的server)变基到基分支(即这里的master)上。这样做能省去你先切换到server分支，再对其进行变基命令的多个步骤。
 `git rebase master server`
 如下图，将server中的修改变基到master上所示，server中的代码被“续”到了master后面。
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/interesting-rebase-4.png?raw=true)
@@ -728,7 +719,7 @@ git merge server
 
 ##### 用变基解决变基
 
-如果你 真的 遭遇了类似的处境，Git 还有一些高级魔法可以帮到你。 如果团队中的某人强制推送并覆盖了一些你所基于的提交，你需要做的就是检查你做了哪些修改，以及他们覆盖了哪些修改。
+如果你真的遭遇了类似的处境，Git 还有一些高级魔法可以帮到你。 如果团队中的某人强制推送并覆盖了一些你所基于的提交，你需要做的就是检查你做了哪些修改，以及他们覆盖了哪些修改。
 
 实际上，Git 除了对整个提交计算 SHA-1 校验和以外，也对本次提交所引入的修改计算了校验和——即 “patch-id”。
 
@@ -747,7 +738,7 @@ git merge server
 
 在本例中另一种简单的方法是使用 git pull --rebase 命令而不是直接 git pull。 又或者你可以自己手动完成这个过程，先 git fetch，再 git rebase teamone/master。
 
-如果你只对不会离开你电脑的提交执行变基，那就不会有事。 如果你对已经推送过的提交执行变基，但别人没有基于它的提交，那么也不会有事。 如果你对已经推送至共用仓库的提交上执行变基命令，并因此丢失了一些别人的开发所基于的提交， 那你就有大麻烦了，你的同事也会因此鄙视你。
+如果你只对不会离开你电脑的提交执行变基，那就不会有事。 如果你对已经推送过的提交执行变基，但别人没有基于它的提交，那么也不会有事。 如果你对已经推送至共用仓库的提交上执行变基命令，并因此丢失了一些别人的开发所基于的提交，那你就有大麻烦了，你的同事也会因此鄙视你。
 
 如果你或你的同事在某些情形下决意要这么做，请一定要通知每个人执行 git pull --rebase 命令，这样尽管不能避免伤痛，但能有所缓解。
 
@@ -766,8 +757,7 @@ git merge server
 现在，让我们回到之前的问题上来，到底合并还是变基好？希望你能明白，这并没有一个简单的答案。 Git 是一个非常强大的工具，它允许你对
 提交历史做许多事情，但每个团队、每个项目对此的需求并不相同。 既然你已经分别学习了两者的用法，相信你能够根据实际情况作出明智的选择。
 
-总的原则是，只对尚未推送或分享给别人的本地修改执行变基操作清理历史， 从不对已推送至别处的提交执行变基操作，这样，你才能享受到两
-种方式带来的便利。
+总的原则是，只对尚未推送或分享给别人的本地修改执行变基操作清理历史， 从不对已推送至别处的提交执行变基操作，这样，你才能享受到两种方式带来的便利。
 
 ### git fetch与git pull的区别
 
diff --git "a/JavaKnowledge/HashMap\345\256\236\347\216\260\345\216\237\347\220\206\345\210\206\346\236\220.md" "b/JavaKnowledge/HashMap\345\256\236\347\216\260\345\216\237\347\220\206\345\210\206\346\236\220.md"
index f610438e..a5192325 100644
--- "a/JavaKnowledge/HashMap\345\256\236\347\216\260\345\216\237\347\220\206\345\210\206\346\236\220.md"
+++ "b/JavaKnowledge/HashMap\345\256\236\347\216\260\345\216\237\347\220\206\345\210\206\346\236\220.md"
@@ -1,35 +1,66 @@
 HashMap实现原理分析
-===
-
-HashMap基于Map接口实现，元素以键值对的方式存储，并且允许使用null建和null值，因为key不允许重复，因此只能有一个键为null,另外HashMap不能保证放入元素的顺序，它是无序的，和放入的顺序并不能相同。
-
+=== 
+HashMap是Map接口的实现，元素以键值对的方式存储，并且允许使用null建和null值，因为key不允许重复，因此只能有一个键为null。 
+HashMap被认为是Hashtable的增强版，HashMap是一个非线程安全的容器，如果想构造线程安全的Map考虑使用ConcurrentHashMap。 
+HashMap是无序的，因为HashMap无法保证内部存储的键值对的有序性。
+
+### 重要属性
+
+- 初始容量
+    HashMap的默认初始容量是由DEFAULT_INITIAL_CAPACITY属性管理的。
+    `static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
+    HashMap的默认初始容量是 1 << 4 = 16， << 是一个左移操作，它相当于是:     
+    ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/hashmap_1.webp)
+
+- 最大容量
+    HashMap的最大容量是
+    `static final int MAXIMUM_CAPACITY = 1 << 30;`
+    这里是不是有个疑问？int 占用四个字节，按说最大容量应该是左移 31 位，为什么 HashMap 最大容量是左移 30 位呢？因为在数值计算中，最高位也就是最左位的位 是代表着符号为，0 -> 正数，1 -> 负数，容量不可能是负数，所以 HashMap 最高位只能移位到 2 ^ 30 次幂。
+- 默认负载因子
+    HashMap的默认负载因子是
+    `static final float DEFAULT_LOAD_FACTOR = 0.75f;`
+    float 类型所以用 .f 为单位，负载因子是和扩容机制有关，这里大致提一下，后面会细说。扩容机制的原则是当 HashMap 中存储的数量 > HashMap 容量 * 负载因子时，就会把 HashMap 的容量扩大为原来的二倍。
+    HashMap 的第一次扩容就在 DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR = 12 时进行。
+- 树化阈值
+    HashMap 的树化阈值是
+    `static final int TREEIFY_THRESHOLD = 8;`
+
+    在进行添加元素时，当一个桶中存储元素的数量 > 8 时，会自动转换为红黑树（JDK1.8 特性）。
+- 链表阈值
+    HashMap 的链表阈值是
+    `static final int UNTREEIFY_THRESHOLD = 6;` 在进行删除元素时，如果一个桶中存储元素数量 < 6 后，会自动转换为链表 - 扩容临界值 `static final int MIN_TREEIFY_CAPACITY = 64;`
+    这个值表示的是当桶数组容量小于该值时，优先进行扩容，而不是树化
 
 
 ## 原理
 
 其底层数据结构是数组称之为哈希桶，每个桶(bucket)里面放的是链表，链表中的每个节点，就是哈希表中的每个元素。
 
-通过hash的方法，通过put和get存储和获取对象。存储对象时，我们将K / V传给put方法时，它调用hashCode计算hash
-从而得到bucket位置，进一步存储，HashMap会根据当前bucket的占用情况自动调整容量 (超过Load Facotr则resize为原来的2倍)。
-获取对象时，我们将K传给get()方法，它调用hashCodeO()计算hash从而得到bucket位置，并进一步调用equals()方法确定键值对。
-如果发生碰撞的时候，HashMap通过链表将产生碰撞冲突的元素组织起来，在JDK8中，如果一个bucket中碰撞冲突的元素超过8个，
-则使用红黑树来替换链表，从而提高速度。
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/hashmap_hash.webp)
+哈希表中哈希函数的设计是相当重要的，这也是建哈希表过程中的关键问题之一。
+建立一个哈希表之前需要解决两个主要问题：
+
+- 构造一个合适的哈希函数,均匀性 H（key）的值均匀分布在哈希表中
+- 冲突的处理
+
+冲突：在哈希表中，不同的关键字值对应到同一个存储位置的现象。
+
+当一个值中要存储到HashMap中的时候会根据Key的值来计算出他的hash，通过hash值来确认存放到数组中的位置，如果发生hash冲突就以链表的形式存储，当链表过长的话，HashMap会把这个链表转换成红黑树来存储通过hash的方法，通过put和get存储和获取对象。存储对象时，我们将K / V传给put方法时，它调用hashCode计算hash从而得到bucket位置，进一步存储，HashMap会根据当前bucket的占用情况自动调整容量 (超过Load Factor则resize为原来的2倍)。
+获取对象时，我们将K传给get()方法，它调用hashCode()计算hash从而得到bucket位置，并进一步调用equals()方法确定键值对。
 
-因其底层哈希桶的数据结构是数组，所以也会涉及到扩容的问题。当HashMap的容量达到threshold域值时，就会触发扩容。
 扩容前后，哈希桶的长度一定会是2的次方。这样在根据key的hash值寻找对应的哈希桶时，可以用位运算替代取余操作，更加高效。
 而key的hash值，并不仅仅只是key对象的hashCode()方法的返回值，还会经过扰动函数的扰动，以使hash值更加均衡。
-因为hashCode()是int类型，取值范围是40多亿，只要哈希函数映射的比较均匀松散，碰撞几率是很小的。 但就算原本的hashCode()取的很好，
-每个key的hashCode()不同，但是由于HashMap的哈希桶的长度远比hash取值范围小，默认是16，所以当对hash值以桶的长度取余，
-以找到存放该key的桶的下标时，由于取余是通过与操作完成的，会忽略hash值的高位。因此只有hashCode()的低位参加运算，
+因为hashCode()是int类型，取值范围是40多亿，只要哈希函数映射的比较均匀松散，碰撞几率是很小的。 但就算原本的hashCode()取的很好，每个key的hashCode()不同，但是由于HashMap的哈希桶的长度远比hash取值范围小，默认是16，所以当对hash值以桶的长度取余，以找到存放该key的桶的下标时，由于取余是通过与操作完成的，会忽略hash值的高位。因此只有hashCode()的低位参加运算，
 发生不同的hash值，但是得到的index相同的情况的几率会大大增加，这种情况称之为hash碰撞。即碰撞率会增大。
-扰动函数就是为了解决hash碰撞的。它会综合hash值高位和低位的特征，并存放在低位，因此在与运算时，相当于高低位一起参与了运算，
-以减少hash碰撞的概率。（在JDK8之前，扰动函数会扰动四次，JDK8简化了这个操作）扩容操作时，会new一个新的Node数组作为哈希桶，
-然后将原哈希表中的所有数据(Node节点)移动到新的哈希桶中，相当于对原哈希表中所有的数据重新做了一个put操作。所以性能消耗很大，
-可想而知，在哈希表的容量越大时，性能消耗越明显。扩容时，如果发生过哈希碰撞，节点数小于8个。则要根据链表上每个节点的哈希值，
-依次放入新哈希桶对应下标位置。因为扩容是容量翻倍，所以原链表上的每个节点，现在可能存放在原来的下标，即low位， 或者扩容后的下标，
-即high位。 high位= low位+原哈希桶容量如果追加节点后，链表数量》=8，则转化为红黑树由迭代器的实现可以看出，遍历HashMap时，
+扰动函数就是为了解决hash碰撞的。它会综合hash值高位和低位的特征，并存放在低位，因此在与运算时，相当于高低位一起参与了运算，以减少hash碰撞的概率。（在JDK8之前，扰动函数会扰动四次，JDK8简化了这个操作）扩容操作时，会new一个新的Node数组作为哈希桶，然后将原哈希表中的所有数据(Node节点)移动到新的哈希桶中，相当于对原哈希表中所有的数据重新做了一个put操作。所以性能消耗很大，可想而知，在哈希表的容量越大时，性能消耗越明显。扩容时，如果发生过哈希碰撞，节点数小于8个。则要根据链表上每个节点的哈希值，依次放入新哈希桶对应下标位置。因为扩容是容量翻倍，所以原链表上的每个节点，现在可能存放在原来的下标，即low位， 或者扩容后的下标，即high位。 high位= low位+原哈希桶容量如果追加节点后，链表数量 >=8，且只有数组长度大于64才处理，则转化为红黑树由迭代器的实现可以看出，遍历HashMap时，
 顺序是按照哈希桶从低到高，链表从前往后，依次遍历的。
 
+数组的特点：查询效率高，插入删除效率低。
+链表的特点：查询效率低，插入删除效率高。
+
+在HashMap底层使用数组加（链表或红黑树）的结构完美的解决了数组和链表的问题，使得查询和插入，删除的效率都很高。
+
+
 ## JDK1.7
 
 HashMap在JDK1.8中发生了改变，下面的部分是基于JDK1.7的分析。HashMap主要是用数组来存储数据的，我们都知道它会对key进行哈希运算，
@@ -147,7 +178,7 @@ public V get(Object key) {
 ## JDK1.8
 
 在Jdk1.8中HashMap的实现方式做了一些改变，但是基本思想还是没有变的，只是在一些地方做了优化，下面来看一下这些改变的地方,
-数据结构的存储由数组+链表的方式，变化为数组+链表+红黑树的存储方式，当链表长度超过阈值（8）时，将链表转换为红黑树。
+数据结构的存储由数组+链表的方式，变化为数组+链表+红黑树的存储方式，当链表长度超过阈值（8）时,且只有数组长度大于64才处理，将链表转换为红黑树。
 利用红黑树快速增删改查的特点来提高HashMap的性能，其中会用到红黑树的插入、删除、查找等算法。HashMap中，
 如果key经过hash算法得出的数组索引位置全部不相同，即Hash算法非常好，那样的话，getKey方法的时间复杂度就是O(1)，
 如果Hash算法技术的结果碰撞非常多，假如Hash算法极其差，所有的Hash算法结果得出的索引位置一样，那样所有的键值对都集中到一个桶中，
@@ -505,6 +536,9 @@ resize()方法用于初始化数组或数组扩容，每次扩容后容量为原
 是0的话索引没变，是1的话索引变成 “原索引 + oldCap”。可以看看下图为16扩充为32的resize示意图：
 ![resize](https://raw.githubusercontent.com/CharonChui/Pictures/master/resize3.bmp)
 
+这里有一个需要注意的点就是在JDK1.8 HashMap扩容阶段重新映射元素时不需要像1.7版本那样重新去一个个计算元素的hash值，而是通过hash & oldCap的值来判断，若为0则索引位置不变，不为0则新索引=原索引+旧数组长度，为什么呢？具体原因如下：
+
+因为我们使用的是2次幂的扩展(指长度扩为原来2倍)，所以，元素的位置要么是在原位置，要么是在原位置再移动2次幂的位置。因此，我们在扩充HashMap的时候，不需要像JDK1.7的实现那样重新计算hash，只需要看看原来的hash值新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引变成“原索引+oldCap
 
 这个设计确实非常的巧妙，既省去了重新计算hash值的时间，而且同时，**由于新增的1bit是0还是1可以认为是随机的，因此resize的过程，
 均匀的把之前的冲突的节点分散到新的bucket了**。
@@ -690,7 +724,7 @@ final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
 * 扩容时，如果发生过哈希碰撞，节点数小于8个。则要根据链表上每个节点的哈希值，依次放入新哈希桶对应下标位置。
 * 因为扩容是容量翻倍，所以原链表上的每个节点，现在可能存放在原来的下标，即low位， 或者扩容后的下标，即high位。 high位= low位+原哈希桶容量
 * 利用哈希值 与运算 旧的容量 ，if ((e.hash & oldCap) == 0),可以得到哈希值去模后，是大于等于oldCap还是小于oldCap，等于0代表小于oldCap，应该存放在低位，否则存放在高位。这里又是一个利用位运算 代替常规运算的高效点
-* 如果追加节点后，链表数量》=8，则转化为红黑树
+* 如果追加节点后，链表数量 >= 8，则转化为红黑树
 * 插入节点操作时，有一些空实现的函数，用作LinkedHashMap重写使用。
 
 
@@ -726,18 +760,22 @@ final Node<K,V> getNode(int hash, Object key) {
 ```
 
 
-
-
-
 ## JDK 7与JDK 8中关于HashMap的对比
 
-1. JDK8为红黑树 + 链表 + 数组的形式，当桶内元素大于8时，便会树化。
+1. JDK8为红黑树 + 链表 + 数组的形式，当桶内元素大于8时,且只有数组长度大于64才处理，便会树化。
 2. hash值的计算方式不同 (jdk 8 简化)。
 3. JDK7中table在创建hashmap时分配空间，而8中在put的时候分配。
 4. 链表的插入方式从头插法改成了尾插法，简单说就是插入时，如果数组位置上已经有元素，1.7将新元素放到数组中，原始节点作为新节点的后继节点，1.8遍历链表，将元素放置到链表的最后；因为头插法会使链表发生反转，多线程环境下会产生环；
 5. 在resize操作中，7 需要重新进行index的计算，而8不需要，通过判断相应的位是0还是1，要么依旧是原index，要么是oldCap + 原 index。
 6. 在插入时，1.7先判断是否需要扩容，再插入，1.8先进行插入，插入完成再判断是否需要扩容；
 
+把链表转换成红黑树，树化需要满足以下两个条件：
+
+- 链表长度大于等于8
+- table数组长度大于等于64
+为什么table数组容量大于等于64才树化？
+
+因为当table数组容量比较小时，键值对节点 hash 的碰撞率可能会比较高，进而导致链表长度较长。这个时候应该优先扩容，而不是立马树化。
 
 
 ## 问题
@@ -782,6 +820,11 @@ final Node<K,V> getNode(int hash, Object key) {
         扩容后为32后的二进制就高位多了1，============>为0001 1111。因为是&运算，1和任何数&都是它本身，那就分二种情况，
         原数据hashcode高位第4位为0和高位为1的情况；第四位高位为0，重新hash数值不变，第四位为1，重新hash数值比原来大16（旧数组的容量）。
 
+6. HashMap和HashSet的区别： 
+
+HashSet继承于AbstractSet接口，实现了Set、Cloneable、java.io.Serializable接口。HashSet不允许集合中出现重复的值。HashSet底层其实
+就是HashMap，所有对HashSet的操作其实就是对HashMap的操作。所以HashSet也不保证集合的顺序。
+
 
 参考:  
 
@@ -794,5 +837,3 @@ final Node<K,V> getNode(int hash, Object key) {
 ---
 - 邮箱 ：charon.chui@gmail.com  
 - Good Luck! 
-
-    
diff --git "a/JavaKnowledge/Java\345\271\266\345\217\221\347\274\226\347\250\213\344\271\213\345\216\237\345\255\220\346\200\247\343\200\201\345\217\257\350\247\201\346\200\247\344\273\245\345\217\212\346\234\211\345\272\217\346\200\247.md" "b/JavaKnowledge/Java\345\271\266\345\217\221\347\274\226\347\250\213\344\271\213\345\216\237\345\255\220\346\200\247\343\200\201\345\217\257\350\247\201\346\200\247\344\273\245\345\217\212\346\234\211\345\272\217\346\200\247.md"
index 14d1a46c..f90b23af 100644
--- "a/JavaKnowledge/Java\345\271\266\345\217\221\347\274\226\347\250\213\344\271\213\345\216\237\345\255\220\346\200\247\343\200\201\345\217\257\350\247\201\346\200\247\344\273\245\345\217\212\346\234\211\345\272\217\346\200\247.md"
+++ "b/JavaKnowledge/Java\345\271\266\345\217\221\347\274\226\347\250\213\344\271\213\345\216\237\345\255\220\346\200\247\343\200\201\345\217\257\350\247\201\346\200\247\344\273\245\345\217\212\346\234\211\345\272\217\346\200\247.md"
@@ -1,13 +1,10 @@
 # Java并发编程之原子性、可见性以及有序性
 
-
-
 - 缓存导致的可见性问题
 - 线程切换带来的原子性问题
 - 编译优化带来的有序性问题
 
 
-
 ## 原子性(Atomicity）
 
 众所周知，原子是构成物质的基本单位，所以原子代表着不可分。
@@ -31,7 +28,7 @@
 可见性指的是当一个线程修改了共享变量后，其他线程能够立即得知这个修改。
 
 在多核处理器中，如果多个线程对一个变量进行操作，但是这多个线程有可能被分配到多个处理器中运行，那么编译器会对代码进行优化，
-当线程要处理该变量时，多个处理器会将变量从主内存复制一份分别存储在自己的片上存储器中，等到进行完操作后，再赋值回主存。
+当线程要处理该变量时，多个处理器会将变量从主内存复制一份分别存储在自己的存储器中，等到进行完操作后，再赋值回主存。
 (这样做的好处是提高了运行的速度，因为在处理过程中多个处理器减少了同主内存通信的次数)；
 同样在单核处理器中这样由于备份造成的问题同样存在！这样的优化带来的问题之一是变量可见性——如果线程`t1`与线程`t2`分别被安排在了不同
 的处理器上面，那么`t1`与`t2`对于变量`A`的修改时相互不可见，如果`t1`给`A`赋值，然后`t2`又赋新值，那么`t2`的操作就将`t1`的操作
diff --git "a/JavaKnowledge/hashCode\344\270\216equals.md" "b/JavaKnowledge/hashCode\344\270\216equals.md"
index 75bf9067..c73130a0 100644
--- "a/JavaKnowledge/hashCode\344\270\216equals.md"
+++ "b/JavaKnowledge/hashCode\344\270\216equals.md"
@@ -1,11 +1,12 @@
 hashCode与equals
 ===
 
-`HashSet`和`HashMap`一直都是`JDK`中最常用的两个类，`HashSet`要求不能存储相同的对象，`HashMap`要求不能存储相同的键。 那么`Java`运行时环境是如何判断`HashSet`
-中相同对象、`HashMap`中相同键的呢？当存储了相同的东西之后`Java`运行时环境又将如何来维护呢？             
-在研究这个问题之前，首先说明一下`JDK`对`equals(Object obj)`和`hashcode()`这两个方法的定义和规范:在`Java`中任何一个对象都具备`equals(Object obj)`
-和`hashcode()`这两个方法，因为他们是在`Object`类中定义的。`equals(Object obj)`方法用来判断两个对象是否“相同”，如果“相同”则返回`true`，否则返回`false`。 
-`hashcode()`方法返回一个`int`数，在`Object`类中的默认实现是“将该对象的内部地址转换成一个整数返回”。           
+`HashSet`和`HashMap`一直都是`JDK`中最常用的两个类，`HashSet`要求不能存储相同的对象，`HashMap`要求不能存储相同的键。 那么`Java`运行时
+环境是如何判断`HashSet`中相同对象、`HashMap`中相同键的呢？当存储了相同的东西之后`Java`运行时环境又将如何来维护呢？             
+在研究这个问题之前，首先说明一下`JDK`对`equals(Object obj)`和`hashcode()`这两个方法的定义和规范:
+在`Java`中任何一个对象都具备`equals(Object obj)`和`hashcode()`这两个方法，因为他们是在`Object`类中定义的:     
+- `equals(Object obj)`方法用来判断两个对象是否“相同”，如果“相同”则返回`true`，否则返回`false`。 
+- `hashcode()`方法返回一个`int`数，在`Object`类中的默认实现是“将该对象的内部地址转换成一个整数返回”。           
 
 接下来有两个个关于这两个方法的重要规范:    
 - 若重写`equals(Object obj)`方法，有必要重写`hashcode()`方法，确保通过`equals(Object obj)`方法判断结果为`true`的两个对象具备相等的`hashcode()`返回值。
diff --git "a/JavaKnowledge/volatile\345\222\214Synchronized\345\214\272\345\210\253.md" "b/JavaKnowledge/volatile\345\222\214Synchronized\345\214\272\345\210\253.md"
index c4ed28a2..82801018 100644
--- "a/JavaKnowledge/volatile\345\222\214Synchronized\345\214\272\345\210\253.md"
+++ "b/JavaKnowledge/volatile\345\222\214Synchronized\345\214\272\345\210\253.md"
@@ -26,7 +26,7 @@
 >
 > 多核CPU就像一家公司是由多个合伙人共同创办的，那么，就需要给每个合伙人都设立一套供自己直接领导的高层管理人员，多个合伙人共享使用的是公司的底层员工。
 >
-> 还有的公司，不断壮大，开始差分出各个子公司。各个子公司就是多个CPU了，互相使用没有共用的资源。互不影响。
+> 还有的公司，不断壮大，开始拆分出各个子公司。各个子公司就是多个CPU了，互相使用没有共用的资源。互不影响。
 
 随着计算机能力不断提升，开始支持多线程。那么问题就来了。我们分别来分析下单线程、多线程在单核CPU、多核CPU中的影响。
 
@@ -34,7 +34,7 @@
 
 **单核CPU，多线程**：进程中的多个线程会同时访问进程中的共享数据，CPU将某块内存加载到缓存后，不同线程在访问相同的物理地址的时候，都会映射到相同的缓存位置，这样即使发生线程的切换，缓存仍然不会失效。但由于任何时刻只能有一个线程在执行，因此不会出现缓存访问冲突。
 
-**多核CPU，多线程**：每个核都至少有一个L1缓存。多个线程访问进程中的某个共享内存，且这多个线程分别在不同的核心上执行，则每个核心都会在各自的caehe中保留一份共享内存的缓冲。由于多核是可以并行的，可能会出现多个线程同时写各自的缓存的情况，而各自的cache之间的数据就有可能不同。
+**多核CPU，多线程**：每个核都至少有一个L1缓存。多个线程访问进程中的某个共享内存，且这多个线程分别在不同的核心上执行，则每个核心都会在各自的cache中保留一份共享内存的缓存。由于多核是可以并行的，可能会出现多个线程同时写各自的缓存的情况，而各自的cache之间的数据就有可能不同。
 
 在CPU和主存之间增加缓存，在多线程场景下就可能存在**缓存一致性问题**，也就是说，在多核CPU中，每个核的自己的缓存中，关于同一个数据的缓存内容可能不一致。
 
@@ -170,14 +170,14 @@ public class DoubleCheckSingleton {
 ```java
 memory = allocate();   //1.分配对象的内存空间
 ctorInstance(memory);  //2.初始化对象
-instance = memory; 	   //3.设置instance指向刚分配的内存地址
+instance = memory;     //3.设置instance指向刚分配的内存地址
 ```
 
 上面3行伪代码中的2和3之间可能会发生重排序，排序后的执行顺序如下：
 
 ```java
 memory = allocate();   //1.分配对象的内存空间
-instance = memory; 	   //3.设置instance指向刚分配的内存地址，此时对象还没有初始化，但instance == null 判断为false
+instance = memory;     //3.设置instance指向刚分配的内存地址，此时对象还没有初始化，但instance == null 判断为false
 ctorInstance(memory);  //2.初始化对象
 ```
 
diff --git "a/JavaKnowledge/\345\212\250\346\200\201\344\273\243\347\220\206.md" "b/JavaKnowledge/\345\212\250\346\200\201\344\273\243\347\220\206.md"
index e8c1277f..a010cb92 100644
--- "a/JavaKnowledge/\345\212\250\346\200\201\344\273\243\347\220\206.md"
+++ "b/JavaKnowledge/\345\212\250\346\200\201\344\273\243\347\220\206.md"
@@ -3,16 +3,11 @@
 
 有关代理模式已经动态代理和静态代理的区别请查看另一篇文章[设计模式](https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F.md)             
 
-刚毕业的时候在学习`android`时看到过[张孝祥老师的Java高新技术](http://yun.itheima.com/course/5.html)，里面
-讲到了动态代理，当时看完后感觉懂了.但是现在全部都忘了。       
-因为动态代理我们平时用的其实并不多，但是作为`Android`开发，你肯定知道`Retrofit`，而`Retrofit`就是基于动态代理实现。   
-
-
+动态代理我们平时用的其实并不多，但是作为`Android`开发，你肯定知道`Retrofit`，而`Retrofit`就是基于动态代理实现。   
 
 动态代理的类和接口
 ---
 
-
 - `Proxy`:动态代理机制的主类，提供一组静态方法为一组接口动态的生成对象和代理类。
 
 ```java
@@ -32,7 +27,7 @@ public static Object newProxyInstance(ClassLoader loader,
 ```
 
 
-- `InvocationHandler`:调用处理器接口，自定义invokle方法，用于实现对于真正委托类的代理访问。
+- `InvocationHandler`:调用处理器接口，自定义invoke方法，用于实现对于真正委托类的代理访问。
 
 ```java
 /**
diff --git "a/JavaKnowledge/\345\274\272\345\274\225\347\224\250\343\200\201\350\275\257\345\274\225\347\224\250\343\200\201\345\274\261\345\274\225\347\224\250\343\200\201\350\231\232\345\274\225\347\224\250.md" "b/JavaKnowledge/\345\274\272\345\274\225\347\224\250\343\200\201\350\275\257\345\274\225\347\224\250\343\200\201\345\274\261\345\274\225\347\224\250\343\200\201\350\231\232\345\274\225\347\224\250.md"
index 769efa0b..48d014de 100644
--- "a/JavaKnowledge/\345\274\272\345\274\225\347\224\250\343\200\201\350\275\257\345\274\225\347\224\250\343\200\201\345\274\261\345\274\225\347\224\250\343\200\201\350\231\232\345\274\225\347\224\250.md"
+++ "b/JavaKnowledge/\345\274\272\345\274\225\347\224\250\343\200\201\350\275\257\345\274\225\347\224\250\343\200\201\345\274\261\345\274\225\347\224\250\343\200\201\350\231\232\345\274\225\347\224\250.md"
@@ -17,21 +17,19 @@
 
 - 强引用(Strong Reference)
   
-	你懂的，不要胡乱持有着不放，不然内存泄露、oom有你好看，就像是老板（OOM）的亲儿子一样，在公司可以什么事都不干，但是千万不要老是占用公司的资源为他自己做事，记得用完公司的妹子之后,要让她们去工作(资源要懂得释放) 不然公司很可能会垮掉的。   
+    你懂的，不要胡乱持有着不放，不然内存泄露、oom有你好看，就像是老板（OOM）的亲儿子一样，在公司可以什么事都不干，但是千万不要老是占用公司的资源为他自己做事，记得用完公司的妹子之后,要让她们去工作(资源要懂得释放) 不然公司很可能会垮掉的。   
 
     平时我们编程的时候例如：`Object object=new Object()`；那`object`就是一个强引用了。如果一个对象具有强引用，那就类似于必不可少的生活用品，垃圾回收器绝不会回收它。当JVM的内存空间不足时，宁愿抛出OutOfMemoryError使得程序异常终止也不愿意回收具有强引用的存活着的对象！记住是存活着，不可能是你new一个对象就永远不会被GC回收。
   
 - 软引用(SoftReference)
   
     描述一些还有用，但并非必需的对象。如果一个对象只具有软引用，那就类似于可有可物的生活用品。如果内存空间足够，垃圾回收器就不会回收它，如果内存空间不足了，就会回收这些对象的内存，但是system.gc对其无效，有点像老板(OOM)的亲戚，在公司表现不好有可能会被开除，即使你投诉他（调用GC)上班看片，但是只要不被老板看到（被JVM检测到）就不会被开除（被虚拟机回收）。**软引用可用来实现内存敏感的高速缓存**。 软引用可以和一个引用队列`(ReferenceQueue)`联合使用，如果软引用所引用的对象被垃圾回收，`Java`虚拟机就会把这个软引用加入到与之关联的引用队列中。
-        
-    
 
 - 弱引用(WeakReference)
   
     同软引用，也用来描述非必须对象，但是它的强度比软引用更弱一些，被弱引用关联的对象只能生存到下一次垃圾收集发生之前。所以弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的声明周期。在对象没有其他引用的情况下，调用system.gc对象可被虚拟机回收，就是一个普通的员工，平常如果表现不佳会被开除（对象没有其他引用的情况下），遇到别人投诉（调用GC)上班看片,那开除是肯定了(被虚拟机回收)。
     
-	在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了***只具***有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。弱引用最常见的用途是实现规范映射(canonicalizing mappings，比如哈希表）。
+    在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了***只具***有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。弱引用最常见的用途是实现规范映射(canonicalizing mappings，比如哈希表）。
 
     常见的一个例子就是WeakHashMap，在HashMap中，键被置为null，唤醒gc后，不会垃圾回收键为null的键值对。但是在WeakHashMap中，键被置为null，唤醒gc后，键为null的键值对会被回收。
     
@@ -65,16 +63,9 @@
     一个对象是否有虚引用的存在完全不会对其生存时间构成影响，也无法通过虚引用来取得一个对象实例。为一个对象设置虚引用关联的唯一的用处：能在对象被GC时收到系统通知，主要用于跟踪对象何时被回收，比如防止资源泄漏等。 
     
     虚引用必须和引用队列 (ReferenceQueue)联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动。 虚引用是每次垃圾回收的时候都会被回收，通过虚引用的get方法永远获取到的数据为null。
-    
-    
 
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/reference_compare.jpg)
 
-
-
-
-
-
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
diff --git "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\347\256\227\346\263\225.md" "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\347\256\227\346\263\225.md"
index b57a2d11..c6ce6686 100644
--- "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\347\256\227\346\263\225.md"
+++ "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\347\256\227\346\263\225.md"
@@ -147,7 +147,7 @@ for(i = 0; i < n; i ++) {
 
 ### 算法空间复杂度
 
-我们在写代码时，完全可以用空间来换取时间，比如说，要判断某某年是不是闰年，你可能会花一点心思写了一个算法，而且由于是一个算法，也就意味着，每次给一个年份，都是要通过计算得到是否是闰年的结果。还有另一个办法就是，事先建立一个有2 050个元素的数组（年数略比现实多一点），然后把所有的年份按下标的数字对应，如果是闰年，此数组项的值就是1，如果不是值为0。这样，所谓的判断某一年是否是闰年，就变成了查找这个数组的某一项的值是多少的问题。此时，我们的运算是最小化了，但是硬盘上或者内存中需要存储这2050个0和1。这是通过一笔空间上的开销来换取计算时间的小技巧。到底哪一个好，其实要看你用在什么地方。
+我们在写代码时，完全可以用空间来换取时间，比如说，要判断某某年是不是闰年，你可能会花一点心思写了一个算法，而且由于是一个算法，也就意味着，每次给一个年份，都是要通过计算得到是否是闰年的结果。还有另一个办法就是，事先建立一个有2050个元素的数组（年数略比现实多一点），然后把所有的年份按下标的数字对应，如果是闰年，此数组项的值就是1，如果不是值为0。这样，所谓的判断某一年是否是闰年，就变成了查找这个数组的某一项的值是多少的问题。此时，我们的运算是最小化了，但是硬盘上或者内存中需要存储这2050个0和1。这是通过一笔空间上的开销来换取计算时间的小技巧。到底哪一个好，其实要看你用在什么地方。
 
 算法的空间复杂度通过计算算法所需的存储空间实现，算法空间复杂度的计算公式记作：S(n)=O(f(n))，其中，n为问题的规模，f(n)为语句关于n所占存储空间的函数。
 
@@ -156,7 +156,7 @@ for(i = 0; i < n; i ++) {
 
 算法的空间复杂度并不是计算实际占用的空间，而是计算整个算法的辅助空间单元的个数，与问题的规模没有关系。算法的空间复杂度`S(n)`定义为该算法所耗费空间的数量级。     
 `S(n)=O(f(n))`若算法执行时所需要的辅助空间相对于输入数据量`n`而言是一个常数，则称这个算法的辅助空间为`O(1)`;      
-递归算法的空间复杂度:递归深度`N*`每次递归所要的辅助空间， 如果每次递归所需的辅助空间是常数，则递归的空间复杂度是`O(N)`.     
+递归算法的空间复杂度:递归深度`N*`每次递归所要的辅助空间,如果每次递归所需的辅助空间是常数，则递归的空间复杂度是`O(N)`.     
 
 空间复杂度的分析方法:      
 
@@ -197,11 +197,6 @@ for(i = 0; i < n; i ++) {
 
 顺序查找（Sequential Search）又叫线性查找，是最基本的查找技术，它的查找过程是：从表中第一个（或最后一个）记录开始，逐个进行记录的关键字和给定值比较，若某个记录的关键字和给定值相等，则查找成功，找到所查的记录；如果直到最后一个（或第一个）记录，其关键字和给定值比较都不等时，则表中没有所查的记录，查找不成功。
 
-
-
-
-
-
 算法（Algorithm）是一系列解决问题的清晰指令，也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。如果一个算法有缺陷，或不适合于某个问题，
 执行这个算法将不会解决这个问题。不同的算法可能用不同的时间、空间或效率来完成同样的任务。一个算法的优劣可以用空间复杂度与时间复杂度来衡量。         
 算法可以理解为有基本运算及规定的运算顺序所构成的完整的解题步骤。或者看成按照要求设计好的有限的确切的计算序列，并且这样的步骤和序列可以解决一类问题。
@@ -293,26 +288,6 @@ public static int[] merge(int[] a, int[] b) {
 ````
 
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-		
 ---
 - 邮箱 ：charon.chui@gmail.com  
 - Good Luck! 
diff --git "a/JavaKnowledge/\347\272\277\347\250\213\346\261\240\347\256\200\344\273\213.md" "b/JavaKnowledge/\347\272\277\347\250\213\346\261\240\347\256\200\344\273\213.md"
index 27fff875..a638c653 100644
--- "a/JavaKnowledge/\347\272\277\347\250\213\346\261\240\347\256\200\344\273\213.md"
+++ "b/JavaKnowledge/\347\272\277\347\250\213\346\261\240\347\256\200\344\273\213.md"
@@ -22,7 +22,7 @@
 - 使用线程池的好处:        
     - 降低资源消耗。通过重复利用减少在创建和销毁线程上所花的时间以及系统资源的开销 
     - 提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，
-         还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。如不使用线程池，有可能造成系统创建大量线程而导致消耗完系统内存以及”过度切换”。 
+    还会降低系统的稳定性，使用线程池可以进行统一分配、调优和监控。如不使用线程池，有可能造成系统创建大量线程而导致消耗完系统内存以及”过度切换”。 
     - 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
     
 - 工作流程            
@@ -135,7 +135,7 @@ public class ThreadPoolExecutor extends AbstractExecutorService {
 - `Executors.newFixedThreadPool(int);`    //创建固定容量大小的缓冲池，固定数量的线程池，没提交一个任务就是一个线程，直到达到线程池的最大数量，然后后面进入等待队列直到前面的任务完成才继续执行
 - `Executors.newScheduleThreadExecutor();`// 大小无限制的线程池，能按时间计划来执行任务，允许用户设定计划执行任务的时间。在实际的业务场景中可以使用该线程池定期的同步数据。
 
-这几个个方法的具体实现:       
+这几个方法的具体实现:       
 
 ```java
 public static ExecutorService newFixedThreadPool(int nThreads) {
@@ -161,8 +161,6 @@ public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
 
 ```
 
-
-
 从它们的具体实现来看，它们实际上也是调用了`ThreadPoolExecutor`，只不过参数都已配置好了:      
 
 - `newFixedThreadPool`创建的线程池`corePoolSize`和`maximumPoolSize`值是相等的，它使用的`LinkedBlockingQueue`；
@@ -172,12 +170,9 @@ public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
 
 实际中，如果`Executors`提供的三个静态方法能满足要求，就尽量使用它提供的三个方法，因为自己去手动配置`ThreadPoolExecutor`的参数有点麻烦，要根据实际任务的类型和数量来进行配置。
 
-
-
 ## 线程池执行状态
 
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/thread_poll_process.png)
-
 整个过程可以拆分成以下几个部分：
 
 - 提交任务
@@ -251,8 +246,6 @@ public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
 
 两个方法都可以向线程池提交任务，`execute()`方法的返回类型是`void`，它定义在`Executor`接口中, 而`submit()`方法可以返回持有计算结果的`Future`对象，它定义在`ExecutorService`接口中，它扩展了`Executor`接口，其它线程池类像`ThreadPoolExecutor`和`ScheduledThreadPoolExecutor`都有这些方法。 
 
-
-
 线程池的关闭
 ---
 
diff --git "a/JavaKnowledge/\350\256\276\350\256\241\346\250\241\345\274\217.md" "b/JavaKnowledge/\350\256\276\350\256\241\346\250\241\345\274\217.md"
index a499894c..c0551d48 100644
--- "a/JavaKnowledge/\350\256\276\350\256\241\346\250\241\345\274\217.md"
+++ "b/JavaKnowledge/\350\256\276\350\256\241\346\250\241\345\274\217.md"
@@ -1,9 +1,11 @@
 设计模式(Design Patterns)
 ===
 
-设计模式`(Design pattern)`是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 
+设计模式`(Design pattern)`是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他
+人理解、保证代码可靠性。 
 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。
-项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。
+项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及
+该问题的核心解决方案，这也是它能被广泛应用的原因。
 
 
 设计模式的分类
@@ -22,41 +24,64 @@
 - 开闭原则`(Open Close Principle)`             
     开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是:
     为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。
-    当系统升级时，如果为了增强系统功能而需要进行大量的代码修改，则说明这个系统的设计是失败的，是违反开闭原则的。反之，对系统的扩展应该只需添加新的软件模块，系统模式一旦确立就不再修改现有代码，这才是符合开闭原则的优雅设计。其实开闭原则在各种设计模式中都有体现，对抽象的大量运用奠定了系统可复用性、可扩展性的基础，也增加了系统的稳定性。
+    当系统升级时，如果为了增强系统功能而需要进行大量的代码修改，则说明这个系统的设计是失败的，是违反开闭原则的。反之，对系统的扩展应该只需添加
+    新的软件模块，系统模式一旦确立就不再修改现有代码，这才是符合开闭原则的优雅设计。其实开闭原则在各种设计模式中都有体现，对抽象的大量运用奠定
+    了系统可复用性、可扩展性的基础，也增加了系统的稳定性。
 
 - 里氏代换原则`（Liskov Substitution Principle）`        
-    里氏代换原则面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 `LSP`是继承复用的基石，只有当衍生类可以替换掉基类，
-    软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。
-    里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。
+    里氏代换原则面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 `LSP`是继承复用的基石，只有当衍生类
+    可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。
+    里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实
+    现抽象化的具体步骤的规范。
 
 - 依赖倒转原则`（Dependence Inversion Principle）`      
-    我们知道，面向对象中的依赖是类与类之间的一种关系，如H（高层）类要调用L（底层）类的方法，我们就说H类依赖L类。依赖倒置原则(Dependency InversionPrinciple)指高层模块不依赖底层模块，也就是说高层模块只依赖上层抽象，而不直接依赖具体的底层实现，从而达到降低耦合的目的。如上面提到的H与L的依赖关系必然会导致它们的强耦合，也许L任何细枝末节的变动都可能影响H，这是一种非常死板的设计。而依赖倒置的做法则是反其道而行，我们可以创建L的上层抽象A，然后H即可通过抽象A间接地访问L，那么高层H不再依赖底层L，而只依赖上层抽象A。这样一来系统会变得更加松散，这也印证了我们在“里氏替换原则”中所提到的“面向接口编程”，以达到替换底层实现的目的。
-    举个例子，公司总经理制订了下一年度的目标与计划，为了提高办公效率，总经理决定年底要上线一套全新的办公自动化软件。那么总经理作为发起方该如何实施这个计划呢？直接发动基层程序员并调用他们的研发方法吗？我想世界上没有以这种方式管理公司的领导吧。公司高层一定会发动IT部门的上层抽象去执行，调用IT部门经理的work方法并传入目标即可，至于这个work方法的具体实现者也许是架构师甲，也可能是程序员乙，总经理也许根本不认识他们，这就达到了公司高层与底层员工实现解耦的目的。这就是将“高层依赖底层”倒置为“底层依赖高层”的好处。
+    我们知道，面向对象中的依赖是类与类之间的一种关系，如H（高层）类要调用L（底层）类的方法，我们就说H类依赖L类。
+    依赖倒置原则指高层模块不依赖底层模块，也就是说高层模块只依赖上层抽象，而不直接依赖具体的底层实现，从而达到降低耦合的目的。如上面提到的H与L
+    的依赖关系必然会导致它们的强耦合，也许L任何细枝末节的变动都可能影响H，这是一种非常死板的设计。而依赖倒置的做法则是反其道而行，我们可以创建
+    L的上层抽象A，然后H即可通过抽象A间接地访问L，那么高层H不再依赖底层L，而只依赖上层抽象A。这样一来系统会变得更加松散，这也印证了我们在
+    “里氏替换原则”中所提到的“面向接口编程”，以达到替换底层实现的目的。
+    举个例子，公司总经理制订了下一年度的目标与计划，为了提高办公效率，总经理决定年底要上线一套全新的办公自动化软件。那么总经理作为发起方该如何
+    实施这个计划呢？直接发动基层程序员并调用他们的研发方法吗？我想世界上没有以这种方式管理公司的领导吧。公司高层一定会发动IT部门的上层抽象去
+    执行，调用IT部门经理的work方法并传入目标即可，至于这个work方法的具体实现者也许是架构师甲，也可能是程序员乙，总经理也许根本不认识他们，
+    这就达到了公司高层与底层员工实现解耦的目的。这就是将“高层依赖底层”倒置为“底层依赖高层”的好处。
 
 - 接口隔离原则`（Interface Segregation Principle）`      
-    接口隔离原则(Interface Segregation Principle)指的是对高层接口的独立、分化，客户端对类的依赖基于最小接口，而不依赖不需要的接口。简单来说，就是切勿将接口定义成全能型的，否则实现类就必须神通广大，这样便丧失了子类实现的灵活性，降低了系统的向下兼容性。反之，定义接口的时候应该尽量拆分成较小的粒度，往往一个接口只对应一个职能。
-
-    这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，
-    从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。
+    接口隔离原则指的是对高层接口的独立、分化，客户端对类的依赖基于最小接口，而不依赖不需要的接口。简单来说，就是切勿将接口定义成全能型的，否则
+    实现类就必须神通广大，这样便丧失了子类实现的灵活性，降低了系统的向下兼容性。反之，定义接口的时候应该尽量拆分成较小的粒度，往往一个接口只对
+    应一个职能。
 
+    这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计
+    思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。
 
 - 迪米特法则（最少知识原则）`（Demeter Principle）`        
-    迪米特法则(law of Demeter)也被称为最少知识原则，它提出一个模块对其他模块应该知之甚少，或者说模块之间应该彼此保持陌生，甚至意识不到对方的存在，以此最小化、简单化模块间的通信，并达到松耦合的目的。反之，模块之间若存在过多的关联，那么一个很小的变动则可能会引发蝴蝶效应般的连锁反应，最终会波及大范围的系统变动。我们说，缺乏良好封装性的系统模块是违反迪米特法则的，牵一发动全身的设计使系统的扩展与维护变得举步维艰。举个例子，我们买了一台游戏机，主机内部集成了非常复杂的电路及电子元件，这些对外部来说完全是不可见的，就像一个黑盒子。虽然我们看不到黑盒子的内部构造与工作原理，但它向外部开放了控制接口，让我们可以接上手柄对其进行访问，这便构成了一个完美的封装。
-    之前我们学过的“门面模式”就是极好的范例。例如我们去某单位办理一项业务，来到业务大厅一脸茫然，各种填表、盖章等复杂的办理流程让人一头雾水，有可能来回折腾几个小时。假若有一个提供快速通道服务的“门面”办理窗口，那么我们只需简单地把材料递交过去就可以了，“办理人“与“门面”保持最简单的通信，对于门面里面发生的事情，办理人则知之甚少，更没有必要去亲力亲为。要设计出符合迪米特法则的软件，切勿跨越红线，干涉他人内务。系统模块一定要最大程度地隐藏内部逻辑，大门一定要紧锁，防止陌生人随意访问，而对外只适可而止地暴露最简单的接口，让模块间的通信趋向“简单化”“傻瓜化”。
+    迪米特法则也被称为最少知识原则，它提出一个模块对其他模块应该知之甚少，或者说模块之间应该彼此保持陌生，甚至意识不到对方的存在，以此最小化、
+    简单化模块间的通信，并达到松耦合的目的。反之，模块之间若存在过多的关联，那么一个很小的变动则可能会引发蝴蝶效应般的连锁反应，最终会波及大范
+    围的系统变动。我们说，缺乏良好封装性的系统模块是违反迪米特法则的，牵一发动全身的设计使系统的扩展与维护变的举步维艰。举个例子，我们买了一台
+    游戏机，主机内部集成了非常复杂的电路及电子元件，这些对外部来说完全是不可见的，就像一个黑盒子。虽然我们看不到黑盒子的内部构造与工作原理，
+    但它向外部开放了控制接口，让我们可以接上手柄对其进行访问，这便构成了一个完美的封装。
+    “门面模式”就是极好的范例。例如我们去某单位办理一项业务，来到业务大厅一脸茫然，各种填表、盖章等复杂的办理流程让人一头雾水，有可能来回折腾
+    几个小时。假若有一个提供快速通道服务的“门面”办理窗口，那么我们只需简单地把材料递交过去就可以了，“办理人“与“门面”保持最简单的通信，对于门面
+    里面发生的事情，办理人则知之甚少，更没有必要去亲力亲为。要设计出符合迪米特法则的软件，切勿跨越红线，干涉他人内务。系统模块一定要最大程度地
+    隐藏内部逻辑，大门一定要紧锁，防止陌生人随意访问，而对外只适可而止地暴露最简单的接口，让模块间的通信趋向“简单化”“傻瓜化”。
 
 
 - 合成复用原则`（Composite Reuse Principle）`          
     原则是尽量使用合成/聚合的方式，而不是使用继承。
 
 - 单一职责原则(Single Responsibility Principle)    
-    我们知道，一套功能完备的软件系统可能是非常复杂的。既然要利用好面向对象的思想，那么对一个大系统的拆分、模块化是不可或缺的软件设计步骤。面向对象以“类”来划分模块边界，再以“方法”来分隔其功能。我们可以将某业务功能划归到一个类中，也可以拆分为几个类分别实现，但是不管对其负责的业务范围大小做怎样的权衡与调整，这个类的角色职责应该是单一的，或者其方法所完成的功能也应该是单一的。总之，不是自己分内之事绝不该负责，这就是单一职责原则(SingleResponsibility Principle)。
-    以最典型的“责任链模式”为例，其环环相扣的每个节点都“各扫门前雪”，这种清晰的职责范围划分就是单一职责原则的最佳实践。符合单一职责原则的设计能使类具备“高内聚性”，让单个模块变得“简单”“易懂”，如此才能增强代码的可读性与可复用性，并提高系统的易维护性与易测试性。
+    我们知道，一套功能完备的软件系统可能是非常复杂的。既然要利用好面向对象的思想，那么对一个大系统的拆分、模块化是不可或缺的软件设计步骤。
+    面向对象以“类”来划分模块边界，再以“方法”来分隔其功能。我们可以将某业务功能划归到一个类中，也可以拆分为几个类分别实现，但是不管对其负责的业
+    务范围大小做怎样的权衡与调整，这个类的角色职责应该是单一的，或者其方法所完成的功能也应该是单一的。总之，不是自己分内之事绝不该负责，这就是
+    单一职责原则。
+    以最典型的“责任链模式”为例，其环环相扣的每个节点都“各扫门前雪”，这种清晰的职责范围划分就是单一职责原则的最佳实践。符合单一职责原则的设计
+    能使类具备“高内聚性”，让单个模块变得“简单”“易懂”，如此才能增强代码的可读性与可复用性，并提高系统的易维护性与易测试性。
 
 
 1.工厂方法模式`(Factory Method)`
 ---
 
-制造业是一个国家工业经济发展的重要支柱，而工厂则是其根基所在。程序设计中的工厂类往往是对对象构造、实例化、初始化过程的封装，而工厂方法(Factory Method)则可以升华为一种设计模式，它对工厂制造方法进行接口规范化，以允许子类工厂决定具体制造哪类产品的实例，最终降低系统耦合，使系统的可维护性、可扩展性等得到提升。
+制造业是一个国家工业经济发展的重要支柱，而工厂则是其根基所在。程序设计中的工厂类往往是对对象构造、实例化、初始化过程的封装，而工厂方法则可以升华
+为一种设计模式，它对工厂制造方法进行接口规范化，以允许子类工厂决定具体制造哪类产品的实例，最终降低系统耦合，使系统的可维护性、可扩展性等得到提升。
 工厂内部封装的生产逻辑对外部来说像一个黑盒子，外部不需要关心工厂内部细节，外部类只管调用即可。
 
 工厂方法模式分为三种:      
@@ -139,27 +164,28 @@
     sender.Send();  
     ```
 
-总体来说，工厂模式适合凡是出现了大量的产品需要创建，并且具有共同的接口时，可以通过工厂方法模式进行创建。在以上的三种模式中，第一种如果传入的字符串有误，不能正确创建对象，第三种相对于第二种，不需要实例化工厂类，所以，大多数情况下，我们会选用第三种——静态工厂方法模式。
-
-
+总体来说，工厂模式适合凡是出现了大量的产品需要创建，并且具有共同的接口时，可以通过工厂方法模式进行创建。在以上的三种模式中，
+第一种如果传入的字符串有误，不能正确创建对象，第三种相对于第二种，不需要实例化工厂类，所以，大多数情况下，我们会选用第三种——静态工厂方法模式。
 
 2.抽象工厂模式`(Abstract Factory)`
 ---
 
+工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，
+有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。
 
-工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。
-
-抽象工厂模式(Abstract Factory)是对工厂的抽象化，而不只是制造方法。我们知道，为了满足不同用户对产品的多样化需求，工厂不会只局限于生产一类产品，但是系统如果按工厂方法那样为每种产品都增加一个新工厂又会造成工厂泛滥。所以，为了调和这种矛盾，抽象工厂模式提供了另一种思路，将各种产品分门别类，基于此来规划各种工厂的制造接口，最终确立产品制造的顶级规范，使其与具体产品彻底脱钩。抽象工厂是建立在制造复杂产品体系需求基础之上的一种设计模式，在某种意义上，我们可以将抽象工厂模式理解为工厂方法模式的高度集群化升级版。
-针对这种情况，我们就需要进行产业规划与整合，对现有工厂进行重构。例如，我们可以基于产品品牌与系列进行生产线规划，按品牌划分A工厂与B工厂。具体以汽车工厂举例，A品牌汽车有轿车、越野车、跑车3个系列的产品，同样地，B品牌汽车也包括以上3个系列的产品，如此便形成了两个产品族，分别由A工厂和B工厂负责生产，每个工厂都有3条生产线，分别生产这3个系列的汽车，如图5-1所示。
-
-
-
+抽象工厂模式是对工厂的抽象化，而不只是制造方法。我们知道，为了满足不同用户对产品的多样化需求，工厂不会只局限于生产一类产品，但是系统如果按工厂
+方法那样为每种产品都增加一个新工厂又会造成工厂泛滥。所以，为了调和这种矛盾，抽象工厂模式提供了另一种思路，将各种产品分门别类，基于此来规划各种
+工厂的制造接口，最终确立产品制造的顶级规范，使其与具体产品彻底脱钩。
+抽象工厂是建立在制造复杂产品体系需求基础之上的一种设计模式，在某种意义上，我们可以将抽象工厂模式理解为工厂方法模式的高度集群化升级版。
+针对这种情况，我们就需要进行产业规划与整合，对现有工厂进行重构。例如，我们可以基于产品品牌与系列进行生产线规划，按品牌划分A工厂与B工厂。
+具体以汽车工厂举例，A品牌汽车有轿车、越野车、跑车3个系列的产品，同样的，B品牌汽车也包括以上3个系列的产品，如此便形成了两个产品族，分别由A工厂
+和B工厂负责生产，每个工厂都有3条生产线，分别生产这3个系列的汽车。
 
 还是用上面的例子，只是在工厂类这里需要改一下，提供两个不同的工厂类，他们要实现同一个接口:    
 
 ```java
 public interface IProvider {  
-    public ISender produce();  
+    ISender produce();  
 }  
 ```
 
@@ -171,8 +197,7 @@ public class SendMailFactory implements IProvider {
     public ISender produce(){  
         return new MailSender();  
     }  
-}  
-
+}
 
 public class SendSmsFactory implements IProvider{  
     @Override  
@@ -190,13 +215,13 @@ ISender sender = provider.produce();
 sender.Send();  
 ```
 
-其实这个模式的好处就是，如果你现在想增加一个功能：发送即时信息，则只需做一个实现类，实现`ISender`接口，同时做一个工厂类，实现`IProvider`接口，就`OK`了，无需去改动现成的代码。这样做，拓展性较好！
+其实这个模式的好处就是，如果你现在想增加一个功能：发送即时信息，则只需做一个实现类，实现`ISender`接口，同时做一个工厂类，实现`IProvider`接口，
+就`OK`了，无需去改动现成的代码。这样做，拓展性较好！
 
 
 3.单例模式`(Singleton)`
 ---
 
-
 单例模式能保证在一个`JVM`中，该对象只有一个实例存在。
 
 这样的模式有几个好处:      
@@ -225,7 +250,9 @@ public class SingleTon {
 }
 ```
 
-这个类可以满足基本要求，但是，像这样毫无线程安全保护的类，如果我们把它放入多线程的环境下，肯定就会出现问题了，如何解决？我们首先会想到对`getInstance()`方法加`synchronized`关键字，但是，`synchronized`关键字锁住的是这个对象，这样的用法，在性能上会有所下降，因为每次调用`getInstance()`，都要对对象上锁，事实上，只有在第一次创建对象的时候需要加锁，之后就不需要了，所以，这个地方需要改进。我们改成下面这个:   
+这个类可以满足基本要求，但是，像这样毫无线程安全保护的类，如果我们把它放入多线程的环境下，肯定就会出现问题了，如何解决？我们首先会想到对
+`getInstance()`方法加`synchronized`关键字，但是，`synchronized`关键字锁住的是这个对象，这样的用法，在性能上会有所下降，因为每次调用
+`getInstance()`，都要对对象上锁，事实上，只有在第一次创建对象的时候需要加锁，之后就不需要了，所以，这个地方需要改进。我们改成下面这个:   
 
 ```java
 public class SingleTon {
@@ -253,8 +280,11 @@ public class SingleTon {
 }
 ```
 
-似乎解决了之前提到的问题，将`synchronized`关键字加在了内部，也就是说当调用的时候是不需要加锁的，只有在`instance`为`null`，并创建对象的时候才需要加锁，性能有一定的提升。         
-但是，这样的情况，还是有可能有问题的，看下面的情况：在`Java`指令中创建对象和赋值操作是分开进行的，也就是说`instance = new Singleton();`语句是分两步执行的。但是JVM并不保证这两个操作的先后顺序，也就是说有可能`JVM`会为新`的Singleton`实例分配空间，然后直接赋值给`instance`成员，然后再去初始化这个`Singleton`实例。这样就可能出错了。     
+似乎解决了之前提到的问题，将`synchronized`关键字加在了内部，也就是说当调用的时候是不需要加锁的，只有在`instance`为`null`，并创建对象的时候
+才需要加锁，性能有一定的提升。         
+但是，这样的情况，还是有可能有问题的，看下面的情况：在`Java`指令中创建对象和赋值操作是分开进行的，也就是说`instance = new Singleton();`
+语句是分两步执行的。但是JVM并不保证这两个操作的先后顺序，也就是说有可能`JVM`会为新`的Singleton`实例分配空间，然后直接赋值给`instance`成员，
+然后再去初始化这个`Singleton`实例。这样就可能出错了。     
 
 我们以`A`、`B`两个线程为例:      
 
@@ -286,18 +316,25 @@ public class SingleTon {
 }
 ```
 
-单例模式使用内部类来维护单例的实现，`JVM`内部的机制能够保证当一个类被加载的时候，这个类的加载过程是线程互斥的。这样当我们第一次调用`getInstance()`的时候，`JVM`能够帮我们保证`instance`只被创建一次，并且会保证把赋值给`instance`的内存初始化完毕，这样我们就不用担心上面的问题。同时该方法也只会在第一次调用的时候使用互斥机制，这样就解决了低性能问题。
-其实说它完美，也不一定，如果在构造函数中抛出异常，实例将永远得不到创建，也会出错。所以说，十分完美的东西是没有的，我们只能根据实际情况，选择最适合自己应用场景的实现方法。
+单例模式使用内部类来维护单例的实现，`JVM`内部的机制能够保证当一个类被加载的时候，这个类的加载过程是线程互斥的。
+这样当我们第一次调用`getInstance()`的时候，`JVM`能够帮我们保证`instance`只被创建一次，并且会保证把赋值给`instance`的内存初始化完毕，
+这样我们就不用担心上面的问题。同时该方法也只会在第一次调用的时候使用互斥机制，这样就解决了低性能问题。
+其实说它完美，也不一定，如果在构造函数中抛出异常，实例将永远得不到创建，也会出错。所以说，十分完美的东西是没有的，我们只能根据实际情况，
+选择最适合自己应用场景的实现方法。
 
 
 4.建造者模式`(Builder)`
 ---
 
 
-建造者模式(Builder)所构建的对象一定是庞大而复杂的，并且一定是按照既定的制造工序将组件组装起来的，例如计算机、汽车、建筑物等。我们通常将负责构建这些大型对象的工程师称为建造者。建造者模式又称为生成器模式，主要用于对复杂对象的构建、初始化，它可以将多个简单的组件对象按顺序一步步组装起来，最终构建成一个复杂的成品对象。与工厂系列模式不同的是，建造者模式的主要目的在于把烦琐的构建过程从不同对象中抽离出来，使其脱离并独立于产品类与工厂类，最终实现用同一套标准的制造工序能够产出不同的产品。
-
-工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性，其实建造者模式就是前面抽象工厂模式和最后的`Test`测试类结合起来得到的。         
+建造者模式所构建的对象一定是庞大而复杂的，并且一定是按照既定的制造工序将组件组装起来的，例如计算机、汽车、建筑物等。我们通常将负责构建这些大型
+对象的工程师称为建造者。
+建造者模式又称为生成器模式，主要用于对复杂对象的构建、初始化，它可以将多个简单的组件对象按顺序一步步组装起来，最终构建成一个复杂的成品对象。
+与工厂系列模式不同的是，建造者模式的主要目的在于把烦琐的构建过程从不同对象中抽离出来，使其脱离并独立于产品类与工厂类，最终实现用同一套标准的制造
+工序能够产出不同的产品。
 
+工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性，
+其实建造者模式就是前面抽象工厂模式和最后的`Test`测试类结合起来得到的。
 
 还是前面的例子，一个`ISender`接口，两个实现类`MailSender`和`SmsSender`。最后，建造者类如下:    
 ```java
@@ -323,21 +360,24 @@ Builder builder = new Builder();
 builder.produceMailSender(10);  
 ```
 
-建造者模式将很多功能集成到一个类里，这个类可以创造出比较复杂的东西。所以与工程模式的区别就是：工厂模式关注的是创建单个产品，而建造者模式则关注创建符合对象，多个部分。因此，是选择工厂模式还是建造者模式，依实际情况而定。
+建造者模式将很多功能集成到一个类里，这个类可以创造出比较复杂的东西。所以与工程模式的区别就是：工厂模式关注的是创建单个产品，而建造者模式则关注
+创建符合对象，多个部分。因此，是选择工厂模式还是建造者模式，依实际情况而定。
 
 5.原型模式`(Prototype)`
 ---
 
-在制造业中通常是指大批量生产开始之前研发出的概念模型，并基于各种参数指标对其进行检验，如果达到了质量要求，即可参照这个原型进行批量生产。原型模式达到以原型实例创建副本实例的目的即可，并不需要知道其原始类。
+在制造业中通常是指大批量生产开始之前研发出的概念模型，并基于各种参数指标对其进行检验，如果达到了质量要求，即可参照这个原型进行批量生产。
+原型模式达到以原型实例创建副本实例的目的即可，并不需要知道其原始类。
 也就是说，原型模式可以用对象创建对象，而不是用类创建对象，以此达到效率的提升。
 
-构造一个对象的过程是耗时耗力的。想必大家一定有过打印和复印的经历，为了节省成本，我们通常会用打印机把电子文档打印到A4纸上（原型实例化过程），再用复印机把这份纸质文稿复制多份（原型拷贝过程），这样既实惠又高效。
+构造一个对象的过程是耗时耗力的。想必大家一定有过打印和复印的经历，为了节省成本，我们通常会用打印机把电子文档打印到A4纸上（原型实例化过程），
+再用复印机把这份纸质文稿复制多份（原型拷贝过程），这样既实惠又高效。
 那么，对于第一份打印出来的原文稿，我们可以称之为“原型文件”，而对于复印过程，我们则可以称之为“原型拷贝”
 
 想必大家已经明白了类的实例化与克隆之间的区别，二者都是在造对象，但方法绝对是不同的。
 ***原型模式的目的是从原型实例克隆出新的实例，对于那些有非常复杂的初始化过程的对象或者是需要耗费大量资源的情况，原型模式是更好的选择***
 
-该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。本小结会通过对象的复制，进行讲解。在`Java`中，复制对象是通过`clone()`实现的，先创建一个原型类:      
+该模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。在`Java`中，复制对象是通过`clone()`实现的，先创建一个原型类:      
 
 ```java
 public class Prototype implements Cloneable {
@@ -348,10 +388,14 @@ public class Prototype implements Cloneable {
 }
 ```
 
-很简单，一个原型类，只需要实现`Cloneable`接口，重写`clone()`方法，此处`clone()`方法可以改成任意的名称，因为`Cloneable`接口是个空接口，你可以任意定义实现类的方法名，如`cloneA`或者`cloneB`，因为此处的重点是`super.clone()`这句话，`super.clone()`调用的是`Object`的`clone()`方法，而在`Object`类中，`clone()`是`native`的。
+很简单，一个原型类，只需要实现`Cloneable`接口，重写`clone()`方法，此处`clone()`方法可以改成任意的名称，因为`Cloneable`接口是个空接口，
+你可以任意定义实现类的方法名，如`cloneA`或者`cloneB`，因为此处的重点是`super.clone()`这句话，
+`super.clone()`调用的是`Object`的`clone()`方法，而在`Object`类中，`clone()`是`native`的。
 
-我们都知道，Java中的变量分为原始类型和引用类型，所谓浅拷贝是指只复制原始类型的值，比如横坐标x与纵坐标y这种以原始类型int定义的值，它们会被复制到新克隆出的对象中。
-而引用类型同样会被拷贝，但是请注意这个操作只是拷贝了地址引用（指针），也就是说副本与原型中的对象是同一个，因为两个同样的地址实际指向的内存对象是同一个对象。需要注意的是，克隆方法中调用父类Object的clone方法进行的是浅拷贝，所以此处的bullet并没有被真正克隆。
+我们都知道，Java中的变量分为原始类型和引用类型，所谓浅拷贝是指只复制原始类型的值，比如横坐标x与纵坐标y这种以原始类型int定义的值，
+它们会被复制到新克隆出的对象中。
+而引用类型同样会被拷贝，但是请注意这个操作只是拷贝了地址引用（指针），也就是说副本与原型中的对象是同一个，因为两个同样的地址实际指向的内存对象是
+同一个对象。需要注意的是，克隆方法中调用父类Object的clone方法进行的是浅拷贝，所以此处的bullet并没有被真正克隆。
 
 在这儿，将结合对象的浅复制和深复制来说一下，首先需要了解对象深、浅复制的概念:    
 
@@ -409,14 +453,17 @@ class SerializableObject implements Serializable {
 
 实现深复制，需要采用流的形式读入当前对象的二进制输入，再写出二进制数据对应的对象。
 
-从类到对象叫作“创建”，而由本体对象至副本对象则叫作“克隆”，当需要创建多个类似的复杂对象时，我们就可以考虑用原型模式。究其本质，克隆操作时Java虚拟机会进行内存操作，直接拷贝原型对象数据流生成新的副本对象，绝不会拖泥带水地触发一些多余的复杂操作（如类加载、实例化、初始化等），所以其效率远远高于“new”关键字所触发的实例化操作。看尽世间烦扰，拨开云雾见青天，有时候“简单粗暴”也是一种去繁从简、不绕弯路的解决方案。
+从类到对象叫作“创建”，而由本体对象至副本对象则叫作“克隆”，当需要创建多个类似的复杂对象时，我们就可以考虑用原型模式。究其本质，克隆操作时Java
+虚拟机会进行内存操作，直接拷贝原型对象数据流生成新的副本对象，绝不会拖泥带水地触发一些多余的复杂操作（如类加载、实例化、初始化等），所以其效率
+远远高于“new”关键字所触发的实例化操作。看尽世间烦扰，拨开云雾见青天，有时候“简单粗暴”也是一种去繁从简、不绕弯路的解决方案。
 
 
 适配器模式`(Adapter)`
 ---
 
 适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。
-适配器模式(Adapter)通常也被称为转换器，顾名思义，它一定是进行适应与匹配工作的物件。当一个对象或类的接口不能匹配用户所期待的接口时，适配器就充当中间转换的角色，以达到兼容用户接口的目的，同时适配器也实现了客户端与接口的解耦，提高了组件的可复用性。
+适配器模式(Adapter)通常也被称为转换器，顾名思义，它一定是进行适应与匹配工作的物件。当一个对象或类的接口不能匹配用户所期待的接口时，
+适配器就充当中间转换的角色，以达到兼容用户接口的目的，同时适配器也实现了客户端与接口的解耦，提高了组件的可复用性。
 
 
 主要分为三类：     
@@ -428,36 +475,36 @@ class SerializableObject implements Serializable {
     ```java
     public interface Targetable {  
         /* 与原类中的方法相同 */  
-	    public void method1();  
-	  
-	    /* 新类的方法 */  
-	    public void method2();  
-	}  
-
-	public class Source {  	  
-	    public void method1() {  
-	        System.out.println("this is original method!");  
-	    }  
-	}  
-
-	public class Adapter extends Source implements Targetable {  
-	    @Override  
-	    public void method2() {  
-	        System.out.println("this is the targetable method!");  
-	    }  
-	} 
-
-	public class AdapterTest {  
-	    public static void main(String[] args) {  
-	        Targetable target = new Adapter();  
-	        target.method1();  
-	        target.method2();  
-	    }  
-	}
-
-	输出结果是:    
-	this is original method!
-	this is the targetable method!
+        public void method1();  
+      
+        /* 新类的方法 */  
+        public void method2();  
+    }  
+
+    public class Source {     
+        public void method1() {  
+            System.out.println("this is original method!");  
+        }  
+    }  
+
+    public class Adapter extends Source implements Targetable {  
+        @Override  
+        public void method2() {  
+            System.out.println("this is the targetable method!");  
+        }  
+    } 
+
+    public class AdapterTest {  
+        public static void main(String[] args) {  
+            Targetable target = new Adapter();  
+            target.method1();  
+            target.method2();  
+        }  
+    }
+
+    输出结果是:    
+    this is original method!
+    this is the targetable method!
     ```
 
     `Adapter`类继承`Source`类，实现`Targetable`接口,这样`Targetable`接口的实现类就具有了`Source`类的功能。
@@ -469,31 +516,31 @@ class SerializableObject implements Serializable {
     只修改上面的`Adapter`类就可以了。   
 
     ```java
-	public class Adapter implements Targetable {  
-	    private Source source;  
-	    public Adapter(Source source){  
-	        super();  
-	        this.source = source;  
-	    }  
-	    @Override  
-	    public void method2() {  
-	        System.out.println("this is the targetable method!");  
-	    }  
-	  
-	    @Override  
-	    public void method1() {  
-	        source.method1();  
-	    }  
-	} 
-
-	public class AdapterTest {  
-	    public static void main(String[] args) {  
-	        Source source = new Source();  
-	        Targetable target = new Wrapper(source);  
-	        target.method1();  
-	        target.method2();  
-	    }  
-	}  
+    public class Adapter implements Targetable {  
+        private Source source;  
+        public Adapter(Source source){  
+            super();  
+            this.source = source;  
+        }  
+        @Override  
+        public void method2() {  
+            System.out.println("this is the targetable method!");  
+        }  
+      
+        @Override  
+        public void method1() {  
+            source.method1();  
+        }  
+    } 
+
+    public class AdapterTest {  
+        public static void main(String[] args) {  
+            Source source = new Source();  
+            Targetable target = new Wrapper(source);  
+            target.method1();  
+            target.method2();  
+        }  
+    }  
     ```
     输出结果和上面的一样，只是适配器的方法不同。
 
@@ -505,42 +552,42 @@ class SerializableObject implements Serializable {
     而我们不和原始的接口打交道，只和该抽象类取得联系，所以我们写一个类，继承该抽象类，重写我们需要的方法就行。例如`Android ListView`中的`Adapter`就是这样设计的。 
 
     ```java
-	public interface ISourceable {  
-	    public void method1();  
-	    public void method2();  
-	    public void method3();  
-	    public void method4();  
-	    public void method5();  
-	    public void method6();  
-	}
-
-	public abstract class BaseAdapter implements ISourceable{  
+    public interface ISourceable {  
+        public void method1();  
+        public void method2();  
+        public void method3();  
+        public void method4();  
+        public void method5();  
+        public void method6();  
+    }
+
+    public abstract class BaseAdapter implements ISourceable{  
         public void method1() {
 
         }
-	    public void method2() {
-        		
+        public void method2() {
+                
         }
-	    public void method3() {
-        		
+        public void method3() {
+                
         }
-	    public void method4() {
-        		
+        public void method4() {
+                
         }
-	    public void method5() {
-        		
+        public void method5() {
+                
         }
-	    public void method6() {
-        		
+        public void method6() {
+                
         }
-	}
-
-	public class ListAdapter extends BaseAdapter {  
-		// 不用全部实现方法，只需要实现自己需要的就可以了
-	    public void method4(){  
-	        System.out.println("the sourceable interface's first Sub1!");  
-	    }  
-	}  
+    }
+
+    public class ListAdapter extends BaseAdapter {  
+        // 不用全部实现方法，只需要实现自己需要的就可以了
+        public void method4(){  
+            System.out.println("the sourceable interface's first Sub1!");  
+        }  
+    }  
     ```
 
 
@@ -555,7 +602,9 @@ class SerializableObject implements Serializable {
 ---
 
 装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。     
-装饰器模式(Decorator)能够在运行时动态地为原始对象增加一些额外的功能，使其变得更加强大。从某种程度上讲，装饰器非常类似于“继承”，它们都是为了增强原始对象的功能，区别在于方式的不同，后者是在编译时(compile-time)静态地通过对原始类的继承完成，而前者则是在程序运行时(run-time)通过对原始对象动态地“包装”完成，是对类实例（对象）“装饰”的结果。
+装饰器模式(Decorator)能够在运行时动态地为原始对象增加一些额外的功能，使其变得更加强大。从某种程度上讲，装饰器非常类似于“继承”，它们都是为了
+增强原始对象的功能，区别在于方式的不同，后者是在编译时(compile-time)静态地通过对原始类的继承完成，而前者则是在程序运行时(run-time)通过对原始
+对象动态地“包装”完成，是对类实例（对象）“装饰”的结果。
 
 
 `Source`类是被装饰类，`Decorator`类是一个装饰类，可以为`Source`类动态的添加一些功能，代码如下:    
@@ -609,18 +658,22 @@ after decorator!
 代理模式`(Proxy)`
 ---
 
-代理模式(Proxy)，顾名思义，有代表打理的意思。某些情况下，当客户端不能或不适合直接访问目标业务对象时，业务对象可以通过代理把自己的业务托管起来，使客户端间接地通过代理进行业务访问。如此不但能方便用户使用，还能对客户端的访问进行一定的控制。简单来说，就是代理方以业务对象的名义，代理了它的业务。
-代理模式不仅能增强原业务功能，更重要的是还能对其进行业务管控。对用户来讲，隐藏于代理中的实际业务被透明化了，而暴露出来的是代理业务，以此避免客户端直接进行业务访问所带来的安全隐患，从而保证系统业务的可控性、安全性。
+代理模式(Proxy)，顾名思义，有代表打理的意思。某些情况下，当客户端不能或不适合直接访问目标业务对象时，业务对象可以通过代理把自己的业务托管起来，
+使客户端间接地通过代理进行业务访问。如此不但能方便用户使用，还能对客户端的访问进行一定的控制。简单来说，就是代理方以业务对象的名义，代理了它的业务。
+代理模式不仅能增强原业务功能，更重要的是还能对其进行业务管控。对用户来讲，隐藏于代理中的实际业务被透明化了，而暴露出来的是代理业务，以此避免客户
+端直接进行业务访问所带来的安全隐患，从而保证系统业务的可控性、安全性。
 
-代理模式就是多一个代理类出来，替原对象进行一些操作，比如我们在租房子的时候回去找中介，为什么呢？因为你对该地区房屋的信息掌握的不够全面，希望找一个更熟悉的人去帮你做，此处的代理就是这个意思。再如我们有的时候打官司，我们需要请律师，因为律师在法律方面有专长，可以替我们进行操作，表达我们的想法。也就是说把专业事情交给专业的人来做。    
+代理模式就是多一个代理类出来，替原对象进行一些操作，比如我们在租房子的时候回去找中介，为什么呢？因为你对该地区房屋的信息掌握的不够全面，
+希望找一个更熟悉的人去帮你做，此处的代理就是这个意思。再如我们有的时候打官司，我们需要请律师，因为律师在法律方面有专长，可以替我们进行操作，
+表达我们的想法。也就是说把专业事情交给专业的人来做。    
 
 代理按照代理的创建时期，可以分为两种:     
 
 - 静态代理:由程序员创建代理类或特定工具自动生成源代码再对其编译。在程序运行前代理类的`.class`文件就已经存在了。   
 - 动态代理:在程序运行时运用反射机制动态创建而成。也就是说我们不需要专门针对某个接口去编写代码实现一个代理类，而是在接口运行时动态生成。    
 
-静态代理是在编译时就将接口、实现类、代理类一股脑儿全部手动完成，但如果我们需要很多的代理，每一个都这么手动的去创建实属浪费时间，而且会有大量的重复代码，此时我们就可以采用动态代理，动态代理可以在程序运行期间根据需要动态的创建代理类及其实例，来完成具体的功能，主要用的是`JAVA`的反射机制。
-
+静态代理是在编译时就将接口、实现类、代理类一股脑儿全部手动完成，但如果我们需要很多的代理，每一个都这么手动的去创建实属浪费时间，而且会有大量的
+重复代码，此时我们就可以采用动态代理，动态代理可以在程序运行期间根据需要动态的创建代理类及其实例，来完成具体的功能，主要用的是`Java`的反射机制。
 
 下面用静态代理的示例:     
 ```java
@@ -691,22 +744,20 @@ after proxy!
 ```java
 //动态代理类只能代理接口（不支持抽象类），代理类都需要实现InvocationHandler类，实现invoke方法。该invoke方法就是调用被代理接口的所有方法时需要调用的，该invoke方法返回的值是被代理接口的一个实现类  
 public class DynamicProxy implements InvocationHandler {
-　　private Object object;//用于接收具体实现类的实例对象
-　　//使用带参数的构造器来传递具体实现类的对象
-　　public DynamicProxy(Object obj){
-　　　　this.object = obj;
-　　}
-　　@Override
-　　public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
-　　　　System.out.println("前置内容");
-　　　　method.invoke(object, args);
-　　　　System.out.println("后置内容");
-　　　　return null;
-　　}
+    private Object object;//用于接收具体实现类的实例对象
+    //使用带参数的构造器来传递具体实现类的对象
+    public DynamicProxy(Object obj){
+        this.object = obj;
+    }
+    @Override
+    public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
+        System.out.println("前置内容");
+        method.invoke(object, args);
+        System.out.println("后置内容");
+        return null;
+    }
 }
 
-测试类:   
-
 public static void main(String[] args) {
     ISourceable source = new Source();
     InvocationHandler h = new DynamicProxy(source);
@@ -715,20 +766,29 @@ public static void main(String[] args) {
 }
 ```
 
+动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理`(InvocationHandler.invoke)`。这样，
+在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。而且动态代理的应用使我们的类职责更加单一，复用性更强
 
-动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理`(InvocationHandler.invoke)`。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。而且动态代理的应用使我们的类职责更加单一，复用性更强
-
-代理对象就是把被代理对象包装一层，在其内部做一些额外的工作，比如用户需要上facebook,而普通网络无法直接访问，网络代理帮助用户先翻墙，然后再访问facebook。这就是代理的作用了。
+代理对象就是把被代理对象包装一层，在其内部做一些额外的工作，比如用户需要上facebook,而普通网络无法直接访问，网络代理帮助用户先翻墙，
+然后再访问facebook。这就是代理的作用了。
 
-纵观静态代理与动态代理，它们都能实现相同的功能，而我们看从静态代理到动态代理的这个过程，我们会发现其实动态代理只是对类做了进一步抽象和封装，使其复用性和易用性得到进一步提升而这不仅仅符合了面向对象的设计理念，其中还有AOP的身影，这也提供给我们对类抽象的一种参考。关于动态代理与AOP的关系，个人觉得AOP是一种思想，而动态代理是一种AOP思想的实现！
+纵观静态代理与动态代理，它们都能实现相同的功能，而我们看从静态代理到动态代理的这个过程，我们会发现其实动态代理只是对类做了进一步抽象和封装，
+使其复用性和易用性得到进一步提升而这不仅仅符合了面向对象的设计理念，其中还有AOP的身影，这也提供给我们对类抽象的一种参考。关于动态代理与AOP的关系，
+个人觉得AOP是一种思想，而动态代理是一种AOP思想的实现！
 
 外观(门面)模式`(Facade)`
 ---
 
 
-外观模式是为了解决类与类之家的依赖关系的，像`spring`一样，可以将类和类之间的关系配置到配置文件中，而外观模式就是将他们的关系放在一个`Facade`类中，降低了类类之间的耦合度，该模式中没有涉及到接口。   它可能是最简单的结构型设计模式，它能将多个不同的子系统接口封装起来，并对外提供统一的高层接口，使复杂的子系统变得更易使用。 利用门面模式，我们可以把多个子系统“关”在门里面隐藏起来，成为一个整合在一起的大系统，来自外部的访问只需通过这道“门面”（接口）来进行，而不必再关心门面背后隐藏的子系统及其如何运转。总之，无论门面内部如何错综复杂，从门面外部看来总是一目了然，使用起来也很简单。
+外观模式是为了解决类与类之家的依赖关系的，像`spring`一样，可以将类和类之间的关系配置到配置文件中，而外观模式就是将他们的关系放在一个`Facade`
+类中，降低了类类之间的耦合度，该模式中没有涉及到接口。    
+它可能是最简单的结构型设计模式，它能将多个不同的子系统接口封装起来，并对外提供统一的高层接口，使复杂的子系统变得更易使用。    
+利用门面模式，我们可以把多个子系统“关”在门里面隐藏起来，成为一个整合在一起的大系统，来自外部的访问只需通过这道“门面”（接口）来进行，而不必再
+关心门面背后隐藏的子系统及其如何运转。总之，无论门面内部如何错综复杂，从门面外部看来总是一目了然，使用起来也很简单。
 
-为了更形象地理解门面模式，我们先来看一个例子。早期的相机使用起来是非常麻烦的，拍照前总是要根据场景情况进行一系列复杂的操作，如对焦、调节闪光灯、调光圈等，非专业人士面对这么一大堆的操作按钮根本无从下手，拍出来的照片质量也不高。随着科技的进步，出现了一种相机，叫作“傻瓜相机”，以形容其使用起来的方便性。用户再也不必学习那些复杂的参数调节了，只要按下快门键就可完成所有操作。
+为了更形象地理解门面模式，我们先来看一个例子。早期的相机使用起来是非常麻烦的，拍照前总是要根据场景情况进行一系列复杂的操作，如对焦、调节闪光灯、
+调光圈等，非专业人士面对这么一大堆的操作按钮根本无从下手，拍出来的照片质量也不高。随着科技的进步，出现了一种相机，叫作“傻瓜相机”，以形容其使用
+起来的方便性。用户再也不必学习那些复杂的参数调节了，只要按下快门键就可完成所有操作。
 
 
 下面以计算机启动过程为例:   
@@ -797,10 +857,7 @@ public class User {
         computer.startup();  
         computer.shutdown();  
     }  
-}  
-
-输出：
-
+}
 start the computer!
 cpu startup!
 memory startup!
@@ -813,15 +870,18 @@ disk shutdown!
 computer closed!
 ```
 
-如果我们没有`Computer`类，那么`CPU`、`Memory`、`Disk`他们之间将会相互持有实例，产生关系，这样会造成严重的依赖，修改一个类，可能会带来其他类的修改，这不是我们想要看到的，有了`Computer`类，他们之间的关系被放在了`Computer`类里，这样就起到了解耦的作用，这就是外观模式！
+如果我们没有`Computer`类，那么`CPU`、`Memory`、`Disk`他们之间将会相互持有实例，产生关系，这样会造成严重的依赖，修改一个类，可能会带来
+其他类的修改，这不是我们想要看到的，有了`Computer`类，他们之间的关系被放在了`Computer`类里，这样就起到了解耦的作用，这就是外观模式！
 
 
 桥接模式`(Bridge)`
 ---
 
-桥接模式(Bridge)能将抽象与实现分离，使二者可以各自单独变化而不受对方约束，使用时再将它们组合起来，就像架设桥梁一样连接它们的功能，如此降低了抽象与实现这两个可变维度的耦合度，以保证系统的可扩展性。       
+桥接模式能将抽象与实现分离，使二者可以各自单独变化而不受对方约束，使用时再将它们组合起来，就像架设桥梁一样连接它们的功能，如此降低了抽象与实现
+这两个可变维度的耦合度，以保证系统的可扩展性。       
 
-桥接的用意是：将抽象化与实现化解耦，使得二者可以独立变化，像我们常用的`JDBC`桥`DriverManager`一样，`JDBC`进行连接数据库的时候，在各个数据库之间进行切换，基本不需要动太多的代码，甚至丝毫不用动，原因就是`JDBC`提供统一接口，每个数据库提供各自的实现，用一个叫做数据库驱动的程序来桥接就行了。        
+桥接的用意是：将抽象化与实现化解耦，使得二者可以独立变化，像我们常用的`JDBC`桥`DriverManager`一样，`JDBC`进行连接数据库的时候，在各个数据库
+之间进行切换，基本不需要动太多的代码，甚至丝毫不用动，原因就是`JDBC`提供统一接口，每个数据库提供各自的实现，用一个叫做数据库驱动的程序来桥接就行了。        
 
 ```java
 public interface ISourceable {  
@@ -861,9 +921,9 @@ public abstract class Bridge {
 }  
 public class MyBridge extends Bridge {  
     public void method(){  
-    	if (getSource() == null) {
-    		return;
-    	}
+        if (getSource() == null) {
+            return;
+        }
         getSource().method();  
     }  
 }  
@@ -895,7 +955,8 @@ this is the second sub!
 组合模式`(Composite)`
 ---
 
-组合模式(Composite)是针对由多个节点对象（部分）组成的树形结构的对象（整体）而发展出的一种结构型设计模式，它能够使客户端在操作整体对象或者其下的每个节点对象时做出统一的响应，保证树形结构对象使用方法的一致性，使客户端不必关注对象的整体或部分，最终达到对象复杂的层次结构与客户端解耦的目的。
+组合模式是针对由多个节点对象（部分）组成的树形结构的对象（整体）而发展出的一种结构型设计模式，它能够使客户端在操作整体对象或者其下的每个节点对象
+时做出统一的响应，保证树形结构对象使用方法的一致性，使客户端不必关注对象的整体或部分，最终达到对象复杂的层次结构与客户端解耦的目的。
 
 组合模式有时又叫部分-整体模式在处理类似树形结构的问题时比较方便。   
 
@@ -969,7 +1030,11 @@ public static void main(String[] args) {
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flyweight_1.jpg?raw=true)     
 
-`FlyWeightFactory`负责创建和管理享元单元，当一个客户端请求时，工厂需要检查当前对象池中是否有符合条件的对象，如果有，就返回已经存在的对象，如果没有，则创建一个新对象，`FlyWeight`是超类。一提到共享池，我们很容易联想到`Java`里面的`JDBC`连接池，想想每个连接的特点，我们不难总结出：适用于作共享的一些个对象，他们有一些共有的属性，就拿数据库连接池来说，`url`、`driverClassName`、`username`、`password`及`dbname`，这些属性对于每个连接来说都是一样的，所以就适合用享元模式来处理，建一个工厂类，将上述类似属性作为内部数据，其它的作为外部数据，在方法调用时，当做参数传进来，这样就节省了空间，减少了实例的数量。
+`FlyWeightFactory`负责创建和管理享元单元，当一个客户端请求时，工厂需要检查当前对象池中是否有符合条件的对象，如果有，就返回已经存在的对象，
+如果没有，则创建一个新对象，`FlyWeight`是超类。一提到共享池，我们很容易联想到`Java`里面的`JDBC`连接池，想想每个连接的特点，
+我们不难总结出：适用于作共享的一些个对象，他们有一些共有的属性，就拿数据库连接池来说，`url`、`driverClassName`、`username`、`password`
+及`dbname`，这些属性对于每个连接来说都是一样的，所以就适合用享元模式来处理，建一个工厂类，将上述类似属性作为内部数据，其它的作为外部数据，
+在方法调用时，当做参数传进来，这样就节省了空间，减少了实例的数量。
 
 下面用数据库连接池的例子:   
 
@@ -1027,8 +1092,8 @@ public class ConnectionPool {
 策略模式`(strategy)`
 ---
 
-策略模式定义了一系列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户。需要设计一个接口，为一系列实现类提供统一的方法，多个实现类实现该接口，设计一个抽象类（可有可无，属于辅助类），提供辅助函数，关系图如下：
-
+策略模式定义了一系列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户。需要设计一个接口，为一系列实现类提供
+统一的方法，多个实现类实现该接口，设计一个抽象类（可有可无，属于辅助类），提供辅助函数，关系图如下：
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/strategy.jpg?raw=true)     
 
@@ -1089,28 +1154,33 @@ public class StrategyTest {
 输出: 
 10
 ```
-策略模式的决定权在用户，系统本身提供不同算法的实现，新增或者删除算法，对各种算法做封装。因此，策略模式多用在算法决策系统中，外部用户只需要决定用哪个算法即可
+策略模式的决定权在用户，系统本身提供不同算法的实现，新增或者删除算法，对各种算法做封装。因此，策略模式多用在算法决策系统中，外部用户只需要决定用
+哪个算法即可
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/design_mode_celue.png?raw=true)     
 
-相信大家对上图中的计算机、USB接口还有各种设备之间的关系以及使用方法都非常熟悉了，这些模块组成的系统正是策略模式的最佳范例。策略接口就是图中的USB接口。
-
-我们通过对计算机USB接口的标准化，使计算机系统拥有了无限扩展外设的能力，需要什么功能只需要购买相关的USB设备。可见在策略模式中，USB接口起到了至关重要的解耦作用。如果没有USB接口的存在，我们就不得不将外设直接“焊接”在主机上，致使设备与主机高度耦合，系统将彻底丧失对外设的替换与扩展能力。
-
-变化是世界的常态，唯一不变的就是变化本身。拥有顺势而为、随机应变的能力才能立于不败之地。策略模式的运用能让系统的应变能力得到提升，适应随时变化的需求。接口的巧妙运用让一系列的策略可以脱离系统而单独存在，使系统拥有更灵活、更强大的“可插拔”扩展功能。
+相信大家对上图中的计算机、USB接口还有各种设备之间的关系以及使用方法都非常熟悉了，这些模块组成的系统正是策略模式的最佳范例。策略接口就是图中的
+USB接口。
 
+我们通过对计算机USB接口的标准化，使计算机系统拥有了无限扩展外设的能力，需要什么功能只需要购买相关的USB设备。可见在策略模式中，USB接口起到了
+至关重要的解耦作用。如果没有USB接口的存在，我们就不得不将外设直接“焊接”在主机上，致使设备与主机高度耦合，系统将彻底丧失对外设的替换与扩展能力。
 
+变化是世界的常态，唯一不变的就是变化本身。拥有顺势而为、随机应变的能力才能立于不败之地。策略模式的运用能让系统的应变能力得到提升，适应随时变化
+的需求。接口的巧妙运用让一系列的策略可以脱离系统而单独存在，使系统拥有更灵活、更强大的“可插拔”扩展功能。
 
 模板方法模式`(Template Method)`
 ---
 
-模板是对多种事物的结构、形式、行为的模式化总结，而模板方法模式(Template Method)则是对一系列类行为（方法）的模式化。我们将总结出来的行为规律固化在基类中，对具体的行为实现则进行抽象化并交给子类去完成，如此便实现了子类对基类模板的套用。
+模板是对多种事物的结构、形式、行为的模式化总结，而模板方法模式则是对一系列类行为（方法）的模式化。我们将总结出来的行为规律固化在基类中，
+对具体的行为实现则进行抽象化并交给子类去完成，如此便实现了子类对基类模板的套用。
 
-一个抽象类中，有一个主方法，再定义1...n个方法，可以是抽象的，也可以是实际的方法，定义一个类，继承该抽象类，重写抽象方法，通过调用抽象类，实现对子类的调用，先看个关系图:   
+一个抽象类中，有一个主方法，再定义1...n个方法，可以是抽象的，也可以是实际的方法，定义一个类，继承该抽象类，重写抽象方法，通过调用抽象类，
+实现对子类的调用，先看个关系图:   
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/template.jpg?raw=true)   
 
-就是在`AbstractCalculator`类中定义一个主方法`calculate()`，`calculate()`调用`spilt()`等，`Plus`和`Minus`分别继承`AbstractCalculator`类，通过对`AbstractCalculator`的调用实现对子类的调用，看下面的例子:   
+就是在`AbstractCalculator`类中定义一个主方法`calculate()`，`calculate()`调用`spilt()`等，`Plus`和`Minus`分别继承
+`AbstractCalculator`类，通过对`AbstractCalculator`的调用实现对子类的调用，看下面的例子:   
 
 ```java
 public abstract class AbstractCalculator {  
@@ -1156,9 +1226,11 @@ public static void main(String[] args) {
 观察者模式`(Observer)`
 ---
 
-观察者模式(Observer)可以针对被观察对象与观察者对象之间一对多的依赖关系建立起一种行为自动触发机制，当被观察对象状态发生变化时主动对外发起广播，以通知所有观察者做出响应。
+观察者模式(Observer)可以针对被观察对象与观察者对象之间一对多的依赖关系建立起一种行为自动触发机制，当被观察对象状态发生变化时主动对外发起广播，
+以通知所有观察者做出响应。
 
-观察者模式很好理解，类似于邮件订阅和`RSS`订阅，当我们浏览一些博客或`wiki`时，经常会看到`RSS`图标，就这的意思是，当你订阅了该文章，如果后续有更新，会及时通知你。简单的说就是当一个对象变化时，其它依赖该对象的对象都会收到通知，并且随着变化！对象之间是一种一对多的关系。
+观察者模式很好理解，类似于邮件订阅和`RSS`订阅，当我们浏览一些博客或`wiki`时，经常会看到`RSS`图标，就这的意思是，当你订阅了该文章，如果后续有
+更新，会及时通知你。简单的说就是当一个对象变化时，其它依赖该对象的对象都会收到通知，并且随着变化！对象之间是一种一对多的关系。
 
 在`Android`中我们常用的`Button.setOnClickListener()`其实就是用的观察者模式。大名鼎鼎的`RxJava`也是基于这种模式。  
 
@@ -1254,9 +1326,11 @@ observer2 has received!
 迭代器模式`(Iterator)`
 ---
 
-迭代，在程序中特指对某集合中各元素逐个取用的行为。迭代器模式(Iterator)提供了一种机制来按顺序访问集合中的各元素，而不需要知道集合内部的构造。换句话讲，迭代器满足了对集合迭代的需求，并向外部提供了一种统一的迭代方式，而不必暴露集合的内部数据结构。
+迭代，在程序中特指对某集合中各元素逐个取用的行为。迭代器模式提供了一种机制来按顺序访问集合中的各元素，而不需要知道集合内部的构造。
+换句话讲，迭代器满足了对集合迭代的需求，并向外部提供了一种统一的迭代方式，而不必暴露集合的内部数据结构。
 
-迭代器模式就是顺序访问聚集中的对象，一般来说，集合中非常常见，如果对集合类比较熟悉的话，理解本模式会十分轻松。这句话包含两层意思：一是需要遍历的对象，即聚集对象，二是迭代器对象，用于对聚集对象进行遍历访问。
+迭代器模式就是顺序访问聚集中的对象，一般来说，集合中非常常见，如果对集合类比较熟悉的话，理解本模式会十分轻松。
+这句话包含两层意思：一是需要遍历的对象，即聚集对象，二是迭代器对象，用于对聚集对象进行遍历访问。
 
 `MyCollection`中定义了集合的一些操作，`MyIterator`中定义了一系列迭代操作，且持有`Collection`实例，我们来看看实现代码:   
 
@@ -1321,7 +1395,7 @@ public class MyIterator implements Iterator {
   
     @Override  
     public Object next() {  
-        if(pos<collection.size()-1){  
+        if(pos < collection.size()-1){  
             pos++;  
         }  
         return collection.get(pos);  
@@ -1329,7 +1403,7 @@ public class MyIterator implements Iterator {
   
     @Override  
     public boolean hasNext() {  
-        if(pos<collection.size()-1){  
+        if(pos < collection.size()-1){  
             return true;  
         }else{  
             return false;  
@@ -1361,16 +1435,23 @@ public static void main(String[] args) {
 A B C D E
 ```
 
-foreach是Java5中引入的一种for的语法增强。如果我们对class文件进行反编译就会发现，对Collection接口的各种实现类来说，foreach本质上还是通过获取迭代器(Iterator)来遍历的。
+foreach是Java5中引入的一种for的语法增强。如果我们对class文件进行反编译就会发现，对Collection接口的各种实现类来说，
+foreach本质上还是通过获取迭代器(Iterator)来遍历的。
 
-对于任何类型的集合，要防止内部机制不被暴露或破坏，以及确保用户对每个元素有足够的访问权限，迭代器模式起到了至关重要的作用。迭代器巧妙地利用了内部类的形式与集合类分离，然则“藕断丝连”，迭代器依然对其内部的元素保有访问权限，如此便促成了集合的完美封装，在此基础上还提供给用户一套标准的迭代器接口，使各种繁杂的遍历方式得以统一。迭代器模式的应用，能在内部事务不受干涉的前提下，保持一定的对外部开放，让我们“鱼与熊掌兼得”。
+对于任何类型的集合，要防止内部机制不被暴露或破坏，以及确保用户对每个元素有足够的访问权限，迭代器模式起到了至关重要的作用。
+迭代器巧妙地利用了内部类的形式与集合类分离，迭代器依然对其内部的元素保有访问权限，如此便促成了集合的完美封装，在此基础上还提供给用户一套标准的
+迭代器接口，使各种繁杂的遍历方式得以统一。迭代器模式的应用，能在内部事务不受干涉的前提下，保持一定的对外部开放，让我们“鱼与熊掌兼得”。
 
 责任链模式`(Chain of Responsibility)`
 ---
 
-责任链是由很多责任节点串联起来的一条任务链条，其中每一个责任节点都是一个业务处理环节。责任链模式(Chain ofResponsibility)允许业务请求者将责任链视为一个整体并对其发起请求，而不必关心链条内部具体的业务逻辑与流程走向，也就是说，请求者不必关心具体是哪个节点起了作用，总之业务最终能得到相应的处理。在软件系统中，当一个业务需要经历一系列业务对象去处理时，我们可以把这些业务对象串联起来成为一条业务责任链，请求者可以直接通过访问业务责任链来完成业务的处理，最终实现请求者与响应者的解耦。
+责任链是由很多责任节点串联起来的一条任务链条，其中每一个责任节点都是一个业务处理环节。责任链模式允许业务请求者将责任链视为一个整体并对其发起请求，
+而不必关心链条内部具体的业务逻辑与流程走向，也就是说，请求者不必关心具体是哪个节点起了作用，总之业务最终能得到相应的处理。在软件系统中，当一个
+业务需要经历一系列业务对象去处理时，我们可以把这些业务对象串联起来成为一条业务责任链，请求者可以直接通过访问业务责任链来完成业务的处理，最终实现
+请求者与响应者的解耦。
 
-有多个对象，每个对象持有对下一个对象的引用，这样就会形成一条链，请求在这条链上传递，直到某一对象决定处理该请求。但是发出者并不清楚到底最终那个对象会处理该请求，所以，责任链模式可以实现，在隐瞒客户端的情况下，对系统进行动态的调整。先看看关系图：
+有多个对象，每个对象持有对下一个对象的引用，这样就会形成一条链，请求在这条链上传递，直到某一对象决定处理该请求。但是发出者并不清楚到底最终那个对
+象会处理该请求，所以，责任链模式可以实现，在隐瞒客户端的情况下，对系统进行动态的调整。先看看关系图：
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/zerenlian.jpg?raw=true)  
 
@@ -1430,19 +1511,19 @@ h1deal!
 h2deal!
 h3deal!
 ```
-链接上的请求可以是一条链，可以是一个树，还可以是一个环，模式本身不约束这个，需要我们自己去实现，同时，在一个时刻，命令只允许由一个对象传给另一个对象，而不允许传给多个对象。
-
-
+链接上的请求可以是一条链，可以是一个树，还可以是一个环，模式本身不约束这个，需要我们自己去实现，同时，在一个时刻，命令只允许由一个对象传给另一个
+对象，而不允许传给多个对象。
 
 命令模式`(Command)`
 ---
 
-
-命令模式很好理解，举个例子，司令员下令让士兵去干件事情，从整个事情的角度来考虑，司令员的作用是，发出口令，口令经过传递，传到了士兵耳朵里，士兵去执行。这个过程好在，三者相互解耦，任何一方都不用去依赖其他人，只需要做好自己的事儿就行，司令员要的是结果，不会去关注到底士兵是怎么实现的。我们看看关系图：
+命令模式很好理解，举个例子，司令员下令让士兵去干件事情，从整个事情的角度来考虑，司令员的作用是，发出口令，口令经过传递，传到了士兵耳朵里，
+士兵去执行。这个过程好在，三者相互解耦，任何一方都不用去依赖其他人，只需要做好自己的事儿就行，司令员要的是结果，不会去关注到底士兵是怎么实现的。
+我们看看关系图：
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/command.jpg?raw=true)  
 
-`Invoker`是调用者（司令员），`Receiver`是被调用者（士兵），`MyCommand`是命令，实现了`Command`接口，持有接收对象，看实现代码:    
+`Invoker`是调用者（司令员），`Receiver`是被调用者（士兵），`MyCommand`是命令，实现了`Command`接口，持有接收对象，实现代码:    
 
 ```java
 public interface Command {  
@@ -1488,20 +1569,23 @@ public static void main(String[] args) {
 }  
 ```
 
-命令模式的目的就是达到命令的发出者和执行者之间解耦，实现请求和执行分开，熟悉`Struts`的同学应该知道，`Struts`其实就是一种将请求和呈现分离的技术，其中必然涉及命令模式的思想！
+命令模式的目的就是达到命令的发出者和执行者之间解耦，实现请求和执行分开，熟悉`Struts`的同学应该知道，`Struts`其实就是一种将请求和呈现分离的
+技术，其中必然涉及命令模式的思想！
 
 
 备忘录模式`(Memento)`
 ---
 
-备忘录用来记录曾经发生过的事情，使回溯历史变得切实可行。备忘录模式(Memento)则可以在不破坏元对象封装性的前提下捕获其在某些时刻的内部状态，并像历史快照一样将它们保留在元对象之外，以备恢复之用。
-
-主要目的是保存一个对象的某个状态，以便在适当的时候恢复对象，个人觉得叫备份模式更形象些，通俗的讲下：假设有原始类A，A中有各种属性，A可以决定需要备份的属性，备忘录类B是用来存储A的一些内部状态，类C呢，就是一个用来存储备忘录的，且只能存储，不能修改等操作。做个图来分析一下：
+备忘录用来记录曾经发生过的事情，使回溯历史变得切实可行。备忘录模式则可以在不破坏元对象封装性的前提下捕获其在某些时刻的内部状态，并像历史快照一样
+将它们保留在元对象之外，以备恢复之用。
 
+主要目的是保存一个对象的某个状态，以便在适当的时候恢复对象，个人觉得叫备份模式更形象些，通俗的讲下：假设有原始类A，A中有各种属性，A可以决定需要
+备份的属性，备忘录类B是用来存储A的一些内部状态，类C呢，就是一个用来存储备忘录的，且只能存储，不能修改等操作。做个图来分析一下：
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/memento.jpg?raw=true)  
 
-`Original`类是原始类，里面有需要保存的属性`value`及创建一个备忘录类，用来保存`value`值。`Memento`类是备忘录类，`Storage`类是存储备忘录的类，持有`Memento`类的实例，该模式很好理解。直接看源码：
+`Original`类是原始类，里面有需要保存的属性`value`及创建一个备忘录类，用来保存`value`值。`Memento`类是备忘录类，`Storage`类是存储备忘录
+的类，持有`Memento`类的实例，该模式很好理解。直接看源码：
 
 ```java
 public class Original {  
@@ -1584,16 +1668,18 @@ public static void main(String[] args) {
 修改后的状态为：niu
 恢复后的状态为：egg 
 ```
-新建原始类时，`value`被初始化为`egg`，后经过修改，将`value`的值置为`niu`，最后倒数第二行进行恢复状态，结果成功恢复了。其实我觉得这个模式叫“备份-恢复”模式最形象。
+新建原始类时，`value`被初始化为`egg`，后经过修改，将`value`的值置为`niu`，最后倒数第二行进行恢复状态，结果成功恢复了。
+其实我觉得这个模式叫“备份-恢复”模式最形象。
 
 
 状态模式`(State)`
 ---
 
-状态指事物基于所处的状况、形态表现出的不同的行为特性。状态模式(State)构架出一套完备的事物内部状态转换机制，并将内部状态包裹起来且对外部不可见，使其行为能随其状态的改变而改变，同时简化了事物的复杂的状态变化逻辑。
+状态指事物基于所处的状况、形态表现出的不同的行为特性。状态模式构架出一套完备的事物内部状态转换机制，并将内部状态包裹起来且对外部不可见，
+使其行为能随其状态的改变而改变，同时简化了事物的复杂的状态变化逻辑。
 
-
-核心思想就是:当对象的状态改变时，同时改变其行为，很好理解！就拿QQ来说，有几种状态，在线、隐身、忙碌等，每个状态对应不同的操作，而且你的好友也能看到你的状态，所以，状态模式就两点:       
+核心思想就是:当对象的状态改变时，同时改变其行为，很好理解！就拿QQ来说，有几种状态，在线、隐身、忙碌等，每个状态对应不同的操作，
+而且你的好友也能看到你的状态，所以，状态模式就两点:       
 
 - 可以通过改变状态来获得不同的行为
 - 你的好友能同时看到你的变化
@@ -1601,8 +1687,6 @@ public static void main(String[] args) {
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/state.jpg?raw=true)  
 
-
-
 `State`类是个状态类，`Context`类可以实现切换，我们来看看代码:   
 
 ```java
@@ -1678,17 +1762,21 @@ execute the second opt!
 
 访问者模式`(Visitor)`
 ---
-访问者模式(Visitor)主要解决的是数据与算法的耦合问题，尤其是在数据结构比较稳定，而算法多变的情况下。为了不“污染”数据本身，访问者模式会将多种算法独立归类，并在访问数据时根据数据类型自动切换到对应的算法，实现数据的自动响应机制，并且确保算法的自由扩展。
+访问者模式主要解决的是数据与算法的耦合问题，尤其是在数据结构比较稳定，而算法多变的情况下。为了不“污染”数据本身，访问者模式会将多种算法独立归类，
+并在访问数据时根据数据类型自动切换到对应的算法，实现数据的自动响应机制，并且确保算法的自由扩展。
 
-访问者模式把数据结构和作用于结构上的操作解耦合，使得操作集合可相对自由地演化。访问者模式适用于数据结构相对稳定算法又易变化的系统。因为访问者模式使得算法操作增加变得容易。若系统数据结构对象易于变化，经常有新的数据对象增加进来，则不适合使用访问者模式。访问者模式的优点是增加操作很容易，因为增加操作意味着增加新的访问者。访问者模式将有关行为集中到一个访问者对象中，其改变不影响系统数据结构。其缺点就是增加新的数据结构很困难。
+访问者模式把数据结构和作用于结构上的操作解耦合，使得操作集合可相对自由地演化。访问者模式适用于数据结构相对稳定算法又易变化的系统。因为访问者模式
+使的算法操作增加变的容易。若系统数据结构对象易于变化，经常有新的数据对象增加进来，则不适合使用访问者模式。访问者模式的优点是增加操作很容易，
+因为增加操作意味着增加新的访问者。访问者模式将有关行为集中到一个访问者对象中，其改变不影响系统数据结构。其缺点就是增加新的数据结构很困难。
 
 简单来说，访问者模式就是一种分离对象数据结构与行为的方法，通过这种分离，可达到为一个被访问者动态添加新的操作而无需做其它的修改的效果。
 
 示例:银行柜台提供的服务和来办业务的人。把银行的服务和业务的办理解耦了。
-缺点：如果银行要修改底层业务接口，所有继承接口的类都需要作出修改。不过java8的新特性接口默认方法可以解决这个问题，或者java8之前可以通过接口的适配器模式来解决这个问题。   
+缺点：如果银行要修改底层业务接口，所有继承接口的类都需要作出修改。不过java8的新特性接口默认方法可以解决这个问题，或者java8之前可以通过接口的
+适配器模式来解决这个问题。   
 
 ```java
-	// 银行柜台服务，以后银行要新增业务，只需要新增一个类实现这个接口就可以了。
+    // 银行柜台服务，以后银行要新增业务，只需要新增一个类实现这个接口就可以了。
     public interface Service {
         void accept(Visitor visitor);
     }
@@ -1764,12 +1852,12 @@ execute the second opt!
 中介者模式`(Mediator)`
 ---
 
-中介是在事物之间传播信息的中间媒介。中介模式(Mediator)为对象构架出一个互动平台，通过减少对象间的依赖程度以达到解耦的目的。我们的生活中有各种各样的媒介，如婚介所、房产中介、门户网站、电子商务、交换机组网、通信基站、即时通软件等，这些都与人类的生活息息相关，离开它们我们将举步维艰。
+中介是在事物之间传播信息的中间媒介。中介模式为对象构架出一个互动平台，通过减少对象间的依赖程度以达到解耦的目的。我们的生活中有各种各样的媒介，
+如婚介所、房产中介、门户网站、电子商务、交换机组网、通信基站、即时通软件等，这些都与人类的生活息息相关，离开它们我们将举步维艰。
 
 中介者模式也是用来降低类类之间的耦合的，因为如果类类之间有依赖关系的话，不利于功能的拓展和维护，因为只要修改一个对象，其它关联的对象都得进行修改。
 如果使用中介者模式，只需关心和`Mediator`类的关系，具体类类之间的关系及调度交给`Mediator`就行，这有点像`spring`容器的作用。
 
-
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/mediator.jpg?raw=true)  
 
 `User`类统一接口，`User1`和`User2`分别是不同的对象，二者之间有关联，如果不采用中介者模式，则需要二者相互持有引用，这样二者的耦合度很高，为了解耦，
@@ -1858,23 +1946,25 @@ public static void main(String[] args) {
     // user2 exe!
 }  
 ```
-众所周知，对象间显式的互相引用越多，意味着依赖性越强，同时独立性越弱，不利于代码的维护与扩展。中介模式很好地解决了这些问题，它能将多方互动的工作交由中间平台去完成，解除了你中有我、我中有你的相互依赖，让各个模块之间的关系变得更加松散、独立，最终增强系统的可复用性与可扩展性，同时也使系统运行效率得到提升。
-
-
+众所周知，对象间显式的互相引用越多，意味着依赖性越强，同时独立性越弱，不利于代码的维护与扩展。中介模式很好地解决了这些问题，它能将多方互动的工作
+交由中间平台去完成，解除了你中有我、我中有你的相互依赖，让各个模块之间的关系变得更加松散、独立，最终增强系统的可复用性与可扩展性，同时也使系统
+运行效率得到提升。
 
 解释器模式`(Interpreter)`
 ---
 
-解释有拆解、释义的意思，一般可以理解为针对某段文字，按照其语言的特定语法进行解析，再以另一种表达形式表达出来，以达到人们能够理解的目的。类似地，解释器模式(Interpreter)会针对某种语言并基于其语法特征创建一系列的表达式类（包括终极表达式与非终极表达式），利用树结构模式将表达式对象组装起来，最终将其翻译成计算机能够识别并执行的语义树。例如结构型数据库对查询语言SQL的解析，浏览器对HTML语言的解析，以及操作系统Shell对命令的解析。不同的语言有着不同的语法和翻译方式，这都依靠解释器完成。以最常见的Java编程语言为例。当我们以人类能够理解的语言完成了一段程序并命名为Hello.java后，经过调用编译器会生成Hello.class的字节码文件，执行的时候则会加载此文件到内存并进行解释、执行，最终被解释的机器码才是计算机可以理解并执行的指令格式，如下图所示。从Java语言到机器语言，这个跨越语言鸿沟的翻译步骤必须由解释器来完成，这便是其存在的意义： 
+解释有拆解、释义的意思，一般可以理解为针对某段文字，按照其语言的特定语法进行解析，再以另一种表达形式表达出来，以达到人们能够理解的目的。类似地，
+解释器模式(Interpreter)会针对某种语言并基于其语法特征创建一系列的表达式类（包括终极表达式与非终极表达式），利用树结构模式将表达式对象组装起来，
+最终将其翻译成计算机能够识别并执行的语义树。例如结构型数据库对查询语言SQL的解析，浏览器对HTML语言的解析，以及操作系统Shell对命令的解析。
+不同的语言有着不同的语法和翻译方式，这都依靠解释器完成。以最常见的Java编程语言为例。当我们以人类能够理解的语言完成了一段程序并命名为
+Hello.java后，经过调用编译器会生成Hello.class的字节码文件，执行的时候则会加载此文件到内存并进行解释、执行，最终被解释的机器码才是计算机可以
+理解并执行的指令格式，如下图所示。从Java语言到机器语言，这个跨越语言鸿沟的翻译步骤必须由解释器来完成，这便是其存在的意义： 
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/design_mode_jieshiqi.png?raw=true)     
 
-
 解释器模式是我们暂时的最后一讲，一般主要应用在`OOP`开发中的编译器的开发中，所以适用面比较窄。
 
-
-![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/interpreter.jpg?raw=true)  
-
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/interpreter.jpg?raw=true)
 
 `Context`类是一个上下文环境类，`Plus`和`Minus`分别是用来计算的实现，代码如下:   
 
@@ -1933,19 +2023,12 @@ public static void main(String[] args) {
 ```
 基本就这样，解释器模式用来做各种各样的解释器，如正则表达式等的解释器等等！
 
+在面向对象的软件设计中，人们经常会遇到一些重复出现的问题。为降低软件模块的耦合性，提高软件的灵活性、兼容性、可复用性、可维护性与可扩展性，
+人们从宏观到微观对各种软件系统进行拆分、抽象、组装，确立模块间的交互关系，最终通过归纳、总结，将一些软件模式沉淀下来成为通用的解决方案，
+这就是设计模式的由来与发展。
 
-
-在面向对象的软件设计中，人们经常会遇到一些重复出现的问题。为降低软件模块的耦合性，提高软件的灵活性、兼容性、可复用性、可维护性与可扩展性，人们从宏观到微观对各种软件系统进行拆分、抽象、组装，确立模块间的交互关系，最终通过归纳、总结，将一些软件模式沉淀下来成为通用的解决方案，这就是设计模式的由来与发展。
-
-
-
-
-
-
-
-		
 ---
 - 邮箱 ：charon.chui@gmail.com  
 - Good Luck! 
 
-	
+    

From 375ba0bc5e2a50eb2e79a01c69c5798292951094 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 9 Mar 2023 15:28:51 +0800
Subject: [PATCH 095/213] update notes

---
 ...00\351\235\242\350\257\225\351\242\230.md" |  2 +-
 .../Bitmap\344\274\230\345\214\226.md"        |  8 ++---
 .../Fragment\344\270\223\351\242\230.md"      |  2 +-
 .../Scroller\347\256\200\344\273\213.md"      |  4 +--
 ...05\345\255\230\346\250\241\345\236\213.md" | 29 ++++---------------
 5 files changed, 13 insertions(+), 32 deletions(-)

diff --git "a/BasicKnowledge/Android\345\237\272\347\241\200\351\235\242\350\257\225\351\242\230.md" "b/BasicKnowledge/Android\345\237\272\347\241\200\351\235\242\350\257\225\351\242\230.md"
index f5a864c6..319f5ef8 100644
--- "a/BasicKnowledge/Android\345\237\272\347\241\200\351\235\242\350\257\225\351\242\230.md"
+++ "b/BasicKnowledge/Android\345\237\272\347\241\200\351\235\242\350\257\225\351\242\230.md"
@@ -1,7 +1,7 @@
 Android基础面试题
 ===
 
-没有删这套题，虽然都是网上找的，在刚开始找工作的时候这套题帮了我很多，那时候`Android`刚起步，很多家都是这一套面试题，我都是直接去了不看题画画一顿就写完了，哈哈
+没有删这套题，虽然都是网上找的，在刚开始找工作的时候这套题帮了我很多，那时候`Android`刚起步，很多家都是这一套面试题，我都是直接去了不看题哗哗一顿就写完了，哈哈
 现在估计没有公司会用这种笔试题了。还是留下来吧，回忆一下。
 
 1. 下列哪些语句关于内存回收的说明是正确的? (b)          
diff --git "a/BasicKnowledge/Bitmap\344\274\230\345\214\226.md" "b/BasicKnowledge/Bitmap\344\274\230\345\214\226.md"
index c127bf68..42b7954b 100644
--- "a/BasicKnowledge/Bitmap\344\274\230\345\214\226.md"
+++ "b/BasicKnowledge/Bitmap\344\274\230\345\214\226.md"
@@ -3,9 +3,9 @@ Bitmap优化
 
 1. 一个进程的内存可以由2个部分组成：`native和dalvik`
     `dalvik`就是我们平常说的`java`堆，我们创建的对象是在这里面分配的，而`bitmap`是直接在`native`上分配的。   
-    一旦内存分配给`Java`后，以后这块内存即使释放后，也只能给`Java`的使用，所以如果`Java`突然占用了一个大块内存，
+    一旦内存分配给`Java`后，以后这块内存即使释放后，也只能给`Java`使用，所以如果`Java`突然占用了一个大块内存，
 	即使很快释放了,`C`能用的内存也是16M减去`Java`最大占用的内存数。
-    而`Bitmap`的生成是通过`malloc`进行内存分配的，占用的是`C`的内存，这个也就说明了，上述的`4MBitmap`无法生成的原因，
+    而`Bitmap`的生成是通过`malloc`进行内存分配的，占用的是`C`的内存，这个也就说明了，有时候`4MBitmap`无法生成的原因，
 	因为在`13M`被`Java`用过后，剩下`C`能用的只有`3M`了。    
 
 2. 在`Android`应用里，最耗费内存的就是图片资源。    
@@ -58,7 +58,7 @@ Bitmap优化
     // 打印出图片的宽和高
     Log.d("example", opts.outWidth + "," + opts.outHeight);
     ```
-    在实际项目中，可以利用上面的代码，先获取图片真实的宽度和高度，然后判断是否需要跑缩小。如果不需要缩小，设置inSampleSize的值为1。如果需要缩小，则动态计算并设置inSampleSize的值，对图片进行缩小。需要注意的是，在下次使用BitmapFactory的decodeFile()等方法实例化Bitmap对象前，别忘记将opts.inJustDecodeBound设置回false。否则获取的bitmap对象还是null。
+    在实际项目中，可以利用上面的代码，先获取图片真实的宽度和高度，然后判断是否需要缩小。如果不需要缩小，设置inSampleSize的值为1。如果需要缩小，则动态计算并设置inSampleSize的值，对图片进行缩小。需要注意的是，在下次使用BitmapFactory的decodeFile()等方法实例化Bitmap对象前，别忘记将opts.inJustDecodeBound设置回false。否则获取的bitmap对象还是null。
 
     以从Gallery获取一个图片为例讲解缩放:   
     ```java
@@ -134,4 +134,4 @@ Bitmap优化
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/BasicKnowledge/Fragment\344\270\223\351\242\230.md" "b/BasicKnowledge/Fragment\344\270\223\351\242\230.md"
index d3d89ad8..81ceb228 100644
--- "a/BasicKnowledge/Fragment\344\270\223\351\242\230.md"
+++ "b/BasicKnowledge/Fragment\344\270\223\351\242\230.md"
@@ -334,4 +334,4 @@ public abstract class BaseFragment extends Fragment {
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/BasicKnowledge/Scroller\347\256\200\344\273\213.md" "b/BasicKnowledge/Scroller\347\256\200\344\273\213.md"
index 8ed68bfa..bfa12941 100644
--- "a/BasicKnowledge/Scroller\347\256\200\344\273\213.md"
+++ "b/BasicKnowledge/Scroller\347\256\200\344\273\213.md"
@@ -29,8 +29,8 @@ Scroller简介
     public void computeScroll() {
     }
     ```
-    通过注释我们可以看到该方法又父类调用根据滚动的值去更新`View`，在使用`Scroller`的时候通常都要实现该方法。来达到子`View`的滚动效果。      
-	继续往下跟发现在`draw()`方法中回去调用`computeScroll()`，而`draw()`方法会在父布局调用`drawChild()`的时候使用。
+    通过注释我们可以看到该方法由父类调用根据滚动的值去更新`View`，在使用`Scroller`的时候通常都要实现该方法。来达到子`View`的滚动效果。      
+	继续往下跟发现在`draw()`方法中会去调用`computeScroll()`，而`draw()`方法会在父布局调用`drawChild()`的时候使用。
 
 3. 具体关联   
     通过上面两步大体能得到`Scroller`与`View`的移动要通过`computeScroll()`来完成，但是在究竟如何进行代码实现。     
diff --git "a/JavaKnowledge/Java\345\206\205\345\255\230\346\250\241\345\236\213.md" "b/JavaKnowledge/Java\345\206\205\345\255\230\346\250\241\345\236\213.md"
index 1e2fae6a..8e75224f 100644
--- "a/JavaKnowledge/Java\345\206\205\345\255\230\346\250\241\345\236\213.md"
+++ "b/JavaKnowledge/Java\345\206\205\345\255\230\346\250\241\345\236\213.md"
@@ -28,11 +28,9 @@ Stack Memory、Method Area、PC、Native Stack Memory)，这些区域都有各
 - 堆内存在JVM启动的时候被加载(初始大小: -Xms)
 - 堆内存在程序运行时会增加或减少
 - 最小值: -Xmx
-- 从结构上来分，可以分为新生代和老年代。而新生代又可以分为Eden空间、From Survivor空间（s0）、To Survivor空间（s1）。 所有新生成的对象首先
-    都是放在新生代的。需要注意，Survivor的两个区是对称的，没先后关系，所以同一个区中可能同时存在从Eden复制过来的对象，和从前一个Survivor复制
-    过来的对象，而复制到老年代的只有从第一个Survivor区过来的对象。而且，Survivor区总有一个是空的。
+- 从结构上来分，可以分为新生代和老年代。而新生代又可以分为Eden空间、From Survivor空间（s0）、To Survivor空间（s1）。 所有新生成的对象首先都是放在新生代的。需要注意，Survivor的两个区是对称的，没先后关系，所以同一个区中可能同时存在从Eden复制过来的对象，和从前一个Survivor复制过来的对象，而复制到老年代的只有从第一个Survivor区过来的对象。而且，Survivor区总有一个是空的。
 
-  ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/jvm_heap_memory.png)
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/jvm_heap_memory.png)
 
 在并发编程中，多个线程之间采取什么机制进行通信（信息交换），什么机制进行数据的同步？在Java语言中，采用的是共享内存模型来实现多线程之间的信息交换和数据同步的。
 
@@ -44,10 +42,9 @@ Stack Memory、Method Area、PC、Native Stack Memory)，这些区域都有各
 
 每当一个方法执行完成时，该栈帧就会弹出栈帧的元素作为这个方法的返回值，并且清除这个栈帧，Java栈的栈顶的栈帧就是当前正在执行的活动栈，也就是当前正在执行的方法，PC寄存器也会指向该地址。只有这个活动的栈帧的本地变量可以被操作栈使用，当在这个栈帧中调用另外一个方法时，与之对应的一个新的栈帧被创建，这个新创建的栈帧被放到Java栈的栈顶，变为当前的活动栈。同样现在只有这个栈的本地变量才能被使用，当这个栈帧中所有指令都完成时，这个栈帧被移除Java栈，刚才的那个栈帧变为活动栈帧，前面栈帧的返回值变为这个栈帧的操作栈的一个操作数。
 
-
-
 线程stack中同样会包含该线程调用栈中所有方法执行所需要的本地变量，一个线程只能获取到它自己对应的线程stack。一个线程创建的本地变量对于其他任何线程都是不可见的。即使两个线程执行完全相同的代码，这两个线程仍然会在各自自己对应的线程stack中创建自己的本地变量。
 所有基础类型的局部变量(boolean,byte,short,char,int,long,float,double)都被保存在自己的线程stack中。一个线程可以将一个基础变量的副本传递给另一个线程，但是它不能共享原始局部变量本身。    
+
 堆内存包含在Java应用程序中创建的所有对象，而不管创建该对象的线程是什么。这包括基本类型的对象版本（例如Byte，Integer，Long等）。创建对象并将其分配给局部变量，或者将其创建为另一个对象的成员变量都没有关系，该对象仍存储在堆中。
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/java-memory-model-1.png)
 
@@ -60,12 +57,10 @@ Stack Memory、Method Area、PC、Native Stack Memory)，这些区域都有各
 - 静态类变量也与类定义一起存储在堆中。    
 - 引用对象的所有线程都可以访问堆上的对象。当线程可以访问对象时，它也可以访问该对象的成员变量。如果两个线程同时在同一个对象上调用一个方法，则它们都将有权访问该对象的成员变量，但是每个线程将拥有自己的局部变量副本。
 
-
-
 Java 虚拟机栈会出现两种异常：StackOverFlowError 和 OutOfMemoryError： 
 
 - StackOverFlowError： 若Java虚拟机栈的内存大小不允许动态扩展，那么当线程请求栈的深度超过当前Java虚拟机栈的最大深度的时候，就抛出StackOverFlowError异常。
-- OutOfMemoryError： 若 Java 虚拟机栈的内存大小允许动态扩展，且当线程请求栈时内存用完了，无法再动态扩展了，此时抛出OutOfMemoryError异常。
+- OutOfMemoryError： 若Java虚拟机栈的内存大小允许动态扩展，且当线程请求栈时内存用完了，无法再动态扩展了，此时抛出OutOfMemoryError异常。
 
 ## Method Area
 
@@ -91,8 +86,6 @@ Java 虚拟机栈会出现两种异常：StackOverFlowError 和 OutOfMemoryError
 
 常量池中存储了如字符串、final变量值、类名和方法名常量。常量池在编译期间就被确定，并保存在已编译的.class文件中。一般分为两类：字面量和应用量。字面量就是字符串、final变量等。类名和方法名属于引用量。引用量最常见的是在调用方法的时候，根据方法名找到方法的引用，并以此定为到函数体进行函数代码的执行。引用量包含：类和接口的权限定名、字段的名称和描述符，方法的名称和描述符。
 
-
-
 JVM会加载、链接、初始化class文件。一个class文件会把其所有所有符号引用都保留在一个位置，即常量池中。 
 
 每个class文件都会有一个对应constant pool。但是class文件中的常量池显然是不够的，因为需要再JVM上执行。这种情况下，需要runtime constant pool来服务JVM的运行。
@@ -136,21 +129,17 @@ Double i4 = 1.2;
 System.out.println(i3 == i4);// 输出false
 ```
 
-
-
 ### Method Area & Constant Pool改动
 
 很多人愿意把方法区称为“永久代”（Permanent Generation），本质上两者并不等价，仅仅是因为HotSpot虚拟机的设计团队选择把GC 分代收集扩展至方法区，或者说使用永久代来实现方法区而已。对于其他虚拟机（如BEA JRockit、IBM J9 等）来说是不存在永久代的概念的。
 
-
-
 在JDK1.7中，将字符串常量池和静态变量从方法区域中移到堆中，其余的运行时常量池仍在方法区域中，即hotspot中的永久生成。 所有的被intern的String被存储在PermGen区.PermGen区使用-XX:MaxPermSize=N来设置最大大小，但是由于应用程序string.intern通常是不可预测和不可控的，因此不好设置这个大小。设置不好的话，常常会引起java.lang.OutOfMemoryError: PermGen space。
 
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/java7_method_constant_pool.jpg)
 
 在 JDK 1.8中移除整个永久代，取而代之的是一个叫元空间（Metaspace）的区域（永久代使用的是JVM的堆内存空间，而元空间使用的是物理内存，直接受到本机的物理内存限制）。string constant pool仍然还是在Heap内存中。runtime constant pool也仍然在方法区。但是方法区的实现已经改成使用Metaspace。 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/java8_memory_method.jpg)
 
-为什么要移除永久代，改为元空间嗯？ 
+为什么要移除永久代，改为元空间呢？ 
 
 > Metaspace与PermGen之间最大的区别在于：Metaspace并不在虚拟机中，而是使用本机内存。如果没有使用-XX:MaxMetaspaceSize来设置类的元数据的大小，其最大可利用空间是整个系统内存的可用空间。JVM也可以增加本地内存空间来满足类元数据信息的存储。
 > 但是如果没有设置最大值，则可能存在bug导致Metaspace的空间在不停的扩展，会导致机器的内存不足；进而可能出现swap内存被耗尽；最终导致进程直接被系统直接kill掉。
@@ -161,10 +150,6 @@ System.out.println(i3 == i4);// 输出false
 
 在很大程度上，这只是名称的更改。早在引入PermGen时，就没有Java EE或动态类的加载（取消加载），因此，一旦加载了一个类，该类便一直停留在内存中，直到JVM关闭为止，从而实现了永久生成。如今，可以在JVM的生命周期内加载和卸载类，因此对于保留元数据的区域，Metaspace更有意义。
 
-
-
-
-
 ## Native Method Stack
 
 本地方法栈和Java栈所发挥的作用非常相似，区别不过是Java栈为JVM执行Java方法服务，而本地方法栈为JVM执行Native方法服务。如Java使用c或c++编写的接口服务时，代码在此区运行，本地方法栈也会抛出StackOverflowError和OutOfMemoryError异常。
@@ -190,7 +175,6 @@ Java线程之间的通信由Java内存模型(JMM)控制，JMM决定一个线程
 
 ## 重排
 
-
 在执行程序时为了提高性能，编译器和处理器常常会对指令做重排序。
 
 这里说的重排序可以发生在好几个地方：编译器、运行时、JIT等，比如编译器会觉得把一个变量的写操作放在最后会更有效率，编译后，这个指令就在最后了（前提是只要不改变程序的语义，编译器、执行器就可以这样自由的随意优化），一旦编译器对某个变量的写操作进行优化（放到最后），那么在执行之前，另一个线程将不会看到这个执行结果。
@@ -213,8 +197,6 @@ Class Reordering {
 ```
 假设这段代码有2个线程并发执行，线程A执行writer方法，线程B执行reader方法，线程B看到y的值为2，因为把y设置成2发生在变量x的写入之后（代码层面），所以能断定线程B这时看到的x就是1吗？
 
-
-
 当然不行！因为在writer方法中，可能发生了重排序，y的写入动作可能发在x写入之前，这种情况下，线程B就有可能看到x的值还是0。
 
 在Java内存模型中，描述了在多线程代码中，哪些行为是正确的、合法的，以及多线程之间如何进行通信，代码中变量的读写行为如何反应到内存、CPU缓存的底层细节。
@@ -250,7 +232,6 @@ a是在栈内存中的，当main()方法执行结束，a就被清理了。但是
 - [Where Has the Java PermGen Gone?](https://www.infoq.com/articles/Java-PERMGEN-Removed/)
 
 
-​   
 ---
 - 邮箱 ：charon.chui@gmail.com  
 - Good Luck! 

From f834ce5534f7ad54be2aad95b3f5235c55407f2e Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 13 Mar 2023 21:46:33 +0800
Subject: [PATCH 096/213] update

---
 AdavancedPart/ApplicationId vs PackageName.md |  4 ++--
 ...11\345\205\250\351\227\256\351\242\230.md" |  4 ++--
 ...straintLaayout\347\256\200\344\273\213.md" |  7 +------
 ...345\217\212ANR\345\210\206\346\236\220.md" | 21 +------------------
 .../Zipalign\344\274\230\345\214\226.md"      |  2 +-
 ...mposing builds\347\256\200\344\273\213.md" |  2 +-
 ...57\345\212\250\350\277\207\347\250\213.md" |  6 ++----
 7 files changed, 10 insertions(+), 36 deletions(-)

diff --git a/AdavancedPart/ApplicationId vs PackageName.md b/AdavancedPart/ApplicationId vs PackageName.md
index 62829a21..35dc2f0a 100644
--- a/AdavancedPart/ApplicationId vs PackageName.md	
+++ b/AdavancedPart/ApplicationId vs PackageName.md	
@@ -7,7 +7,7 @@ ApplicationId vs PackageName
 
 在`Android`官方文档中有一句是这样描述`applicationId`的:`applicationId : the effective packageName`，真是言简意赅，那既然`applicationId`是有效的包明了，`packageName`算啥？     
 
-所有`Android`应用都有一个包名。包名在设备上能唯一的标示一个应用，它在`Google Play`应用商店中也是唯一的。这就意味着一旦你使用一个包名发布应用后，你就永 远不能改变它的包名；如果你改了包名就会导致你的应用被认为是一个新的应用，并且已经使用你之前应用的用户将不会看到作为更新的新应用包。          
+所有`Android`应用都有一个包名。包名在设备上能唯一的标识一个应用，它在`Google Play`应用商店中也是唯一的。这就意味着一旦你使用一个包名发布应用后，你就永 远不能改变它的包名；如果你改了包名就会导致你的应用被认为是一个新的应用，并且已经使用你之前应用的用户将不会看到作为更新的新应用包。          
 
 之前的`Android Gradle`构建系统中，应用的包名是由你的`manifest`文件中的根元素中的`package`属性定义的:       
  
@@ -86,4 +86,4 @@ buildTypes {
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/AdavancedPart/BroadcastReceiver\345\256\211\345\205\250\351\227\256\351\242\230.md" "b/AdavancedPart/BroadcastReceiver\345\256\211\345\205\250\351\227\256\351\242\230.md"
index 1485641a..0a6a7f1a 100644
--- "a/AdavancedPart/BroadcastReceiver\345\256\211\345\205\250\351\227\256\351\242\230.md"
+++ "b/AdavancedPart/BroadcastReceiver\345\256\211\345\205\250\351\227\256\351\242\230.md"
@@ -5,7 +5,7 @@ BroadcastReceiver安全问题
 - 保证发送的广播要发送给指定的对象      
     当应用程序发送某个广播时系统会将发送的`Intent`与系统中所有注册的`BroadcastReceiver`的`IntentFilter`进行匹配，若匹配成功则执行相应的`onReceive`函数。可以通过类似`sendBroadcast(Intent, String)`的接口在发送广播时指定接收者必须具备的`permission`或通过`Intent.setPackage`设置广播仅对某个程序有效。
 
-- 保证我接收到的广播室指定对象发送过来的    
+- 保证我接收到的广播是指定对象发送过来的    
     当应用程序注册了某个广播时，即便设置了`IntentFilter`还是会接收到来自其他应用程序的广播进行匹配判断。对于动态注册的广播可以通过类似`registerReceiver(BroadcastReceiver, IntentFilter, String, android.os.Handler)`的接口指定发送者必须具备的`permission`，对于静态注册的广播可以通过`android:exported="false"`属性表示接收者对外部应用程序不可用，即不接受来自外部的广播。
 
 `android.support.v4.content.LocalBroadcastManager`工具类，可以实现在自己的进程内进行局部广播发送与注册，使用它比直接通过sendBroadcast(Intent)发送系统全局广播有以下几个好处：
@@ -46,4 +46,4 @@ protected void onDestroy() {
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/AdavancedPart/ConstraintLaayout\347\256\200\344\273\213.md" "b/AdavancedPart/ConstraintLaayout\347\256\200\344\273\213.md"
index d765862d..f46d2dc2 100644
--- "a/AdavancedPart/ConstraintLaayout\347\256\200\344\273\213.md"
+++ "b/AdavancedPart/ConstraintLaayout\347\256\200\344\273\213.md"
@@ -224,15 +224,10 @@ implementation 'com.android.support.constraint:constraint-layout:1.1.0'
 它有点类似于`RelativeLayout`，但远比`RelativeLayout`要更强大。
 `ConstraintLayout`在测量/布局阶段的性能比 `RelativeLayout`大约高`40%`。      
 
-
-
-		
-
-
 - [Build a Responsive UI with ConstraintLayout](https://developer.android.com/training/constraint-layout/index.html)
 - [ConstraintLayout文档](https://developer.android.com/reference/android/support/constraint/package-summary.html)
 
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/AdavancedPart/Crash\345\217\212ANR\345\210\206\346\236\220.md" "b/AdavancedPart/Crash\345\217\212ANR\345\210\206\346\236\220.md"
index 40db0adf..df4d8ccf 100644
--- "a/AdavancedPart/Crash\345\217\212ANR\345\210\206\346\236\220.md"
+++ "b/AdavancedPart/Crash\345\217\212ANR\345\210\206\346\236\220.md"
@@ -15,7 +15,7 @@
 6、再执行handleAppCrashLocked方法：
 
 当1分钟内同一进程连续crash两次时，且非persistent进程，则直接结束该应用所有activity，并杀死该进程以及同一个进程组下的所有进程。然后再恢复栈顶第一个非finishing状态的activity;
-当1分钟内同一进程连续crash两次时，且persistent进程，，则只执行恢复栈顶第一个非finishing状态的activity;
+当1分钟内同一进程连续crash两次时，且persistent进程，则只执行恢复栈顶第一个非finishing状态的activity;
 当1分钟内同一进程未发生连续crash两次时，则执行结束栈顶正在运行activity的流程。
 
 7、通过mUiHandler发送消息SHOW_ERROR_MSG，弹出crash对话框；
@@ -35,10 +35,6 @@
 
 
 
-
-
-
-
 Native Crash
 
     崩溃过程：native crash 时操作系统会向进程发送信号，崩溃信息会写入到 data/tombstones 下，并在 logcat 输出崩溃日志
@@ -70,10 +66,8 @@ ANR排查流程
 1、Log获取
 1、抓取bugreport
 adb shell bugreport > bugreport.txt
-复制代码
 2、直接导出/data/anr/traces.txt文件
 adb pull /data/anr/traces.txt trace.txt
-复制代码
 2、搜索“ANR in”处log关键点解读
 
 
@@ -102,7 +96,6 @@ CPU usage from 18101ms to 0ms ago
 如果CPU使用量很少，说明主线程可能阻塞。
 3、在bugreport.txt中根据pid和发生时间搜索到阻塞的log处
 ----- pid 10494 at 2019-11-18 15:28:29 -----
-复制代码
 4、往下翻找到“main”线程则可看到对应的阻塞log
 "main" prio=5 tid=1 Sleeping
 | group="main" sCount=1 dsCount=0 flags=1 obj=0x746bf7f0 self=0xe7c8f000
@@ -110,7 +103,6 @@ CPU usage from 18101ms to 0ms ago
 | state=S schedstat=( 5119636327 325064933 4204 ) utm=460 stm=51 core=4 HZ=100
 | stack=0xff575000-0xff577000 stackSize=8MB
 | held mutexes=
-复制代码
 上述关键字段的含义如下所示：
 
 tid：线程号
@@ -123,14 +115,3 @@ stm：该线程在内核态的执行时间(jiffies)
 sCount：该线程被挂起的次数
 dsCount：该线程被调试器挂起的次数
 self：线程本身的地址
-
-
-
-
-
-
-
-
-
-
-
diff --git "a/AppPublish/Zipalign\344\274\230\345\214\226.md" "b/AppPublish/Zipalign\344\274\230\345\214\226.md"
index f79fa2cc..c69dedfa 100644
--- "a/AppPublish/Zipalign\344\274\230\345\214\226.md"
+++ "b/AppPublish/Zipalign\344\274\230\345\214\226.md"
@@ -22,7 +22,7 @@ And any files added to an "aligned" archive will not be aligned.
 ```
 
 大意就是它提供了一个灰常重要滴功能来确保所有未压缩的数据都从文件的开始位置以指定的4字节对齐方式排列，例如图片或者
-`raw`文件。当然好处也是大大的，就是能够减少内存的资源消耗。最后他还特意提醒了你一下就是已经在对`apk`签完名之后再用`zipalign`
+`raw`文件。当然好处也是大大的，就是能够减少内存的资源消耗。最后他还特意提醒了你一下就是一定在对`apk`签完名之后再用`zipalign`
 优化，如果你在之前用，那无效。
 
 废多看用法:      
diff --git "a/Gradle&Maven/Composing builds\347\256\200\344\273\213.md" "b/Gradle&Maven/Composing builds\347\256\200\344\273\213.md"
index e4060a5d..0c6ea44b 100644
--- "a/Gradle&Maven/Composing builds\347\256\200\344\273\213.md"	
+++ "b/Gradle&Maven/Composing builds\347\256\200\344\273\213.md"	
@@ -293,7 +293,7 @@ gradlePlugin {
 
 3. 在versionPlugin/src/main/java/包名/目录下新建Deps.kt文件，添加你的依赖配置，如：
 
-```groovy
+```kotlin
 package com.xx.xx.versionplugin
 
 class Deps : Plugin<Project> {
diff --git "a/SourceAnalysis/Activity\345\220\257\345\212\250\350\277\207\347\250\213.md" "b/SourceAnalysis/Activity\345\220\257\345\212\250\350\277\207\347\250\213.md"
index 8af22363..5750685e 100644
--- "a/SourceAnalysis/Activity\345\220\257\345\212\250\350\277\207\347\250\213.md"
+++ "b/SourceAnalysis/Activity\345\220\257\345\212\250\350\277\207\347\250\213.md"
@@ -8,7 +8,7 @@ Activity启动过程
 
 今天就来分析一下，我们开启`Activity`主要有两种方式:    
 
-- 通过桌面图标启动，桌面就是`Launcher`其实他也是一个应用程序，他也是继承`Activity`。
+- 通过桌面图标启动，桌面就是`Launcher`,其实他也是一个应用程序，他也是继承`Activity`。
 - 在程序内部调用`startActivity()`开启。
 
 而`Launcher`点击图标其实也是调用了`Activity`的`startActivity()`方法，所以我们就从`startActivity()`方法入手了。     
@@ -141,9 +141,7 @@ public class Instrumentation {
 	...
 }
 ```
-放狗查了下`Instrumentation`的意思是仪器、工具、装置的意思。我就大体翻一下(英语不好- -~，可能不准确)该类是实现应用程序代码的基类，当该类在
-启动的状态下运行时，该类会在其他任何应用程序运行前进行初始化，允许你件事所有应用程序与系统的交互。一个`Instrumentation`实例会通过`Manifest`文件
-中的`<instrumenttation`标签描述给系统。        
+放狗查了下`Instrumentation`的意思是仪器、工具、装置的意思。我就大体翻一下:该类是实现应用程序代码的基类，当该在启动的状态下运行时，该类会在其他任何应用程序运行前进行初始化，允许你监视所有应用程序与系统的交互。一个`Instrumentation`实例会通过`Manifest`文件中的`<instrumenttation`标签描述给系统。        
 所以继续看一下`mInstrumentation.execStartActivity()`:       
 ```java
 /**

From 808844f412036b6f84f13732372834cadfd0761c Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 16 Mar 2023 22:08:58 +0800
Subject: [PATCH 097/213] update file

---
 ...07\347\250\213\350\257\246\350\247\243.md" |  6 +--
 ...06\345\217\221\350\257\246\350\247\243.md" | 38 +++++++++---------
 .../AsyncTask\350\257\246\350\247\243.md"     | 40 +++++++++----------
 ...20\347\240\201\345\210\206\346\236\220.md" |  2 +-
 ...pURLConnection\350\257\246\350\247\243.md" | 22 +++++-----
 ...\350\257\246\350\247\243(\344\270\212).md" |  9 +++--
 ...\350\257\246\350\247\243(\344\270\213).md" | 10 ++---
 ...20\347\240\201\345\210\206\346\236\220.md" |  6 +--
 ...07\347\250\213\350\257\246\350\247\243.md" | 16 ++++----
 ...44\271\211View\350\257\246\350\247\243.md" | 10 ++---
 "VideoDevelopment/CDN\345\217\212PCDN.md"     |  8 ++--
 "VideoDevelopment/DNS\345\217\212HTTPDNS.md"  |  6 +--
 12 files changed, 88 insertions(+), 85 deletions(-)

diff --git "a/SourceAnalysis/Activity\347\225\214\351\235\242\347\273\230\345\210\266\350\277\207\347\250\213\350\257\246\350\247\243.md" "b/SourceAnalysis/Activity\347\225\214\351\235\242\347\273\230\345\210\266\350\277\207\347\250\213\350\257\246\350\247\243.md"
index e71ed344..c686be97 100644
--- "a/SourceAnalysis/Activity\347\225\214\351\235\242\347\273\230\345\210\266\350\277\207\347\250\213\350\257\246\350\247\243.md"
+++ "b/SourceAnalysis/Activity\347\225\214\351\235\242\347\273\230\345\210\266\350\277\207\347\250\213\350\257\246\350\247\243.md"
@@ -41,7 +41,7 @@ public void setContentView(int layoutResID) {
 	// decor, when theme attributes and the like are crystalized. Do not check the feature
 	// before this happens.
 	if (mContentParent == null) {
-	    // 内部会创建mContentParent, 如果mDecor为null就创建，然后如果mContentParent为null，就根据当前要显示的主题去添加对应的布局，
+                // 内部会创建mContentParent, 如果mDecor为null就创建，然后如果mContentParent为null，就根据当前要显示的主题去添加对应的布局，
 		// 并把该布局中id为content的ViewGroup赋值给mContentParent。
 		installDecor();
 	} else if (!hasFeature(FEATURE_CONTENT_TRANSITIONS)) {
@@ -54,7 +54,7 @@ public void setContentView(int layoutResID) {
 				getContext());
 		transitionTo(newScene);
 	} else {
-	    // 把布局inflate后添加到mContentParent中
+	        // 把布局inflate后添加到mContentParent中
 		mLayoutInflater.inflate(layoutResID, mContentParent);
 	}
 	final Callback cb = getCallback();
@@ -582,4 +582,4 @@ protected ViewGroup generateLayout(DecorView decor) {
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/SourceAnalysis/Android Touch\344\272\213\344\273\266\345\210\206\345\217\221\350\257\246\350\247\243.md" "b/SourceAnalysis/Android Touch\344\272\213\344\273\266\345\210\206\345\217\221\350\257\246\350\247\243.md"
index 1ef073c8..85b1e5fc 100644
--- "a/SourceAnalysis/Android Touch\344\272\213\344\273\266\345\210\206\345\217\221\350\257\246\350\247\243.md"	
+++ "b/SourceAnalysis/Android Touch\344\272\213\344\273\266\345\210\206\345\217\221\350\257\246\350\247\243.md"	
@@ -3,12 +3,12 @@ Android Touch事件分发详解
 
 先说一些基本的知识，方便后面分析源码时能更好理解。
 - 所有`Touch`事件都被封装成`MotionEvent`对象，包括`Touch`的位置、历史记录、第几个手指等.
-- 事件类型分为`ACTION_DOWN`,`ACTION_UP`,`ACTION_MOVE`,`ACTION_POINTER_DOWN`,`ACTION_POINTER_UP`,`ACTION_CANCEL`, 每个
+- 事件类型分为`ACTION_DOWN`,`ACTION_UP`,`ACTION_MOVE`,`ACTION_POINTER_DOWN`,`ACTION_POINTER_UP`,`ACTION_CANCEL`, 每
 一个完整的事件以`ACTION_DOWN`开始`ACTION_UP`结束，并且`ACTION_CANCEL`只能由代码引起.一般对于`CANCEL`的处理和`UP`的相同。
 `CANCEL`的一个简单例子：手指在移动的过程中突然移动到了边界外，那么这时`ACTION_UP`事件了，所以这是的`CANCEL`和`UP`的处理是一致的。
-- 事件的处理分别为`dispatchTouchEveent()`分发事件(`TextView`等这种最小的`View`中不会有该方式)、`onInterceptTouchEvent()`拦截事件(`ViewGroup`中拦截事件)、`onTouchEvent()`消费事件.这些方法的返回值如果是true表示事件被当前视图消费掉。
+- 事件的处理分别为`dispatchTouchEvent()`分发事件(`TextView`等这种最小的`View`中不会有该方式)、`onInterceptTouchEvent()`拦截事件(`ViewGroup`中拦截事件)、`onTouchEvent()`消费事件.这些方法的返回值如果是true表示事件被当前视图消费掉。
 - 事件从`Activity.dispatchTouchEveent()`开始传递，只要没有停止拦截，就会从最上层(`ViewGroup`)开始一直往下传递，子`View`通过`onTouchEvent()`消费事件。(隧道式向下分发).
-- 如果时间从上往下一直传递到最底层的子`View`，但是该`View`没有消费该事件(不是clickable或longclickable)，那么该事件会反序网上传递(从该`View`传递给自己的`ViewGroup`，然后再传给更上层的`ViewGroup`直至传递给`Activity.onTouchEvent()`).
+- 如果时间从上往下一直传递到最底层的子`View`，但是该`View`没有消费该事件(不是clickable或longclickable)，那么该事件会反序往上传递(从该`View`传递给自己的`ViewGroup`，然后再传给更上层的`ViewGroup`直至传递给`Activity.onTouchEvent()`).
 (冒泡式向上处理).
 - 如果`View`没有消费`ACTION_DOWN`事件，之后其他的`MOVE`、`UP`等事件都不会传递过来.
 - 事件由父`View(ViewGroup)`传递给子`View`,`ViewGroup`可以通过`onInterceptTouchEvent()`方法对事件进行拦截，停止其往下传递，如果拦截(返回`true`)后该事件
@@ -51,11 +51,11 @@ public boolean dispatchTouchEvent(MotionEvent ev) {
 	if (ev.getAction() == MotionEvent.ACTION_DOWN) {
 		onUserInteraction();
 	}
-    // 首先交给本Activity对应的Window来进行分发，如果分发了，就返回true，事件循环结束
+        // 首先交给本Activity对应的Window来进行分发，如果分发了，就返回true，事件循环结束
 	if (getWindow().superDispatchTouchEvent(ev)) {
 		return true;
 	}
-    // 如果window返回了false，就意味着所有view的ontouchevent都返回了false，那么只能是Activity来决定消费不消费
+        // 如果window返回了false，就意味着所有view的ontouchevent都返回了false，那么只能是Activity来决定消费不消费
 	return onTouchEvent(ev);
 }
 ```
@@ -115,8 +115,8 @@ public boolean superDispatchTouchEvent(MotionEvent event) {
 	return super.dispatchTouchEvent(event);
 }
 ```
-是调用了`super.dispatchTouchEveent()`，而`DecorView`的父类是`FrameLayout`所以我们找到`FrameLayout.dispatchTouchEveent()`.
-我们看到`FrameLayout`中没有重写`dispatchTouchEveent()`方法，所以我们再找到`FrameLayout`的父类`ViewGroup`.看`ViewGroup.dispatchTouchEveent()`实现。
+是调用了`super.dispatchTouchEvent()`，而`DecorView`的父类是`FrameLayout`所以我们找到`FrameLayout.dispatchTouchEvent()`.
+我们看到`FrameLayout`中没有重写`dispatchTouchEvent()`方法，所以我们再找到`FrameLayout`的父类`ViewGroup`.看`ViewGroup.dispatchTouchEvent()`实现。
 新大陆浮现了...     
 ```java
 /**
@@ -145,21 +145,21 @@ public boolean dispatchTouchEvent(MotionEvent ev) {
 			// The framework may have dropped the up or cancel event for the previous gesture
 			// due to an app switch, ANR, or some other state change.
 			cancelAndClearTouchTargets(ev);
-            // 重置FLAG_DISALLOW_INTERCEPT
+                        // 重置FLAG_DISALLOW_INTERCEPT
 			resetTouchState();
 			// 如果是`Down`，那么`mFirstTouchTarget`到这里肯定是`null`.因为是新一系列手势的开始。
 			// `mFirstTouchTarget`是处理第一个事件的目标。
 		}
 
-		// 检查是否拦截该事件(如果`onInterceptTouchEvent()`返回true就拦截该事件)
+	       	// 检查是否拦截该事件(如果`onInterceptTouchEvent()`返回true就拦截该事件)
 		// Check for interception.
 		final boolean intercepted;
-        // 当事件由ViewGroup的子元素成功处理时，mFirstTouchTarget会被赋值并指向子元素，反之被ViewGroup拦截时，mFirstTouchTarget则为null
+                // 当事件由ViewGroup的子元素成功处理时，mFirstTouchTarget会被赋值并指向子元素，反之被ViewGroup拦截时，mFirstTouchTarget则为null
 		if (actionMasked == MotionEvent.ACTION_DOWN
 				|| mFirstTouchTarget != null) {
 			// 标记事件不允许被拦截， 默认是`false`， 该值可以通过`requestDisallowInterceptTouchEvent(true)`方法来设置，
 			// 通知父`View`不要拦截该`View`上的事件。FLG_DISALLOW_INTERCEPT是在View中通过
-            // reqeustDisallowInterceptTouchEvent来设置
+                        // reqeustDisallowInterceptTouchEvent来设置
 			final boolean disallowIntercept = (mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0;
 			if (!disallowIntercept) {
 				// 判断该`ViewGroup`是否要拦截该事件。`onInterceptTouchEvent()`方法默认返回`false`即不拦截。
@@ -370,7 +370,7 @@ private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
 	// or filtering.  The important part is the action, not the contents.
 	final int oldAction = event.getAction();
 	
-	// 这就是为什么时间被拦截之后，之前处理过该事件的`View`会收到`CANCEL`.
+	// 这就是为什么事件被拦截之后，之前处理过该事件的`View`会收到`CANCEL`.
 	if (cancel || oldAction == MotionEvent.ACTION_CANCEL) {
 		event.setAction(MotionEvent.ACTION_CANCEL);
 		if (child == null) {
@@ -439,7 +439,7 @@ private boolean dispatchTransformedTouchEvent(MotionEvent event, boolean cancel,
 ```
 
 
-上面讲了`ViewGroup`的`dispatchTouchEveent()`有些地方会调用`super.dispatchTouchEveent()`，而`ViewGroup`的父类就是`View`，接下来我们看一下`View.dispatchTouchEveent()`方法：
+上面讲了`ViewGroup`的`dispatchTouchEvent()`有些地方会调用`super.dispatchTouchEvent()`，而`ViewGroup`的父类就是`View`，接下来我们看一下`View.dispatchTouchEvent()`方法：
 ```java
 /**
  * Pass the touch screen motion event down to the target view, or this
@@ -531,7 +531,7 @@ public boolean onTouchEvent(MotionEvent event) {
 	}
 
 	// 关于TouchDelegate,文档中是这样说的The delegate to handle touch events that are physically in this view
-    // but should be handled by another view. 就是说如果两个View, View2在View1中，View1比较大，如果我们想点击
+        // but should be handled by another view. 就是说如果两个View, View2在View1中，View1比较大，如果我们想点击
 	// View1的时候，让View2去响应点击事件，这时候就需要使用TouchDelegate来设置。
 	// 简单的理解就是如果这个View有自己的时间委托处理人，就交给委托人处理。
 	if (mTouchDelegate != null) {
@@ -542,12 +542,12 @@ public boolean onTouchEvent(MotionEvent event) {
 
 	if (((viewFlags & CLICKABLE) == CLICKABLE ||
 			(viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)) {
-	    // 这个View可点击
+                // 这个View可点击
 		switch (event.getAction()) {
 			case MotionEvent.ACTION_UP:
-			    // 最好先看DOWN后再看MOVE最后看UP。
+	                        // 最好先看DOWN后再看MOVE最后看UP。
 				// PFLAG_PREPRESSED 表示在一个可滚动的容器中,要稍后才能确定是按下还是滚动.
-                // PFLAG_PRESSED 表示不是在一个可滚动的容器中,已经可以确定按下这一操作.
+                                // PFLAG_PRESSED 表示不是在一个可滚动的容器中,已经可以确定按下这一操作.
 				boolean prepressed = (mPrivateFlags & PFLAG_PREPRESSED) != 0;
 				if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed) {
 					// 处理点击或长按事件
@@ -651,7 +651,7 @@ public boolean onTouchEvent(MotionEvent event) {
 				
 				// Be lenient about moving outside of buttons， 检查是否移动到View外面了。
 				if (!pointInView(x, y, mTouchSlop)) {
-				    // 移动到区域外面去了，就要取消点击。
+			                // 移动到区域外面去了，就要取消点击。
 					// Outside button
 					removeTapCallback();
 					if ((mPrivateFlags & PFLAG_PRESSED) != 0) {
@@ -726,4 +726,4 @@ public boolean performClick() {
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/SourceAnalysis/AsyncTask\350\257\246\350\247\243.md" "b/SourceAnalysis/AsyncTask\350\257\246\350\247\243.md"
index 6550cc67..9ad20560 100644
--- "a/SourceAnalysis/AsyncTask\350\257\246\350\247\243.md"
+++ "b/SourceAnalysis/AsyncTask\350\257\246\350\247\243.md"
@@ -1,7 +1,7 @@
 AsyncTask详解
 ===
 
-`AsyncTask`简单的说其实就是`Handler`和`Thread`的结合，就想下面自己写的`MyAsyncTask`一样，这就是它的基本远离，当然它并不止这么简单。
+`AsyncTask`简单的说其实就是`Handler`和`Thread`的结合，就像下面自己写的`MyAsyncTask`一样，这就是它的基本原理，当然它并不止这么简单。
 
 - 经典版异步任务                
 
@@ -69,9 +69,9 @@ new AsyncTask<Void, Void, Void>() {
 			super.onPostExecute(result);
 		}
 	}.execute(); 
-类的构造方法中接收三个参数，这里我们不用参数就都给它传Void，new出来AsyncTask类之后然后重写这三个方法，
-最后别忘了执行execute方法，其实它的内部和我们写的经典版的异步任务相同，也是里面写了一个在新的线程中去执行耗时的操作，
-然后用handler发送Message对象，主线程收到这个Message之后去执行onPostExecute中的内容。
+//  类的构造方法中接收三个参数，这里我们不用参数就都给它传Void，new出来AsyncTask类之后然后重写这三个方法，
+// 最后别忘了执行execute方法，其实它的内部和我们写的经典版的异步任务相同，也是里面写了一个在新的线程中去执行耗时的操作，
+// 然后用handler发送Message对象，主线程收到这个Message之后去执行onPostExecute中的内容。
 
 
 //AsyncTask<Params, Progress, Result> ,params 异步任务执行(doBackgroud方法)需要的参数这个参数的实参可以由execute()方法的参数传入,
@@ -120,10 +120,10 @@ new AsyncTask<String, Void, Boolean>() {
 		
 	}.execute("backup.xml"); //这里传入的参数就是doInBackgound中的参数，会传入到doInBackground中
  
-ProgressDialog有个方法
-incrementProgressBy(int num);方法，这个方法能够让进度条自动增加，如果参数为1就是进度条累加1。
+// ProgressDialog有个方法
+// incrementProgressBy(int num);方法，这个方法能够让进度条自动增加，如果参数为1就是进度条累加1。
  
-可以给ProgressDialog添加一个监听dismiss的监听器。pd.setOnDismisListener(DismisListener listener);让其在取消显示后做什么事
+// 可以给ProgressDialog添加一个监听dismiss的监听器。pd.setOnDismisListener(DismisListener listener);让其在取消显示后做什么事
 ```
 
 经过上面两部分，我们会发现`AsyncTask`太好了，他帮我们封装了`Handler`和`Thread`，当然他内部肯定会有线程池的管理，所以以后我们在开发中对于耗时的操作可以都用`AsyncTask`来搞定的。其实这种做法是错误的。今天发现公司项目中的网络请求都是用`AsyncTask`来做的(刚换的工作)。这样会有严重的问题。
@@ -132,7 +132,7 @@ incrementProgressBy(int num);方法，这个方法能够让进度条自动增加
 
 - `AsyncTask`虽然有`cancel`方法，但是一旦执行了`doInBackground`方法，就算调用取消方法，也会执行完`doInBackground`方法中的内容才会停止。
 - 串行还是并行的问题。
-    在`1.6`之前，`AsyncTask`是串行执行任务的。`1.6`的时候开始采用线程池并行处理。但是从`3.0`开始为了解决`AsyncTask`的并发问题，`AsyncTask`又采用一个现成来串行执行任务。(串行啊，每个任务10秒，五个任务，最后一个就要到50秒的时候才执行完)
+    在`1.6`之前，`AsyncTask`是串行执行任务的。`1.6`的时候开始采用线程池并行处理。但是从`3.0`开始为了解决`AsyncTask`的并发问题，`AsyncTask`又采用一个线程来串行执行任务。(串行啊，每个任务10秒，五个任务，最后一个就要到50秒的时候才执行完)
 - 线程池的问题。
 
 
@@ -171,7 +171,7 @@ If you truly want parallel execution, you can invoke executeOnExecutor(java.util
  * Creates a new asynchronous task. This constructor must be invoked on the UI thread.
  */
 public AsyncTask() {
-    // 初始化mWorker
+        // 初始化mWorker
 	mWorker = new WorkerRunnable<Params, Result>() {
 		public Result call() throws Exception {
 			// 修改该变量值
@@ -190,7 +190,7 @@ public AsyncTask() {
 		@Override
 		protected void done() {
 			try {
-			    // 执行完成后的操作
+                                // 执行完成后的操作
 				postResultIfNotInvoked(get());
 			} catch (InterruptedException e) {
 				android.util.Log.w(LOG_TAG, e);
@@ -266,14 +266,14 @@ private static class InternalHandler extends Handler {
 	}
 }
 ```
-我们看到如果判断消息类型为`MESSAGE_POST_RESULT`时，回去执行`finish()`方法，接着看一下`result.mTask.finish()`方法的源码:
+我们看到如果判断消息类型为`MESSAGE_POST_RESULT`时，会去执行`finish()`方法，接着看一下`result.mTask.finish()`方法的源码:
 ```java
 private void finish(Result result) {
 	if (isCancelled()) {
-	    // 如果被取消了就执行onCancelled方法，这就是为什么虽然AsyncTask可以取消，但是doInBackground方法还是会执行完的原因。
+                // 如果被取消了就执行onCancelled方法，这就是为什么虽然AsyncTask可以取消，但是doInBackground方法还是会执行完的原因。
 		onCancelled(result);
 	} else {
-	    // 没被取消就执行oPostExecute方法
+	        // 没被取消就执行oPostExecute方法
 		onPostExecute(result);
 	}
 	mStatus = Status.FINISHED;
@@ -307,7 +307,7 @@ public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec
 	mStatus = Status.RUNNING;
 	// 看到我们熟悉的onPreExecute()方法。
 	onPreExecute();
-    // 将参数设置给mWorker变量
+        // 将参数设置给mWorker变量
 	mWorker.mParams = params;
 	// 执行了Executor的execute方法并用mFuture为参数，这个exec就是上面的sDefaultExecutor
 	exec.execute(mFuture);
@@ -331,16 +331,16 @@ private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
 从上面的部分能够看出`sDefaultExecutor`是一个`SerialExecutor`对象，好了，接下来看一下`SerialExecutor`类:
 ```java
 private static class SerialExecutor implements Executor {
-    // 用一个队列来管理所有的runnable。offer是把要执行的添加进来，在scheduleNext中取出来去执行。
+        // 用一个队列来管理所有的runnable。offer是把要执行的添加进来，在scheduleNext中取出来去执行。
 	final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
 	Runnable mActive;
 
 	public synchronized void execute(final Runnable r) {
-	    // 终于找到了sDefaultExecutor.execute()所真正执行的部分。
+                // 终于找到了sDefaultExecutor.execute()所真正执行的部分。
 		mTasks.offer(new Runnable() {
 			public void run() {
 				try {
-				    // 就是mFuture的run方法，他会去调用mWorker.call方法，这样就会执行doInBackground方法，执行完后会把返回值用Handler发送出去
+	                                // 就是mFuture的run方法，他会去调用mWorker.call方法，这样就会执行doInBackground方法，执行完后会把返回值用Handler发送出去
 					r.run();
 				} finally {
 					scheduleNext();
@@ -354,7 +354,7 @@ private static class SerialExecutor implements Executor {
 
 	protected synchronized void scheduleNext() {
 		if ((mActive = mTasks.poll()) != null) {
-		    // 去取队列中的runnable去执行，这个mActive其实就是mFuture对象。
+                        // 去取队列中的runnable去执行，这个mActive其实就是mFuture对象。
 			THREAD_POOL_EXECUTOR.execute(mActive);
 		}
 	}
@@ -388,7 +388,7 @@ public void run() {
 			V result;
 			boolean ran;
 			try {
-			    // 他会去调用 Callable的call()方法，而上面传入的Callable参数是mWorker。所以这里就会调用mWorker的call方法。
+		                // 他会去调用 Callable的call()方法，而上面传入的Callable参数是mWorker。所以这里就会调用mWorker的call方法。
 				// 通过这里就和之前我们讲的doInBackground方法联系上了.
 				result = c.call();
 				ran = true;
@@ -930,4 +930,4 @@ public abstract class AsyncTask<Params, Progress, Result> {
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/SourceAnalysis/LeakCanary\346\272\220\347\240\201\345\210\206\346\236\220.md" "b/SourceAnalysis/LeakCanary\346\272\220\347\240\201\345\210\206\346\236\220.md"
index 62669286..2d5da989 100644
--- "a/SourceAnalysis/LeakCanary\346\272\220\347\240\201\345\210\206\346\236\220.md"
+++ "b/SourceAnalysis/LeakCanary\346\272\220\347\240\201\345\210\206\346\236\220.md"
@@ -3,7 +3,7 @@ LeakCanary源码分析
 
 [LeakCanary](https://github.com/square/leakcanary)是一个用于检测内存泄漏的工具，可以用于Java和Android，是由著名开源组织Square贡献。
 
-强烈建议使用LeakCanary 2.x版本，更高效、使用更简单，而且没有任何Java代码，它当泄露引用到达5时才会发起heap dump，同时使用了全新的heap parser，减少内存占用，提升速度。只需要在dependencies中加入leakcanary的依赖即可。而且debugimplementation只在debug模式下有效，所以不用担心用户在正式环境下也会出现LeanCanary收集。而且是完全使用kotlin实现了，同时使用了[see Shark](https://square.github.io/leakcanary/shark/)来进行heap内存分析，更节省内存。
+强烈建议使用LeakCanary 2.x版本，更高效、使用更简单，而且没有任何Java代码，它当泄露引用到达5时才会发起heap dump，同时使用了全新的heap parser，减少内存占用，提升速度。只需要在dependencies中加入leakcanary的依赖即可。而且debugimplementation只在debug模式下有效，所以不用担心用户在正式环境下也会出现LeakCanary收集。而且是完全使用kotlin实现了，同时使用了[see Shark](https://square.github.io/leakcanary/shark/)来进行heap内存分析，更节省内存。
 
 
 
diff --git "a/SourceAnalysis/Netowork/HttpURLConnection\350\257\246\350\247\243.md" "b/SourceAnalysis/Netowork/HttpURLConnection\350\257\246\350\247\243.md"
index f944cfa0..2c1e28bf 100644
--- "a/SourceAnalysis/Netowork/HttpURLConnection\350\257\246\350\247\243.md"
+++ "b/SourceAnalysis/Netowork/HttpURLConnection\350\257\246\350\247\243.md"
@@ -481,10 +481,10 @@ public final class OkHttpClient implements URLStreamHandlerFactory, Cloneable {
 
   HttpURLConnection open(URL url, Proxy proxy) {
     String protocol = url.getProtocol();
-	// 将该对象clone后设置一些其他的属性返回，里面会设置一个默认的连接池。
+    // 将该对象clone后设置一些其他的属性返回，里面会设置一个默认的连接池。
     OkHttpClient copy = copyWithDefaults();
     copy.proxy = proxy;
-	// 返回了HttpURLConnectionImpl，并且把clone后的OKHttpClient对象传递进去。
+    // 返回了HttpURLConnectionImpl，并且把clone后的OKHttpClient对象传递进去。
     if (protocol.equals("http")) return new HttpURLConnectionImpl(url, copy);
     if (protocol.equals("https")) return new HttpsURLConnectionImpl(url, copy);
     throw new IllegalArgumentException("Unexpected protocol: " + protocol);
@@ -869,7 +869,7 @@ private void connect() throws IOException {
 * @throws NoSuchElementException if there are no more routes to attempt.
 */
 public Connection next(String method) throws IOException {
-    // 使用连接池获取Connection的地方。pool就是OkHttpClient中的连接池。
+        // 使用连接池获取Connection的地方。pool就是OkHttpClient中的连接池。
 	// Always prefer pooled connections over new connections.
 	for (Connection pooled; (pooled = pool.get(address)) != null; ) {
 	  // 匹配get方法，或者判断是否可读，http1.x是通过判断socket是否关闭来判断是否可读的。
@@ -902,7 +902,7 @@ public Connection next(String method) throws IOException {
 	  // tried last.
 	  return next(method);
 	}
-    // 没有的话也会去创建，并把OkHttpClient中的连接池传递进去。
+        // 没有的话也会去创建，并把OkHttpClient中的连接池传递进去。
 	return new Connection(pool, route);
 }
 ```
@@ -946,7 +946,7 @@ public final class Connection implements Closeable {
     out = socket.getOutputStream();
 
     if (route.address.sslSocketFactory != null) {
-	  // 完成TLS握手和验证
+      // 完成TLS握手和验证
       upgradeToTls(tunnelRequest);
     } else {
       initSourceAndSink();
@@ -1214,7 +1214,7 @@ while (true) {
 // 看到了吗？他内部会先去调用connect()方法
 connect();
 
-　  // 这里可能有人会有说，getOutputStream和request body有什么关系，应该是response body才对啊。
+// 这里可能有人会有说，getOutputStream和request body有什么关系，应该是response body才对啊。
 // 不要弄混了啊，getOutputStream是要把post请求的数据输入给请求。
 BufferedSink sink = httpEngine.getBufferedRequestBody();
 if (sink == null) {
@@ -1392,9 +1392,9 @@ public class ConnectionPool {
 
   static {
     String keepAlive = System.getProperty("http.keepAlive");
-	// 存活时间
+    // 存活时间
     String keepAliveDuration = System.getProperty("http.keepAliveDuration");
-	// 最大空闲连接数
+    // 最大空闲连接数
     String maxIdleConnections = System.getProperty("http.maxConnections");
     long keepAliveDurationMs = keepAliveDuration != null ? Long.parseLong(keepAliveDuration)
         : DEFAULT_KEEP_ALIVE_DURATION_MS;
@@ -1527,7 +1527,7 @@ public class ConnectionPool {
       if (!connection.isSpdy()) {
 	    // 不是spdy连接
         try {
-		  // Platforml类对当前Android平台做了适配。
+          // Platforml类对当前Android平台做了适配。
           Platform.get().tagSocket(connection.getSocket());
         } catch (SocketException e) {
           Util.closeQuietly(connection);
@@ -1536,12 +1536,12 @@ public class ConnectionPool {
           continue;
         }
       }
-	  // 找到可复用的Connection
+      // 找到可复用的Connection
       foundConnection = connection;
       break;
     }
 
-	// 针对spdy连接，添加到连接池中
+    // 针对spdy连接，添加到连接池中
     if (foundConnection != null && foundConnection.isSpdy()) {
       connections.addFirst(foundConnection); // Add it back after iteration.
     }
diff --git "a/SourceAnalysis/Netowork/Retrofit\350\257\246\350\247\243(\344\270\212).md" "b/SourceAnalysis/Netowork/Retrofit\350\257\246\350\247\243(\344\270\212).md"
index f40821cd..29bdf7c6 100644
--- "a/SourceAnalysis/Netowork/Retrofit\350\257\246\350\247\243(\344\270\212).md"
+++ "b/SourceAnalysis/Netowork/Retrofit\350\257\246\350\247\243(\344\270\212).md"
@@ -135,7 +135,7 @@ Caused by: java.lang.IllegalArgumentException: Could not locate ResponseBody con
 这是什么鬼?难道官方给的示例代码有问题？ 从`log`上面我们能看出来是返回的数据结构不匹配导致的，返回的是`ResponseBody`的转换器无法转换为`List<Repo>`。    
 
 
-`Retrofit`是一个将`API`接口转换成回调对象的类，默认情况下`Retrofit`会根绝平台提供一些默认的配置，但是它是支持配置的。   
+`Retrofit`是一个将`API`接口转换成回调对象的类，默认情况下`Retrofit`会根据平台提供一些默认的配置，但是它是支持配置的。   
 
 Converters(解析数据)
 ---
@@ -370,6 +370,10 @@ Call<User> getUser(@Header("Authorization") String authorization)
 -keepattributes Exceptions
 ```
 
+------
+- [下一篇：Retrofit详解(下)](https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/Netowork/Retrofit%E8%AF%A6%E8%A7%A3(%E4%B8%8B).md)
+
+
 [1]: https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/Netowork/volley-retrofit-okhttp%E4%B9%8B%E6%88%91%E4%BB%AC%E8%AF%A5%E5%A6%82%E4%BD%95%E9%80%89%E6%8B%A9%E7%BD%91%E8%B7%AF%E6%A1%86%E6%9E%B6.md  "volley-retrofit-okhttp之我们该如何选择网路框架"
 [2]: https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/Netowork/Volley%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90.md "Volley源码分析"
 [3]: https://github.com/CharonChui/AndroidNote/blob/master/AdavancedPart/%E6%B3%A8%E8%A7%A3%E4%BD%BF%E7%94%A8.md "注解使用"
@@ -379,5 +383,4 @@ Call<User> getUser(@Header("Authorization") String authorization)
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
-
+- Good Luck!
diff --git "a/SourceAnalysis/Netowork/Retrofit\350\257\246\350\247\243(\344\270\213).md" "b/SourceAnalysis/Netowork/Retrofit\350\257\246\350\247\243(\344\270\213).md"
index 00e75904..a745ab21 100644
--- "a/SourceAnalysis/Netowork/Retrofit\350\257\246\350\247\243(\344\270\213).md"
+++ "b/SourceAnalysis/Netowork/Retrofit\350\257\246\350\247\243(\344\270\213).md"
@@ -2,7 +2,7 @@ Retrofit详解(下)
 ===
 
 
-上一篇文件介绍了`Retrofit`的基本使用，接下来我们通过从源码的角度分析一下`Retrofit`的实现。    
+上一篇文章介绍了`Retrofit`的基本使用，接下来我们通过从源码的角度分析一下`Retrofit`的实现。    
 
 首先看一下它的基本使用方法:    
 
@@ -49,7 +49,7 @@ Retrofit retrofit = new Retrofit.Builder()
 
 这是典型的建造者模式、外观模式      
 
-就想平时我们写的下载模块，作为一个公共的模块，我们可以对外提供一个`DownloadManager`供外界使用，而对于里面的实现我们完全可以闭门造车。    
+就像平时我们写的下载模块，作为一个公共的模块，我们可以对外提供一个`DownloadManager`供外界使用，而对于里面的实现我们完全可以闭门造车。    
 
 具体`baseUrl()`、`addConverterFactory()`方法里面的具体实现就不去看了，比较简单。当然这里也用到了工厂设计模式。
 
@@ -85,7 +85,7 @@ public <T> T create(final Class<T> service) {
             }
             // 1，根据动态代理的方法去生成ServiceMethod这里动态代理的方法就是listRepos方法
             ServiceMethod serviceMethod = loadServiceMethod(method);
-            // 2，根绝ServiceMethod和参数去生成OkHttpCall，这里args是CharonChui
+            // 2，根据ServiceMethod和参数去生成OkHttpCall，这里args是CharonChui
             OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
             // 3, serviceMethod去进行处理并返回Call对象，拿到这个Call对象才能去执行网络请求。
             return serviceMethod.callAdapter.adapt(okHttpCall);
@@ -96,7 +96,7 @@ public <T> T create(final Class<T> service) {
 
 看到`Proxy.newProxyInstance()`就明白了，这里使用了动态代理。简单的说动态代理是在你要调用某个`Class`的方法前或后，插入你想要执行的代码。那这里要代理的是什么方法？ `Call<List<Repo>> call = gitHubService.listRepos("CharonChui");`，这里就是`listRepos()`方法。   就是说在调用`listRepos()`方法时会被动态代理所拦截，然后执行`Proxy.newProxyInstance()`里面的`InvocationHandler.invoke()`中的部分。   而`invoke()`方法的三个参数分别是啥？ 分别是`Object proxy`: 代理对象，`Method method`：调用的方法，就是`listRepos()`方法，`Object... args`：方法的参数，这里是`CharonChui`。   
 
-有关动态代理介绍可以看[张孝祥老师的java1.5高新技术系列中的动态代理]()
+有关动态代理介绍可以看[张孝祥老师的java1.5高新技术系列中的动态代理](https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/%E5%8A%A8%E6%80%81%E4%BB%A3%E7%90%86.md)
 
 这里就不仔细介绍动态代理了，上面的代码中又分为三部分:    
 
@@ -174,7 +174,7 @@ public <T> T create(final Class<T> service) {
 	          throw parameterError(p, "Parameter type must not include a type variable or wildcard: %s",
 	              parameterType);
 	        }
-			//  解析对应method的注解，这里是listRepos方法的注解。
+         	//  解析对应method的注解，这里是listRepos方法的注解。
 	        Annotation[] parameterAnnotations = parameterAnnotationsArray[p];
 	        if (parameterAnnotations == null) {
 	          throw parameterError(p, "No Retrofit annotation found.");
diff --git "a/SourceAnalysis/Netowork/Volley\346\272\220\347\240\201\345\210\206\346\236\220.md" "b/SourceAnalysis/Netowork/Volley\346\272\220\347\240\201\345\210\206\346\236\220.md"
index 3d081fa4..8b6ca304 100644
--- "a/SourceAnalysis/Netowork/Volley\346\272\220\347\240\201\345\210\206\346\236\220.md"
+++ "b/SourceAnalysis/Netowork/Volley\346\272\220\347\240\201\345\210\206\346\236\220.md"
@@ -202,7 +202,7 @@ public class Volley {
 
 ```
 
-接着来看一上上面提到的new BasicNetwork(HttpStack)方法的实现,可以看到他内部的缓存大小是4k
+接着来看一下上面提到的new BasicNetwork(HttpStack)方法的实现,可以看到他内部的缓存大小是4k
 ```java
 private static int DEFAULT_POOL_SIZE = 4096;
 
@@ -269,12 +269,12 @@ public class RequestQueue {
      */
     private final Set<Request<?>> mCurrentRequests = new HashSet<Request<?>>();
 
-	// cache队列
+    // cache队列
     /** The cache triage queue. */
     private final PriorityBlockingQueue<Request<?>> mCacheQueue =
         new PriorityBlockingQueue<Request<?>>();
 
-	// 网络请求队列
+    // 网络请求队列
     /** The queue of requests that are actually going out to the network. */
     private final PriorityBlockingQueue<Request<?>> mNetworkQueue =
         new PriorityBlockingQueue<Request<?>>();
diff --git "a/SourceAnalysis/View\347\273\230\345\210\266\350\277\207\347\250\213\350\257\246\350\247\243.md" "b/SourceAnalysis/View\347\273\230\345\210\266\350\277\207\347\250\213\350\257\246\350\247\243.md"
index e4168121..1bb19a51 100644
--- "a/SourceAnalysis/View\347\273\230\345\210\266\350\277\207\347\250\213\350\257\246\350\247\243.md"
+++ "b/SourceAnalysis/View\347\273\230\345\210\266\350\277\207\347\250\213\350\257\246\350\247\243.md"
@@ -625,7 +625,7 @@ private void performLayout(WindowManager.LayoutParams lp, int desiredWindowWidth
 							" during layout: running second layout pass");
 					view.requestLayout();
 				}
-                // desiredWindowWidth和desiredWindowHeight是屏幕的尺寸
+                                // desiredWindowWidth和desiredWindowHeight是屏幕的尺寸
 				measureHierarchy(host, lp, mView.getContext().getResources(),
 						desiredWindowWidth, desiredWindowHeight);
 				mInLayout = true;
@@ -975,8 +975,8 @@ private void draw(boolean fullRedrawNeeded) {
 	}
 
 	final Rect dirty = mDirty;
-    // 判断该Surface是否有SurfaceHolder对象，如果有则意味着该Surface是应用程序创建的，因为所有的绘制操作应该由应用程序
-    // 自身去负责，于是View系统推出绘制，如果不是，才开始View绘制的内部流程。
+        // 判断该Surface是否有SurfaceHolder对象，如果有则意味着该Surface是应用程序创建的，因为所有的绘制操作应该由应用程序
+        // 自身去负责，于是View系统推出绘制，如果不是，才开始View绘制的内部流程。
 	if (mSurfaceHolder != null) {
 		// The app owns the surface, we won't draw.
 		dirty.setEmpty();
@@ -1018,10 +1018,10 @@ private void draw(boolean fullRedrawNeeded) {
 	}
 
 	if (!dirty.isEmpty() || mIsAnimating) {
-        // Surface的底层驱动模式分为两种，一种是使用图形加速支持的Surface，俗称显卡，另一种是使用CPU及内存模拟的Surface。
-        // 因此这里需要根据不同的模式，进行不同的操作
+                // Surface的底层驱动模式分为两种，一种是使用图形加速支持的Surface，俗称显卡，另一种是使用CPU及内存模拟的Surface。
+                // 因此这里需要根据不同的模式，进行不同的操作
 		if (mAttachInfo.mHardwareRenderer != null && mAttachInfo.mHardwareRenderer.isEnabled()) {
-            // 硬件绘制
+                        // 硬件绘制
 			// Draw with hardware renderer.
 			mIsAnimating = false;
 			boolean invalidateRoot = false;
@@ -1071,7 +1071,7 @@ private void draw(boolean fullRedrawNeeded) {
 
 	if (animating) {
 		mFullRedrawNeeded = true;
-        // 动画就是让画面动起来，如果正在动画过程中，则需要再次发起一个重绘命令，以便接着绘制，直到滚动结束。
+                // 动画就是让画面动起来，如果正在动画过程中，则需要再次发起一个重绘命令，以便接着绘制，直到滚动结束。
 		scheduleTraversals();
 	}
 }
@@ -1618,4 +1618,4 @@ MeasureSpec是View类的一个静态内部类，用来说明如何测量这个
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/SourceAnalysis/\350\207\252\345\256\232\344\271\211View\350\257\246\350\247\243.md" "b/SourceAnalysis/\350\207\252\345\256\232\344\271\211View\350\257\246\350\247\243.md"
index 557f47f9..35eba6a8 100644
--- "a/SourceAnalysis/\350\207\252\345\256\232\344\271\211View\350\257\246\350\247\243.md"
+++ "b/SourceAnalysis/\350\207\252\345\256\232\344\271\211View\350\257\246\350\247\243.md"
@@ -1,7 +1,7 @@
 自定义View详解
 ===
 
-虽然之前也分析过[View绘制过程](https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/View%E7%BB%98%E5%88%B6%E8%BF%87%E7%A8%8B%E8%AF%A6%E8%A7%A3.md)，但是如果让我自己集成`ViewGroup`然后自己重新`onMeasure,onLayout,onDraw`方法自定义`View`我还是会头疼。今天索性来系统的学习下。
+虽然之前也分析过[View绘制过程](https://github.com/CharonChui/AndroidNote/blob/master/SourceAnalysis/View%E7%BB%98%E5%88%B6%E8%BF%87%E7%A8%8B%E8%AF%A6%E8%A7%A3.md)，但是如果让我自己继承`ViewGroup`然后自己重新`onMeasure,onLayout,onDraw`方法自定义`View`我还是会头疼。今天索性来系统的学习下。
 
 ### `onMeasure`
 
@@ -118,7 +118,7 @@ public static int getSize(int measureSpec) {
 
 ### `onLayout`
 
-为了能合理的去绘制定义`View`,你需要制定它的大小。复杂的自定义`View`通常需要根据屏幕的样式和大小来进行复杂的布局计算。你不应该假设你的屏幕上的`View`的大小。即使只有一个应用使用你的自定义`View`，也需要处理不同的屏幕尺寸、屏幕密度和横屏以及竖屏下的多种比率等。
+为了能合理的去绘制定义`View`,你需要指定它的大小。复杂的自定义`View`通常需要根据屏幕的样式和大小来进行复杂的布局计算。你不应该假设你的屏幕上的`View`的大小。即使只有一个应用使用你的自定义`View`，也需要处理不同的屏幕尺寸、屏幕密度和横屏以及竖屏下的多种比率等。
 
 虽然`View`有很多处理测量的方法，但他们中的大部分都不需要被重写。如果你的`View`不需要特别的控制它的大小，你只需要重写一个方法:`onSizeChanged()`。
 
@@ -448,7 +448,7 @@ public class VerticalLayout extends ViewGroup {
 }
 ```
 继承`ViewGroup`必须要重写`onLayout`方法。其实这也很好理解，因为每个`ViewGroup`的排列方式不一样，所以让子类来自己实现是最好的。      
-当然畜类重写`onLayout`之外，也要重写`onMeasure`。
+当然子类重写`onLayout`之外，也要重写`onMeasure`。
 代码如下，滑动手势处理的部分就不贴了。     
 ```java
 	@Override
@@ -461,7 +461,7 @@ public class VerticalLayout extends ViewGroup {
 
 	@Override
 	protected void onLayout(boolean changed, int l, int t, int r, int b) {
-        // 就像猴子捞月一样，让他们一个个的从上往下排就好了
+                // 就像猴子捞月一样，让他们一个个的从上往下排就好了
 		if (changed) {
 			int childCount = getChildCount();
 			for (int i = 0; i < childCount; i++) {
@@ -523,4 +523,4 @@ public class MetrailEditText extends EditText {
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! I
\ No newline at end of file
+- Good Luck! I
diff --git "a/VideoDevelopment/CDN\345\217\212PCDN.md" "b/VideoDevelopment/CDN\345\217\212PCDN.md"
index 672f475e..bc9d8c36 100644
--- "a/VideoDevelopment/CDN\345\217\212PCDN.md"
+++ "b/VideoDevelopment/CDN\345\217\212PCDN.md"
@@ -43,7 +43,7 @@ PUSH是一种主动分发的技术。通常，PUSH由内容管理系统发起，
 这些内容通过PUSH方式预分发到边缘Cache，可以实现有针对的内容提供。
 对于PUSH分发需要考虑的主要问题是分发策略，即在什么时候分发什么内容。一般来说，
 内容分发可以由CP（内容提供商）或者CDN内容管理员人工确定，也可以通过智能的方式决定，
-即所谓的智能分发，它根据用户访问的统计信息，以及预定义的内容分发的规则，确定内容分发的过程PULL是一种被动的分发技术，PULL分发通常由用户请求驱动。当用户请求的内容在本地的边缘 Cache上不存在（未命中）时，Cache启动PULL方法从内容源或者其他CDN节点实时获取内容。在PULL方式下，内容的分发是按需的。
+即所谓的智能分发，它根据用户访问的统计信息，以及预定义的内容分发的规则，确定内容分发的过程。PULL是一种被动的分发技术，PULL分发通常由用户请求驱动。当用户请求的内容在本地的边缘 Cache上不存在（未命中）时，Cache启动PULL方法从内容源或者其他CDN节点实时获取内容。在PULL方式下，内容的分发是按需的。
 - 内容交换机:处于用户接入集中点，可以均衡单点多个内容缓存设备的负载，并对内容进行缓存负载平衡及访问控制。
 - 内容路由器:负责将用户的请求调度到适当的设备上。它是整体性的网络负载均衡技术，通过内容路由器中的重定向（DNS）机制，在多个远程POP上均衡用户的请求，
 以使用户请求得到最近内容源的响应。CDN负载均衡系统实现CDN的内容路由功能。它的作用是将用户的请求导向
@@ -75,7 +75,7 @@ SLB设备构成）进行。本地内容管理的主要目标是提高内容服
 归纳起来，CDN具有以下主要功能:         
 1. 实现跨运营商、跨地域的全网覆盖    
 互联不互通、区域ISP地域局限、出口带宽受限制等种种因素都造成了网站的区域性无法访问。
-CDN加速可以覆盖全球的线路，通过和运营商合作，部署IDC资源，在全国骨干节点商，合理部署CDN边缘
+CDN加速可以覆盖全球的线路，通过和运营商合作，部署IDC资源，在全国骨干节点上，合理部署CDN边缘
 分发存储节点，充分利用带宽资源，平衡源站流量，这样可以节省骨干网带宽，减少带宽需求量并能
 解决由于用户访问量大造成的服务器过载问题。    
 2. 保障网站安全      
@@ -85,7 +85,7 @@ CDN的负载均衡和分布式存储技术，可以加强网站的可靠性，
 当某个服务器发生意外故障时，系统将会调用其他临近的健康服务器节点进行服务，进而提供接近100%的可靠性，
 这就让你的网站可以做到永不宕机。    
 4. 为了节约成本投入     
-使用CDN加速可以实现网站的全国铺设，你根据不用考虑购买服务器与后续的托管运维，服务器之间镜像同步，
+使用CDN加速可以实现网站的全国铺设，你根本不用考虑购买服务器与后续的托管运维，服务器之间镜像同步，
 也不用为了管理维护技术人员而烦恼，节省了人力、精力和财力。
 
 ### 特点
@@ -288,4 +288,4 @@ P2P用户将根据这些规则来完成P2P共享。P2P在边缘层的引入大
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/VideoDevelopment/DNS\345\217\212HTTPDNS.md" "b/VideoDevelopment/DNS\345\217\212HTTPDNS.md"
index 3c52aea7..0a0323b1 100644
--- "a/VideoDevelopment/DNS\345\217\212HTTPDNS.md"
+++ "b/VideoDevelopment/DNS\345\217\212HTTPDNS.md"
@@ -150,8 +150,8 @@ DNS权威服务器保存着域名空间中部分区域的数据。如果DNS服
 - A：地址记录（Address），返回域名指向的IP地址。
 - NS：域名服务器记录（Name Server），返回保存下一级域名信息的服务器地址。该记录只能设置为域名，不能设置为IP地址。
 - MX：邮件记录（Mail eXchange），返回接收电子邮件的服务器地址。
-- CNAME：规范名称记录（Canonical Name），返回另一个域名，即当前查询的域名是另一个域名的跳转，详见下文。
-- PTR：逆向查询记录（Pointer Record），只用于从IP地址查询域名，详见下文。
+- CNAME：规范名称记录（Canonical Name），返回另一个域名，即当前查询的域名是另一个域名的跳转。
+- PTR：逆向查询记录（Pointer Record），只用于从IP地址查询域名。
 
 一般来说，为了服务的安全可靠，至少应该有两条NS记录，而A记录和MX记录也可以有多条，这样就提供了服务的冗余性，防止出现单点失败。
 
@@ -254,4 +254,4 @@ Accept: */*
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 

From de97a2fcaf80b626bf6e0945bebc3f12ecae1daf Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 20 Mar 2023 14:42:24 +0800
Subject: [PATCH 098/213] update

---
 .../AudioTrack\347\256\200\344\273\213.md"    |  2 +-
 ...47\350\203\275\344\274\230\345\214\226.md" | 50 ++++---------------
 2 files changed, 12 insertions(+), 40 deletions(-)

diff --git "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/AudioTrack\347\256\200\344\273\213.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/AudioTrack\347\256\200\344\273\213.md"
index 1a4f8e30..ff862a6c 100644
--- "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/AudioTrack\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/AudioTrack\347\256\200\344\273\213.md"
@@ -4,7 +4,7 @@ AudioTrack简介
 Android系统提供了三种播放音频文件的方式:  
 
 - SoundPoll:适合播放短促且对反应速度要求比较高的情况(如游戏音效、按键声等)
-- AudioTrack:只支持播放解码后的PCM流，如果是文件的话只致辞WAV格式的音频文件，因为WAV格式的音频文件大部分都是PCM流，AudioTrack不创建解码器，所以只能播放不需要解码的WAV文件，但是CPU占用率低，内存消耗也比较小。因此如果是播放比较短时间的WAV音频文件，建议使用AudioTrack。
+- AudioTrack:只支持播放解码后的PCM流，如果是文件的话只支持WAV格式的音频文件，因为WAV格式的音频文件大部分都是PCM流，AudioTrack不创建解码器，所以只能播放不需要解码的WAV文件，但是CPU占用率低，内存消耗也比较小。因此如果是播放比较短时间的WAV音频文件，建议使用AudioTrack。
 - MediaPlayer:适合比较长且时间要求不那么高的情况,支持多种文件格式，如MP3、WAV、AAC等。其实MediaPlayer是基于AudioTrack的封装，内部也是使用AudioTrack，MediaPlayer在framework层也实例化了AudioTrack，MediaPlayer在framework层进行解码后，生成PCM流，然后代理委托给AudioTrack，最后AudioTrack传递给AudioFlinger进行混音，然后才传递给硬件播放。 
 
 
diff --git "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/\346\222\255\346\224\276\345\231\250\346\200\247\350\203\275\344\274\230\345\214\226.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/\346\222\255\346\224\276\345\231\250\346\200\247\350\203\275\344\274\230\345\214\226.md"
index b64ab96e..a77a4510 100644
--- "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/\346\222\255\346\224\276\345\231\250\346\200\247\350\203\275\344\274\230\345\214\226.md"
+++ "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/\346\222\255\346\224\276\345\231\250\346\200\247\350\203\275\344\274\230\345\214\226.md"
@@ -25,7 +25,7 @@
 - 相比H264,编码复杂度提升4倍，更消耗系统资源
 - 编码时间更长
 
-通过软解可以支持，但是CPU会占用较高，而且发热和好点。
+通过软解可以支持，但是CPU会占用较高，而且发热和耗电。
 对解码能力进行评估，来通过机型打分控制是否使用H265以及是用360p还是480p。   
 但是H265全部切换成本较高，牵扯到转码成本以及存储成本，所以可以只对热点的视频去进行编码，这样少量的视频就可以带来可观的效果。
 
@@ -68,15 +68,15 @@
 
 ### 预取策略
 
-1，修改AndroidVideoCache进行预加载
- 2，线程池并发缓存并控制视频缓存优先级（线程池线程数为3，先加入的先缓存），一次预加载8个视频，item创建时开始预加载，item销毁时，取消预加载
- 3，等待下页第一个视频预加载完成，才会进入下一页视频，保证滑到的视频都是可以立马观看的。（一页视频为8个）
- 4，当前视频开始播放之后才会进行预加载
- 5，区分快滑慢滑两种模式，快滑时取消当前所有预加载，慢滑不取消，因为快滑大概率滑到一个未预加载的视频，慢滑大概率滑到一个已经预加载的视频，保证滑到视频尽快播放。
- 6，当视频播放后，根据滑动方向，会将取消的预加载进行恢复，正向滑动就恢复当前之后之后的预加载任务，反选滑动就恢复当前视频之前的预加载任务。
- 7，限制网速，当时视频还没播放的时候，会限制预下载的网速（慢滑不会取消预加载），通过让下载线程sleep来限制网速。
- 8，ijkplayer起播参数配置。
- 9，视频压缩和处理（让视频参数都位于视频首部）。
+1. 修改AndroidVideoCache进行预加载
+2. 线程池并发缓存并控制视频缓存优先级（线程池线程数为3，先加入的先缓存），一次预加载8个视频，item创建时开始预加载，item销毁时，取消预加载
+3. 等待下页第一个视频预加载完成，才会进入下一页视频，保证滑到的视频都是可以立马观看的。（一页视频为8个）
+4. 当前视频开始播放之后才会进行预加载
+5. 区分快滑慢滑两种模式，快滑时取消当前所有预加载，慢滑不取消，因为快滑大概率滑到一个未预加载的视频，慢滑大概率滑到一个已经预加载的视频，保证滑到视频尽快播放。
+6. 当视频播放后，根据滑动方向，会将取消的预加载进行恢复，正向滑动就恢复当前之后之后的预加载任务，反选滑动就恢复当前视频之前的预加载任务。
+7. 限制网速，当时视频还没播放的时候，会限制预下载的网速（慢滑不会取消预加载），通过让下载线程sleep来限制网速。
+8. ijkplayer起播参数配置。
+9. 视频压缩和处理（让视频参数都位于视频首部）。
 
 
 
@@ -135,9 +135,6 @@ Conviva在2011年的分享中提到以下观点，缓冲次数始终是最主要
 不断优化表现直接与收入关联的主要原因是，收入统计通常计出多门且较为滞后，可采用的替代指标包括注册用户数、活跃用户数、视频观察市场、观看次数、播放占比、付费率、留存率、分享率、满意度等。
 
 
-
-
-
 ### 监控
 
 监控上报，肯定是不可缺少的，这是一个成熟的项目必备的要素。
@@ -152,32 +149,7 @@ Conviva在2011年的分享中提到以下观点，缓冲次数始终是最主要
 
 
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 

From 8d4a19c8a88bebe59031cbf025d6e3b6c833b517 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 20 Mar 2023 16:35:35 +0800
Subject: [PATCH 099/213] update

---
 ...74\345\274\217\350\257\246\350\247\243.md" |  4 +--
 .../fMP4 vs ts.md"                            | 15 ++++-------
 ...01\350\243\205\346\240\274\345\274\217.md" | 25 ++++++++-----------
 3 files changed, 17 insertions(+), 27 deletions(-)

diff --git "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/MP4\346\240\274\345\274\217\350\257\246\350\247\243.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/MP4\346\240\274\345\274\217\350\257\246\350\247\243.md"
index 2778296c..6e36462a 100644
--- "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/MP4\346\240\274\345\274\217\350\257\246\350\247\243.md"
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/MP4\346\240\274\345\274\217\350\257\246\350\247\243.md"
@@ -45,7 +45,7 @@ moov和mdat这两个Atom顺序不固定，一般来说都是moov在前。
 
 #### ftyp(File Type Box)
 
-声明该违建为MP4文件的相关信息，必须在第一个，而且只有一个
+声明该文件为MP4文件的相关信息，必须在第一个，而且只有一个
 
 #### moov(movie box)
 
@@ -102,4 +102,4 @@ mvhd定义了整个movie的特性，通常包含媒体无关的信息，例如
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/fMP4 vs ts.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/fMP4 vs ts.md"
index 1e1017b1..1cb7d9c6 100644
--- "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/fMP4 vs ts.md"	
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/fMP4 vs ts.md"	
@@ -12,22 +12,18 @@ MP4，全称MPEG-4 Part  14，是一种使用MPEG-4的多媒体电脑档案格
 
 ### 媒体数据与元数据的分离
 
-在mp4格式中，元数据可以和媒体数据很好地分开存储，后者都在mdat box中，而在ts中，诸多es流和header/metadata信息是复用在一起的。（TODO:介绍ts中的metadata信息怎么存储）。 
+在mp4格式中，元数据可以和媒体数据很好地分开存储，后者都在mdat box中，而在ts中，诸多es流和header/metadata信息是复用在一起的。 
 元数据的分离允许我们在streaming中先读取各个流的元数据，知道他们的媒体内容的属性（比如不同的视频质量、不同的语言等），从而可以更好地在不同的media data之间做自适应切换。 
 当然，在更实际的应用场景中，比如在dash协议中会直接把这些元数据信息写在mpd中，player可以只读一个mpd就知道各个媒体数据的属性
 
 ### 各个Track独立存储
 
-在fmp4中，不仅媒体数据和metadata相互独立的存储，音视频track的数据也可以分开存储，这里的“分开”已经不仅仅局限于box层面的分开，而是真的可以分开存储于不同的目录。在这种情况下，player只需要读一个记录了它们各自存储位置的manifest，即可去对应的位置download它们的分片，只要做好音视频分片之间的同步工作，就可以正常的播放。 
-举个例子，下面是一个dash中常见的mpd： 
-![这里写图片描述](https://www.itdaan.com/imgs/5/4/8/5/76/090fc502224c3e083760a2300d06e866.jpe)
-在这个mpd中我们看到视频的分片都是存储在video/1/这个目录下，而音频分片都存储在audio/und/mp4a/1这个目录下，而player还是可以将它们拼接到一起完成播放。 
-相对地，在streaming TS流时，音视频往往是复用在一起的，以HLS这个应用场景为例的话，server端一定还需要提前将TS切片做好，这样就会带来几个问题： 
+在fmp4中，不仅媒体数据和metadata相互独立的存储，音视频track的数据也可以分开存储，这里的“分开”已经不仅仅局限于box层面的分开，而是真的可以分开存储于不同的目录。在这种情况下，player只需要读一个记录了它们各自存储位置的manifest，即可去对应的位置download它们的分片，只要做好音视频分片之间的同步工作，就可以正常的播放。     
+相对地，在streaming TS流时，音视频往往是复用在一起的，以HLS这个应用场景为例的话，server端一定还需要提前将TS切片做好，这样就会带来几个问题：      
 **1. 媒体文件存储成本和媒资管理成本增加** 
 假设server端将video track编码为三个质量级别V1, V2, V3，audio track也被编码为三个质量级别A1, A2,  A3，那么如果利用fmp4格式的特性，我们只需要存储这6份媒体文件，player在播放时再自主组合不同质量级别的音视频track即可。而对于TS，则不得不提前将3x3=9种不同的音视频复用情况对应的媒体文件都存储到server端，平白无故多出三份文件的存储成本。实际中，因为要考虑到大屏端、小屏端、移动端、桌面端、不同语言、不同字幕等各种情况，使用TS而造成的冗余成本将更加可观。同时，存储文件的增加也意味着媒资管理成本的增加。这也是包括Netflix在内的一些公司选择使用fmp4做streaming格式的原因。 
 **2. manifest文件更加复杂** 
-fmp4格式的特性可以确保每一个单独的媒体分片都是可解密可解码的（当然player需要先从moov box中读到它们的编解码等信息），这意味着server端甚至根本不需要真的存储一大堆分片，player可以直接利用byte range  request技术从一个大文件中准确地读出一个分片对应的media data，这也使得对应manifest(mpd)文件可以更加简洁，如下： 
-![这里写图片描述](https://www.itdaan.com/imgs/2/0/5/0/35/0e7a66325da9f454b13b32692004c33d.jpe)
+fmp4格式的特性可以确保每一个单独的媒体分片都是可解密可解码的（当然player需要先从moov box中读到它们的编解码等信息），这意味着server端甚至根本不需要真的存储一大堆分片，player可以直接利用byte range  request技术从一个大文件中准确地读出一个分片对应的media data，这也使得对应manifest(mpd)文件可以更加简洁。   
 针对不同语言的音频，都只需要存一个大文件就够了。 
 相对地，在streaming TS流时，不得不在manifest（m3u8）文件中把成百上千个ts分片文件全都老老实实地记录下来。 
 **3.服务器的cache效率会降低** 
@@ -43,7 +39,6 @@ fmp4格式的特性可以确保每一个单独的媒体分片都是可解密可
 
 无缝码流切换实现的关键在于：当第一个码流播放结束时，也就是发生切换的时间，第二个码流一定要以关键帧开始播放。在streaming TS流时，因为不能保证每一个TS  chunk一定以关键帧开始，做码流切换时就意味着要同时download两个码流的相应分片，同时解析两个码流，然后找到关键帧对应的位置，才能切换。同时下载、解析两个码流的媒体内容对网络带宽以及设备性能都形成了挑战。而且有意思的是，如果当前网络环境不佳，player想要切换到低码率码流，结果还要在本来就不好的网络环境下同时进行两个码流的下载，可谓是雪上加霜。 
 而在fmp4中，除了保证各个分片一定以IDR帧开始外，还能保证不同码流的分片之间在时间线上是对齐的。而且streaming fmp4流时因为不要求音视频复用存储，也就意味着视频和音频的同步点可以不一样，视频可以全都以GOP边界作为同步点，音频可以都以sync frame作为同步点，这都使得无缝码流切换更简单。 
-TODO:介绍在分片中间进行切换的情况
 
 ### 与DRM的集成
 
@@ -67,4 +62,4 @@ CENC使用的就是fMP4格式，这是利用了fMP4中音视频可以不复用
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217.md"
index c98f5a96..f60f3b09 100644
--- "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217.md"
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217.md"
@@ -11,20 +11,15 @@
 
 常用视频封装格式及对应的文件格式： 
 
-| 视频封装格式 | 视频文件格式 |
-
-| ------ | ------ | 
-
-| AVI(Audio Video Interleave) | AVI | 
-| WMV(Windows Media Video) | WMV | 
-| MPEG分为MPEG-1,MPEG-2,MPEG-4 | MPG MPEG VOB DAT 3GP MP4 | 
-| Matroska | MKV | 
-| Real Video | RM RMVB | 
-| QuickTime File Format | MOV | 
-| Flash Video | FLV | 
-
-
-
+ | 视频封装格式 | 视频文件格式 |
+ | ------ | ------ |
+ | AVI(Audio Video Interleave) | AVI |
+ | WMV(Windows Media Video) | WMV |
+ | MPEG分为MPEG-1,MPEG-2,MPEG-4 | MPG MPEG VOB DAT 3GP MP4 |
+ | Matroska | MKV |
+ | Real Video | RM RMVB |
+ | QuickTime File Format | MOV |
+ | Flash Video | FLV |
 
 
 ## 音频编码格式
@@ -124,4 +119,4 @@ H.264最大的优势是具有很高的数据压缩比率，在同等图像质量
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 

From 603158f511b0e87f9596578503b965f24d6e7cde Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Tue, 21 Mar 2023 09:33:33 +0800
Subject: [PATCH 100/213] update

---
 ...73\347\273\237\347\256\200\344\273\213.md" | 40 ++++++++++++++-----
 1 file changed, 31 insertions(+), 9 deletions(-)

diff --git "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md" "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
index 7014d941..fa3aa962 100644
--- "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
+++ "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
@@ -1,20 +1,42 @@
 # 1.操作系统简介
 
-操作系统(Operating System, 简称OS)是管理和控制计算机硬件与软件资源的计算机程序。
-它是一种由引导程序（bootloader）启动并管理计算机中所有程序生命周期的系统程序。任何其他软件都必须在操作系统的支持下才能运行，操作系统能有效组织和管理系统中的各种软、硬件资源，合理组织计算机系统的工作流程并控制程序的执行，为用户提供一个良好的操作环境。 目前比较为人所知的操作系统有Microsoft的Windows系统、Apple的Mac及以Linux为内核的各种Linux发行版(Centos/Ubuntu等)。 现代计算机系统由一个或多个处理器、主存、打印机、键盘、鼠标、显示器、网络接口及各种输入\输出设备构成。
-
-
-操作系统这个术语听上去稀松平常，并不给人任何兴奋的感觉，甚至有点俗气。原因在于中文的“操作”这个词：提到操作员，通常让人想起操作车床、磨床和起重机的穿着油腻工作服的工人，这自然让人兴奋不起来。将英文的Operating翻译为中文的“操作”，是因为翻译的人没有理解英文Operating Systems（OS，操作系统）这个名字所蕴涵的精髓。那么英文的Operating Systems意味着什么呢？各位见过手术过程吗？在手术室里，主刀大夫称为Operating Surgeon。在整个手术过程中，主刀大夫具有至高无上的权威：他说要打麻药，麻醉师便要赶紧打麻药；他说需要手术钳，助理大夫就赶忙递给他手术钳；他说需要止血，护士就要忙不迭地拿止血药棉来止血。整个手术最关键的部分，切开皮肤、拿掉器官、安装移植器官等均由主刀大夫完成。当然，主刀大夫有时候也会将某些任务，如缝合创口，交给助理大夫或护士来做，但整个手术的过程皆由其主控。一句话，Operating Surgeon就是掌控整个手术过程、具有精湛技术和敏锐判断力的医师。
-
-引申至非医学领域，Operating Person意思是操刀手，就是掌控事情的人。再将Person这个词换成System，则Operating Systems指的就是掌控局势的一种系统。也就是说计算机里面的一切事情均由Operating Systems来掌控。那么，我们现在面临两个问题：第一个问题是，操作系统到底是什么东西？第二个问题是，操作系统到底操控什么事情？我们先回答第一个问题。既然操作系统是掌控计算机局势的一个系统，自然很重要。但这个说法并不能帮助读者理解操作系统，也无法形成有形的概念。如果我们换个说法：操作系统是介于计算机和应用软件之间的一个软件系统，则概念就具体多了。从这个定义出发，我们知道操作系统的上面和下面都有别的对象存在：下面是硬件平台，上面是应用软件，现在回答第二个问题。我们知道操作系统代表的是掌控事情的系统，掌控什么事情呢？当然是计算机上或计算机里发生的一切事情。最原始的计算机并没有操作系统，而是直接由人来掌控事情，即所谓的单一控制终端、单一操作员模式。但是随着计算机复杂性的增长，人已经不能胜任直接掌控计算机了。于是我们编写出操作系统这个“软件”来掌控计算机，将人类从日益复杂的掌控任务中解脱出来。这个掌控有着多层深远的意义。首先，由于计算机的功能和复杂性不断发生变化（趋向更加复杂），操作系统所掌控的事情也就越来越多，越来越复杂。同时，操作系统本身能够使用的资源也不断增多（如内存容量）。这是早期驱动操作系统不断改善的根本原因。其次，既然操作系统是专门掌控计算机的，那么计算机上发生的所有事情自然需要操作系统的知晓和许可，未经操作系统同意的任何事情均视为非法的，也就是病毒和入侵攻击所试图运作的事情。作为操作系统的设计人员，我们当然要确保计算机不发生任何我们不知情或不同意的事情。但是人的能力是有限的，人的思维也是有缺陷的，我们设计出的系统自然不会十全十美，也会有缺陷，这就给了攻击者可乘之机。操作系统设计人员和攻击者之间的博弈是当前驱动操作系统改善的一个重要动力。再次，掌控事情的水平有高低之分，有效率不同之分。就像手术大夫之间也有水平高低之分。为了更好地掌控事情，同时也为了更好地满足人类永不知足的各种越来越苛刻的要求，操作系统自然需要不断改善。这种改善在过去、现在和将来都会继续下去的。最后，我们可以给操作系统下定义了：操作系统是一个软件系统；操作系统使计算机变得好用（将人类从繁琐、复杂的对机器掌控的任务中解脱）；操作系统使计算机运作变得有序（操作系统掌控计算机上所有的事情）。总结起来就是：操作系统是掌控计算机上所有事情的软件系统。
+操作系统(Operating System, 简称OS)是管理和控制计算机硬件与软件资源的计算机程序。    
+它是一种由引导程序（bootloader）启动并管理计算机中所有程序生命周期的系统程序。    
+任何其他软件都必须在操作系统的支持下才能运行，操作系统能有效组织和管理系统中的各种软、硬件资源，合理组织计算机系统的工作流程并控制程序的执行，为用户提供一个良好的操作环境。    
+ 目前比较为人所知的操作系统有Microsoft的Windows系统、Apple的Mac及以Linux为内核的各种Linux发行版(Centos/Ubuntu等)。    
+ 现代计算机系统由一个或多个处理器、主存、打印机、键盘、鼠标、显示器、网络接口及各种输入\输出设备构成。
+
+
+操作系统这个术语听上去稀松平常，并不给人任何兴奋的感觉，甚至有点俗气。    
+原因在于中文的“操作”这个词：提到操作员，通常让人想起操作车床、磨床和起重机的穿着油腻工作服的工人，这自然让人兴奋不起来。    
+将英文的Operating翻译为中文的“操作”，是因为翻译的人没有理解英文Operating Systems（OS，操作系统）这个名字所蕴涵的精髓。    
+那么英文的Operating Systems意味着什么呢？各位见过手术过程吗？在手术室里，主刀大夫称为Operating Surgeon。在整个手术过程中，主刀大夫具有至高无上的权威：他说要打麻药，麻醉师便要赶紧打麻药；他说需要手术钳，助理大夫就赶忙递给他手术钳；他说需要止血，护士就要忙不迭地拿止血药棉来止血。整个手术最关键的部分，切开皮肤、拿掉器官、安装移植器官等均由主刀大夫完成。当然，主刀大夫有时候也会将某些任务，如缝合创口，交给助理大夫或护士来做，但整个手术的过程皆由其主控。    
+一句话，Operating Surgeon就是掌控整个手术过程、具有精湛技术和敏锐判断力的医师。
+
+引申至非医学领域，Operating Person意思是操刀手，就是掌控事情的人。再将Person这个词换成System，则Operating Systems指的就是掌控局势的一种系统。也就是说计算机里面的一切事情均由Operating Systems来掌控。    
+那么，我们现在面临两个问题：    
+第一个问题是，操作系统到底是什么东西？    
+第二个问题是，操作系统到底操控什么事情？    
+我们先回答第一个问题。既然操作系统是掌控计算机局势的一个系统，自然很重要。但这个说法并不能帮助读者理解操作系统，也无法形成有形的概念。    
+如果我们换个说法：操作系统是介于计算机和应用软件之间的一个软件系统，则概念就具体多了。    
+从这个定义出发，我们知道操作系统的上面和下面都有别的对象存在：下面是硬件平台，上面是应用软件，现在回答第二个问题。我们知道操作系统代表的是掌控事情的系统，掌控什么事情呢？当然是计算机上或计算机里发生的一切事情。最原始的计算机并没有操作系统，而是直接由人来掌控事情，即所谓的单一控制终端、单一操作员模式。但是随着计算机复杂性的增长，人已经不能胜任直接掌控计算机了。于是我们编写出操作系统这个“软件”来掌控计算机，将人类从日益复杂的掌控任务中解脱出来。    
+这个掌控有着多层深远的意义。首先，由于计算机的功能和复杂性不断发生变化（趋向更加复杂），操作系统所掌控的事情也就越来越多，越来越复杂。同时，操作系统本身能够使用的资源也不断增多（如内存容量）。    
+这是早期驱动操作系统不断改善的根本原因。其次，既然操作系统是专门掌控计算机的，那么计算机上发生的所有事情自然需要操作系统的知晓和许可，未经操作系统同意的任何事情均视为非法的，也就是病毒和入侵攻击所试图运作的事情。作为操作系统的设计人员，我们当然要确保计算机不发生任何我们不知情或不同意的事情。但是人的能力是有限的，人的思维也是有缺陷的，我们设计出的系统自然不会十全十美，也会有缺陷，这就给了攻击者可乘之机。    
+操作系统设计人员和攻击者之间的博弈是当前驱动操作系统改善的一个重要动力。再次，掌控事情的水平有高低之分，有效率不同之分。就像手术大夫之间也有水平高低之分。为了更好地掌控事情，同时也为了更好地满足人类永不知足的各种越来越苛刻的要求，操作系统自然需要不断改善。这种改善在过去、现在和将来都会继续下去的。    
+最后，我们可以给操作系统下定义了：    
+操作系统是一个软件系统；    
+操作系统使计算机变得好用（将人类从繁琐、复杂的对机器掌控的任务中解脱）；    
+操作系统使计算机运作变得有序（操作系统掌控计算机上所有的事情）。    
+总结起来就是：操作系统是掌控计算机上所有事情的软件系统。
 
 
 作用:它可以帮我们管理计算机的各种资源，协助我们完成各种复杂繁琐的任务。
 
 ### 操作系统三要素: 
 
-- 虚拟化（virtualization）
-    操作系统将物理（physical）资源（如处理器、内存或磁盘）转换为更通用、更强大且更易于使用的虚拟形式。因此，我们有时将操作系统称为虚拟机（virtual machine）。
+- 虚拟化（virtualization）    
+    操作系统将物理（physical）资源（如处理器、内存或磁盘）转换为更通用、更强大且更易于使用的虚拟形式。因此，我们有时将操作系统称为虚拟机（virtual machine）。    
+
     当然，为了让用户可以告诉操作系统做什么，从而利用虚拟机的功能（如运行程序、分配内存或访问文件），操作系统还提供了一些接口（API），供你调用。实际上，典型的操作系统会提供几百个系统调用（system call），让应用程序调用。由于操作系统提供这些调用来运行程序、访问内存和设备，并进行其他相关操作，我们有时也会说操作系统为应用程序提供了一个标准库（standard library）。
     
     最后，因为虚拟化让许多程序运行（从而共享CPU），让许多程序可以同时访问自己的指令和数据（从而共享内存），让许多程序访问设备（从而共享磁盘等），所以操作系统有时被称为资源管理器（resource manager）。每个CPU、内存和磁盘都是系统的资源（resource），因此操作系统扮演的主要角色就是管理（manage）这些资源，以做到高效或公平，或者实际上考虑其他许多可能的目标。

From 3b3b828252af6265ca07379060ce9f15a5fa6731 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 24 Apr 2023 10:41:57 +0800
Subject: [PATCH 101/213] update

---
 ...47\273\237\347\256\200\344\273\213.md.swp" | Bin 0 -> 49152 bytes
 ...43\344\270\216\347\241\254\350\247\243.md" |  14 ++---
 .../1.FFmpeg\347\256\200\344\273\213.md"      |  23 +++++----
 ...50\345\221\275\344\273\244\350\241\214.md" |   6 +--
 .../\345\205\263\351\224\256\345\270\247.md"  |  48 +++---------------
 .../HLS.md"                                   |   4 +-
 .../HTTP FLV.md"                              |  10 +---
 ...05\345\256\271\346\200\273\347\273\223.md" |   4 +-
 8 files changed, 37 insertions(+), 72 deletions(-)
 create mode 100644 "OperatingSystem/.1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md.swp"

diff --git "a/OperatingSystem/.1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md.swp" "b/OperatingSystem/.1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md.swp"
new file mode 100644
index 0000000000000000000000000000000000000000..60c2cbee68d88f536c7213cd55151f2b89666cdb
GIT binary patch
literal 49152
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

literal 0
HcmV?d00001

diff --git "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/\350\247\206\351\242\221\350\247\243\347\240\201\344\271\213\350\275\257\350\247\243\344\270\216\347\241\254\350\247\243.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/\350\247\206\351\242\221\350\247\243\347\240\201\344\271\213\350\275\257\350\247\243\344\270\216\347\241\254\350\247\243.md"
index bbeff659..94721c34 100644
--- "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/\350\247\206\351\242\221\350\247\243\347\240\201\344\271\213\350\275\257\350\247\243\344\270\216\347\241\254\350\247\243.md"
+++ "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/\350\247\206\351\242\221\350\247\243\347\240\201\344\271\213\350\275\257\350\247\243\344\270\216\347\241\254\350\247\243.md"
@@ -8,19 +8,19 @@
 既然有这两种不同的解码方式，我们在开发中该如何进行选择？哪个更好？                     
 
 - 硬解优缺点：                      
-	显卡核心GPU拥有独特的计算方法，解码效率非常高，而且充当解码核心的模块成本并不高。这样不但能够减轻CPU的负担，还有着低功耗、发热少等特点。但是由于硬解码起步比较晚，
-	软件和驱动对其的支持度低。硬解码内置有什么样的模块就能够解码什么样的视频，面对网络上杂乱无章的视频编码格式，不可能做到完全兼容同。此外，硬解码的滤镜、字母、画质增强方面都做的十分不足。
+    显卡核心GPU拥有独特的计算方法，解码效率非常高，而且充当解码核心的模块成本并不高。这样不但能够减轻CPU的负担，还有着低功耗、发热少等特点。但是由于硬解码起步比较晚，
+    软件和驱动对其的支持度低。硬解码内置有什么样的模块就能够解码什么样的视频，面对网络上杂乱无章的视频编码格式，不可能做到完全兼容同。此外，硬解码的滤镜、字幕、画质增强方面都做的十分不足。
                                
     优点：低功耗、发热少、效率高。              
-	缺点：视频兼容性差、支持度低。                
+    缺点：视频兼容性差、支持度低。                
 
 - 软解优缺点：                    
     软解码技术的解码过程中，需要对大量的视频信息进行运算，对CPU性能的要求非常高。尤其是对高清晰度大码率的视频来说，巨大的运算量就会造成转换效率低、发热量大等问题。
-	但是由于软解码的过程中不需要复杂的硬件支持，兼容性非常高。即使是新出的视频编码格式，只要安装好相应的解码器文件，就能顺利播放。而且软解码拥有丰富的滤镜、字幕、画面处理优化等效果，
-	如果`CPU`足够强悍的话，能够实现更加出色的画面效果。
+    但是由于软解码的过程中不需要复杂的硬件支持，兼容性非常高。即使是新出的视频编码格式，只要安装好相应的解码器文件，就能顺利播放。而且软解码拥有丰富的滤镜、字幕、画面处理优化等效果，
+    如果`CPU`足够强悍的话，能够实现更加出色的画面效果。
 	                  
     优点：  兼容强、全解码、效果好              
-	缺点：  对`CPU`要求高、效率低、发热大                 
+    缺点：  对`CPU`要求高、效率低、发热大                 
 
 	          
 关于软解与硬解究竟哪个更好的问题一直是争论的热点，其实我倒是感觉没有好坏之分，各自有各自的优缺点和使用条件，根据需要去选择才是最合适的。 
@@ -31,4 +31,4 @@
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/VideoDevelopment/FFmpeg/1.FFmpeg\347\256\200\344\273\213.md" "b/VideoDevelopment/FFmpeg/1.FFmpeg\347\256\200\344\273\213.md"
index 16e0c81b..86536a43 100644
--- "a/VideoDevelopment/FFmpeg/1.FFmpeg\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/FFmpeg/1.FFmpeg\347\256\200\344\273\213.md"
@@ -4,19 +4,19 @@
 FFmpeg是一个开源免费跨平台的视频和音频流方案，属于自由软件，采用LGPL或GPL许可证（依据你选择的组件）。它提供了录制、转换以及流化音视频的完整解决方案。它包含了非常先进的音频/视频编解码库libavcodec，为了保证高可移植性和编解码质量，libavcodec里很多codec都是从头开发的。
 
 FFmpeg框架的基本组成包含： 
-- AVFormat
+- AVFormat    
     AVFormat中实现了目前多媒体领域中的绝大多数媒体封装格式，包括封装和解封装，如MP4、FLV、KV、TS等文件封装格式，RTMP、RTSP、MMS、HLS等网络协议封装格式。FFmpeg是否支持某种媒体封装格式，取决于编译时是否包含了该格式的封装库。根据实际需求，可进行媒体封装格式的扩展，增加自己定制的封装格式，即在AVFormat中增加自己的封装处理模块。
-- AVCodec
+- AVCodec    
     AVCodec中实现了目前多媒体领域绝大多数常用的编解码格式，既支持编码，也支持解码。AVCodec除了支持MPEG4、AAC、MJPEG等自带的媒体编解码格式之外，还支持第三方的编解码器，如H.264（AVC）编码，需要使用x264编码器；H.265（HEVC）编码，需要使用x265编码器；MP3（mp3lame）编码，需要使用libmp3lame编码器。如果希望增加自己的编码格式，或者硬件编解码，则需要在AVCodec中增加相应的编解码模块
-- AVFilter
+- AVFilter    
     AVFilter库提供了一个通用的音频、视频、字幕等滤镜处理框架。在AVFilter中，滤镜框架可以有多个输入和多个输出。
-- AVDevice
+- AVDevice    
     读取电脑（或者其他设备上）的多媒体设备的数据 或者输出数据到指定的多媒体设备上；
-- AVUtil
+- AVUtil    
     包含一些公共的工具函数，包括随机数生成、数据结构、核心多媒体工具等；
-- swscale
+- swscale    
     swscale模块提供了高级别的图像转换API，例如它允许进行图像缩放和像素格式转换，常见于将图像从1080p转换成720p或者480p等的缩放，或者将图像数据从YUV420P转换成YUYV，或者YUV转RGB等图像格式转换。
-- swresample
+- swresample    
     用于音频采样采样数据（PCM）转换的库,提供了高级别的音频重采样API。
 
 
@@ -45,8 +45,11 @@ ffmpeg的主要工作流程相对比较简单，具体如下：
 
 
 ffmpeg整体处理的工作流程与步骤为： 
-读取文件 → 解封装 → 解码 → 转换参数 → 新编码 → 封装 → 写入文件
-ffmpeg首先读取输入源；然后通过Demuxer将音视频包进行解封装，这个动作通过调用libavformat中的接口即可实现；接下来通过Decoder进行解码，将音视频通过Decoder解包成为YVU或者PCM这样的数据，Decoder通过libavcodec中的接口即可实现；然后通过Encoder将对应的数据进行编码，编码可以通过libavcodec中的接口来实现；接下来将编码后的音视频数据包通过Muxer进行封装，Muxer封装通过libavformat中的接口即可实现，输出成为输出流。
+读取文件 → 解封装 → 解码 → 转换参数 → 新编码 → 封装 → 写入文件    
+ffmpeg首先读取输入源；    
+然后通过Demuxer将音视频包进行解封装，这个动作通过调用libavformat中的接口即可实现；    
+接下来通过Decoder进行解码，将音视频通过Decoder解包成为YVU或者PCM这样的数据，Decoder通过libavcodec中的接口即可实现；    
+然后通过Encoder将对应的数据进行编码，编码可以通过libavcodec中的接口来实现； 接下来将编码后的音视频数据包通过Muxer进行封装，Muxer封装通过libavformat中的接口即可实现，输出成为输出流。
 
 
 
@@ -54,4 +57,4 @@ ffmpeg首先读取输入源；然后通过Demuxer将音视频包进行解封装
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/VideoDevelopment/FFmpeg/2.FFmpeg\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214.md" "b/VideoDevelopment/FFmpeg/2.FFmpeg\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214.md"
index 4ee12b4e..4b0fe7aa 100644
--- "a/VideoDevelopment/FFmpeg/2.FFmpeg\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214.md"
+++ "b/VideoDevelopment/FFmpeg/2.FFmpeg\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214.md"
@@ -45,8 +45,8 @@ ffmpeg –s w*h –pix_fmt yuv420p –i input.yuv –vcodec mpeg4 output.avi
 ```
 常用参数说明：
 
-主要参数：-i 设定输入流 -f 设定输出格式 -ss 开始时间
-视频参数：-b 设定视频流量，默认为200Kbit/s -r 设定帧速率，默认为25 -s 设定画面的宽与高 -aspect 设定画面的比例 -vn 不处理视频 -vcodec 设定视频编解码器，未设定时则使用与输入流相同的编解码器
+主要参数：-i 设定输入流 -f 设定输出格式 -ss 开始时间     
+视频参数：-b 设定视频流量，默认为200Kbit/s -r 设定帧速率，默认为25 -s 设定画面的宽与高 -aspect 设定画面的比例 -vn 不处理视频 -vcodec 设定视频编解码器，未设定时则使用与输入流相同的编解码器    
 音频参数：-ar 设定采样率 -ac 设定声音的Channel数 -acodec 设定声音编解码器，未设定时则使用与输入流相同的编解码器 -an 不处理音频
 
 
@@ -498,4 +498,4 @@ stream字段说明：
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/VideoDevelopment/\345\205\263\351\224\256\345\270\247.md" "b/VideoDevelopment/\345\205\263\351\224\256\345\270\247.md"
index a3884aec..d4ad6c16 100644
--- "a/VideoDevelopment/\345\205\263\351\224\256\345\270\247.md"
+++ "b/VideoDevelopment/\345\205\263\351\224\256\345\270\247.md"
@@ -5,7 +5,7 @@
 
 ### I、P、B帧
 
-在H.264协议中定义了3中帧，完整编码的帧叫I帧、参考之前的I帧生成的只对差异部分进行编码的帧叫P帧、还有一种参考前后的帧进行编码的帧叫B帧。
+在H.264协议中定义了3种帧，完整编码的帧叫I帧、参考之前的I帧生成的只对差异部分进行编码的帧叫P帧、还有一种参考前后的帧进行编码的帧叫B帧。
 
 - I帧(Intra coded picture):帧内编码图像帧简称关键帧，这一帧画面的完整保留，解码时只需要本帧数据就可以完成.I帧通常是每个GOP(MPEG所使用的一种视频压缩技术)的第一个，GOP就是指两个I帧之间的距离。
 
@@ -19,7 +19,7 @@
 
 ### GOP
 
-这3中帧用于表示传输的视频画面。在H.264中图像以序列为单位进行组织，一个序列是一段图像编码后的数据流，以I帧开始，到下一个I帧结束，中间部分也被称为一个GOP。     
+这3种帧用于表示传输的视频画面。在H.264中图像以序列为单位进行组织，一个序列是一段图像编码后的数据流，以I帧开始，到下一个I帧结束，中间部分也被称为一个GOP。     
 
 GOP(Group of Pictures)是一组连续的画面，由一张I帧和数张B/P帧组成，是视频图像编码器和解码器存取的基本单位，它的排列顺序将会一直重复到影像结束。
 编码器将多张图像进行编码后生产成一段一段的 GOP ，解码器在播放时则是读取一段一段的GOP进行解码后读取画面再渲染显示。
@@ -28,15 +28,13 @@ GOP(Group of Pictures)是一组连续的画面，由一张I帧和数张B/P帧组
 
 ### IDR
 
+IDR（Instantaneous Decoding Refresh）是H.264视频编码中的一种特殊的I帧。它包含了所有的视频序列信息，并且通过强制性地要求解码器重新初始化来保证解码正确性。IDR通常用于视频流中断或丢失时，重新恢复视频流的一种方式。
+
+总之，I帧是视频序列中的一种关键帧，它能够独立解码，而IDR是一种特殊的I帧，具有重新初始化解码器的特殊作用。
+
 一个序列(GOP)的第一个图像叫做IDR图像(立即刷新图像)，IDR图像都是I帧图像。H.264引入IDR图像是为了解码的重新同步，当解码器解码到IDR图像时，立即将参考帧队列清空，将已解码的数据全部输出或抛弃，重新查找下一个参考集，开始解码一个新的序列。这样，如果前一个序列出现重大错误，在这里可以获得重新同步的机会。IDR图像之后的图像永远不会使用IDR之前的图像数据来解码。一个序列就是一段内容差异不太大的图像编码后生成的一串数据流。当运动变化比较少时，一个序列可以很长，因为运动变化少就代表图像画面的内容变动很小，所以就可以是一个I帧，然后一直是P帧、B帧。当运动变化多时，一个序列可能会比较短，比如只包含一个I帧和几个P帧、B帧。
 
-- IDR（Instantaneous Decoding Refresh）--即时解码刷新。
-     I帧:帧内编码帧是一种自带全部信息的独立帧，无需参考其它图像便可独立进行解码，视频序列中的第一个帧始终都是I帧。
-     
-     那么IDR帧与I帧的区别是什么呢?因为H264采用了多帧预测，所以I帧之后的P帧有可能会参考I 帧之前的帧，这就使得在随机访问的时候不能以找到I帧作为参考条 件，因为即使找到I帧，I帧之后的帧还是有可能解析不出来，而IDR帧 就是一种特殊的I帧，即这一帧之后的所有参考帧只会参考到这个IDR 帧，而不会再参考前面的帧。在解码器中，一旦收到一个IDR帧，就会 立即清理参考帧缓冲区，并将IDR帧作为被参考的帧。
-     
-     
-     
+     那么IDR帧与I帧的区别是什么呢?因为H264采用了多帧预测，所以I帧之后的P帧有可能会参考I 帧之前的帧，这就使得在随机访问的时候不能以找到I帧作为参考条件，因为即使找到I帧，I帧之后的帧还是有可能解析不出来，而IDR帧 就是一种特殊的I帧，即这一帧之后的所有参考帧只会参考到这个IDR 帧，而不会再参考前面的帧。在解码器中，一旦收到一个IDR帧，就会 立即清理参考帧缓冲区，并将IDR帧作为被参考的帧。
      I和IDR帧都是使用帧内预测的。它们都是同一个东西而已,在编码和解码中为了方便，要首个I帧和其他I帧区别开，所以才把第一个首个I帧叫IDR，这样就方便控制编码和解码流程。 IDR帧的作用是立刻刷新,使错误不致传播,从IDR帧开始,重新算一个新的序列开始编码。而I帧不具有随机访问的能力，这个功能是由IDR承担。  IDR会导致DPB（DecodedPictureBuffer  参考帧列表——这是关键所在）清空，而I不会。IDR图像一定是I图像，但I图像不一定是IDR图像。一个序列中可以有很多的I图像，I图像之后的图像可以引用I图像之间的图像做运动参考。一个序列中可以有很多的I图像，I图像之后的图象可以引用I图像之间的图像做运动参考。
      对于IDR帧来说，在IDR帧之后的所有帧都不能引用任何IDR帧之前的帧的内容，与此相反，对于普通的I-帧来说，位于其之后的B-和P-帧可以引用位于普通I-帧之前的I-帧。从随机存取的视频流中，播放器永远可以从一个IDR帧播放，因为在它之后没有任何帧引用之前的帧。但是，不能在一个没有IDR帧的视频中从任意点开始播放，因为后面的帧总是会引用前面的帧 。
      收到 IDR 帧时，解码器另外需要做的工作就是：把所有的 PPS 和 SPS 参数进行更新。
@@ -55,8 +53,6 @@ I帧 : P帧 : B帧 = 7 ：20 : 50
 
 P帧和B帧极大的节省了数据量，节省出来的空间可以用来多保存一些I帧，以实现在相同码率下，提供更好的画质。    
 
-
-
 ### PTS和DTS
 
 【为什么会有PTS和DTS的概念】
@@ -78,33 +74,5 @@ PTS（Presentation Time Stamp）：即**显示时间戳**，这个时间戳用
 
 
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
----
-
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HLS.md" "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HLS.md"
index b2f222a2..852cfb03 100644
--- "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HLS.md"
+++ "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HLS.md"
@@ -55,11 +55,11 @@ TS(Transport Stream)，全程为MPEG2-TS。它的特点就是要求从视频流
 
 - Media encoder(媒体编码)
 
-媒体编码器获取到音视频设备的实时信号，将其编码后压缩用于传输
+    媒体编码器获取到音视频设备的实时信号，将其编码后压缩用于传输
 
 - Stream segmenter(流切片器)
 
-  通常是一个软件，将流进行切片，切片的同时会创建一个索引文件(index file)，索引文件会包含这些切片的引用。
+    通常是一个软件，将流进行切片，切片的同时会创建一个索引文件(index file)，索引文件会包含这些切片的引用。
 
 从左到右讲，左下方的inputs的视频源是什么格式都无所谓，他与server之间的通信协议也可以任意（比如RTMP），总之只要把视频数据传输到服务器上即可。这个视频在server服务器上被转换成HLS格式的视频（既TS和m3u8文件）文件。细拆分来看server里面的Media encoder的是一个转码模块负责将视频源中的视频数据转码到目标编码格式（H264）的视频数据，视频源的编码格式可以是任何的视频编码格式。转码成H264视频数据之后用硬件打包到MPEG-2(MPEG-2 Transport Stream)的传输流中，传输流再经过stream segmenter模块，它的工作是把MPEG-2传输流分散为小片段然后保存为一个或多个系列的.ts格式的媒体文件，结果就是index file（m3u8）和ts文件了。图中的Distribution其实只是一个普通的HTTP文件服务器，然后客户端只需要访问一级index文件的路径就会自动播放HLS视频流了。
 
diff --git "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HTTP FLV.md" "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HTTP FLV.md"
index 0f90bba7..9cbdf178 100644
--- "a/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HTTP FLV.md"	
+++ "b/VideoDevelopment/\346\265\201\345\252\222\344\275\223\345\215\217\350\256\256/HTTP FLV.md"	
@@ -7,15 +7,9 @@ HTTP FLV
 
 FLV（Flash  Video）是Adobe公司设计开发的一种流行的流媒体格式，其格式相对简单轻量，不需要很大的媒体头部信息。整个FLV由Header和Body以及其他Tag组成。因此加载速度极快。它是基于HTTP/80传输，可以避免被防火墙拦截的问题，除此之外，它可以通过 HTTP 302 跳转灵活调度/负载均衡，支持使用 HTTPS 加密传输，也能够兼容支持 Android，iOS 的移动端。但是由于它的传输特性，会让流媒体资源缓存在本地客户端，在保密性方面不够好，因为网络流量较大，它也不适合做拉流协议。此外，FLV可以使用Flash Player进行播放，而Flash  Player插件已经安装在绝大部分浏览器上，这使得通过网页播放FLV视频十分容易。FLV封装格式的文件后缀通常为“.flv”。
 
-
-
-先看看HTTP-FLV长成什么样子：http://ip:port/live/livestream.flv，协议头是http,另外”.flv”这个尾巴是它最明显的特征。
-
 HttpFlv 就是 http+flv ，将音视频数据封装成FLV格式，然后通过 HTTP 协议传输给客户端。
 
-
-
-下的直播平台中大部分的主线路使用的都是HTTP-FLV协议，备线路多为RTMP。小编随便在Safari中打开几个直播平台房间，一抓包就不难发现使用HTTP-FLV协议的身影：熊猫、斗鱼、虎牙、B站。
+当下的直播平台中大部分的主线路使用的都是HTTP-FLV协议，备线路多为RTMP。小编随便在Safari中打开几个直播平台房间，一抓包就不难发现使用HTTP-FLV协议的身影：熊猫、斗鱼、虎牙、B站。
 
 
 
@@ -87,4 +81,4 @@ https://blog.csdn.net/qq_37382077/article/details/103386289
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\346\222\255\346\224\276\347\233\270\345\205\263\345\206\205\345\256\271\346\200\273\347\273\223.md" "b/VideoDevelopment/\350\247\206\351\242\221\346\222\255\346\224\276\347\233\270\345\205\263\345\206\205\345\256\271\346\200\273\347\273\223.md"
index 7d36e85b..5b7375cd 100644
--- "a/VideoDevelopment/\350\247\206\351\242\221\346\222\255\346\224\276\347\233\270\345\205\263\345\206\205\345\256\271\346\200\273\347\273\223.md"
+++ "b/VideoDevelopment/\350\247\206\351\242\221\346\222\255\346\224\276\347\233\270\345\205\263\345\206\205\345\256\271\346\200\273\347\273\223.md"
@@ -97,7 +97,7 @@
 
 ## `SurfaceHolder`简介
 
-显示一个`Surface`的抽象接口，使你可以控制`Surface`的大小和格式以及在`Surface`上编辑像素，和监视`Surace`的改变。这个接口通常通过`SurfaceView`类实现。
+显示一个`Surface`的抽象接口，使你可以控制`Surface`的大小和格式以及在`Surface`上编辑像素，和监视`Surface`的改变。这个接口通常通过`SurfaceView`类实现。
 简单的说就是我们无法直接操作`Surface`只能通过`SurfaceHolder`这个接口来获取和操作`Surface`。
 `SurfaceHolder`中提供了一些`lockCanvas()`:获取一个`Canvas`对象，并锁定之。所得到的`Canvas`对象，其实就是`Surface`中一个成员。加锁的目的其实就是为了在绘制的过程中，
 `Surface`中的数据不会被改变。`lockCanvas`是为了防止同一时刻多个线程对同一`canvas`写入。
@@ -127,4 +127,4 @@
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 

From 42f37816cbcd24e6680dfa7eb4cb00ea0c4a4638 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 24 Apr 2023 12:00:36 +0800
Subject: [PATCH 102/213] update OpenGL part1

---
 .../OpenGL/1.OpenGL\347\256\200\344\273\213.md"          | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
index 777ec332..89fce18a 100644
--- "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -25,14 +25,14 @@ OpenGL的前身是硅谷图形功能(SGI)公司为其图形工作站开发的IRI
 
 OpenGL ES是免费的跨平台的功能完善的2D/3D图形库接口的API,是OpenGL的一个子集,主要针对手机、Pad和游戏主机等嵌入式设备而设计。
 
-移动端使用到的基本上都是OpenGl ES，当然Android开发下还专门为OpenGl提供了android.opengl包，并且提供了GlSurfaceView,GLU,GlUtils等工具类。
+移动端使用到的基本上都是OpenGL ES，当然Android开发下还专门为OpenGL提供了android.opengl包，并且提供了GlSurfaceView,GLU,GlUtils等工具类。
 
 
 
 ### OpenGL的作用
 
 在手机上有两大元件，一个是CPU,一个是GPU。显示图形界面也有两种方式，一个是使用CPU渲染，一个是使用GPU渲染，但是目前为止最高效的方法就是有效的使用图形处理单元(GPU)，
-图像的处理和渲染就是在将要渲染到窗口上的像素上做很多的浮点匀速，而GPU可以并行的做浮点运算，所以用GPU来分担CPU的部分，可以提高效率，可以说GPU渲染其实是一种硬件加速。
+图像的处理和渲染就是在将要渲染到窗口上的像素上做很多的浮点运算，而GPU可以并行的做浮点运算，所以用GPU来分担CPU的部分，可以提高效率，可以说GPU渲染其实是一种硬件加速。
 
 - 图片处理:比如图片色调转换、美颜等。
 - 摄像头预览效果处理。比如美颜相机、恶搞相机等。
@@ -175,7 +175,7 @@ OpenGL ES 3.0实现了具有可编程着色功能的图形管线，有两个规
 
 ### OpenGL Context
 
-OpenGL是一个仅仅关注图像渲染的图像接口库，在渲染过程中它需要将顶点信息、纹理信息、编译好的着色器等渲染状态信息存储起来，而存储这些信调用任何OpenGL函数前，必须先创建OpenGL Context，它存储了OpenGL的状态变量以及其他渲染有关的信息。OpenGL是个状态机，有很多状态变量，试个标准的过程式操作过程，改变状态会影响后续所有的操作，这和面向对象的解耦原则不符，毕竟渲染本身就是个复杂的过程。OpenGL采用Client-Server模型来解释OpenGL程序，即Server存储OpenGL Context，Client提出渲染请求，Server给予响应。之后的渲染工作就要依赖这些渲染状态信息来完成，当一个上下文被销毁时，它所对应的OpenGL渲染工作也将结束。
+OpenGL是一个仅仅关注图像渲染的图像接口库，在渲染过程中它需要将顶点信息、纹理信息、编译好的着色器等渲染状态信息存储起来，而存储这些信息调用任何OpenGL函数前，必须先创建OpenGL Context，它存储了OpenGL的状态变量以及其他渲染有关的信息。OpenGL是个状态机，有很多状态变量，是个标准的过程式操作过程，改变状态会影响后续所有的操作，这和面向对象的解耦原则不符，毕竟渲染本身就是个复杂的过程。OpenGL采用Client-Server模型来解释OpenGL程序，即Server存储OpenGL Context，Client提出渲染请求，Server给予响应。之后的渲染工作就要依赖这些渲染状态信息来完成，当一个上下文被销毁时，它所对应的OpenGL渲染工作也将结束。
 
 
 
@@ -226,9 +226,6 @@ Android 通过其框架 API 和原生开发套件 (NDK) 来支持 OpenGL。
 Android 框架中有如下两个基本类，用于通过 OpenGL ES API 来创建和操控图形：`GLSurfaceView` 和 `GLSurfaceView.Renderer`。
 
 
-
-
-
 ### 参考
 
 ---

From 8888b24892851fcac44f376f9c44fc4c88616079 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Tue, 25 Apr 2023 14:27:11 +0800
Subject: [PATCH 103/213] update OpenGl ES part

---
 VideoDevelopment/.DS_Store                    | Bin 6148 -> 0 bytes
 .../1.OpenGL\347\256\200\344\273\213.md"      |  27 ++++++-
 ...55\346\224\276\350\247\206\351\242\221.md" |  10 +--
 .../11.OpenGL ES\346\273\244\351\225\234.md"  |  27 +++++++
 ....GLSurfaceView\347\256\200\344\273\213.md" |   2 +-
 ...66\344\270\211\350\247\222\345\275\242.md" |  76 ++++++++++++++++--
 ...45\231\250\350\257\255\350\250\200GLSL.md" |  56 ++++++++++++-
 .../9.OpenGL ES\347\272\271\347\220\206.md"   |  20 +++--
 8 files changed, 191 insertions(+), 27 deletions(-)
 delete mode 100644 VideoDevelopment/.DS_Store

diff --git a/VideoDevelopment/.DS_Store b/VideoDevelopment/.DS_Store
deleted file mode 100644
index 5eb6b49d607f8326edeb9163d5c1a73b2c412c90..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6148
zcmeHK%}T>S5Z<-5O({YS3OxqA7K~N}@e*S70gUKDr6wfQV45vWY7V84v%Zi|;`2DO
zyEy~{-bCz7+5KkcXE*af_lGgY-DP;ln8_G3pdoTp8U)Rat}Pvm$mJXnn+8QT4-yeH
zO!OB``0X8b1-}`av-<ac1oI@$a@+poTdnqXr)zYLzVYZii^9wOe3`la;vPpgLL@<@
z`@wA-6%%v!LZrDLr_n+t#9;&>4|j1IiozAkG|XhKryNGl=uOPQYBjR$p*1?O*F$S{
zb_DwI=ybjA8GHK&=hu^$WR{9IMI;B#rR->|;2o4&O|RY}O+-2cdzDkg5)uQ%05L!e
zY#sypEHL_;S2|Tp3=ji9Fo64m1r5>BSSplT2XuISMt>U-1$2B%AX*w7jio~HfN+%x
zs8YFpVsMoXc1y=O8cT&LopHG`%%fMX9xq(34t7h1Gwvv)o){no>I}5h(8Tlq68<uc
zkNkQHjfeqa;GZ$T+hcF+LQ(o`{Z<~HwHCA|Xebz0q5=YX?GgY3+(!n|sr(k|5a(zt
V72+&tm+63X5s-vXM-2P|17AffOLG7K

diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
index 89fce18a..0f8f0c43 100644
--- "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -54,6 +54,11 @@ Android中OpenGL ES的版本支持如下:
 
 ###  渲染管线
 
+在OpenGL中，任何事物都在3D空间中，而屏幕和窗口却是2D像素数组，这导致OpenGL的大部分工作都是关于把3D坐标转变为适应你屏幕的2D像素。3D坐标转为2D坐标的处理过程是由OpenGL的图形渲染管线（Graphics Pipeline，大多译为管线，实际上指的是一堆原始图形数据途经一个输送管道，期间经过各种变化处理最终出现在屏幕的过程）管理的。图形渲染管线可以被划分为两个主要部分：第一部分把你的3D坐标转换为2D坐标，第二部分是把2D坐标转变为实际的有颜色的像素。
+
+图形渲染管线接受一组3D坐标，然后把它们转变为你屏幕上的有色2D像素输出。图形渲染管线可以被划分为几个阶段，每个阶段将会把前一个阶段的输出作为输入。所有这些阶段都是高度专门化的（它们都有一个特定的函数），并且很容易并行执行。正是由于它们具有并行执行的特性，当今大多数显卡都有成千上万的小处理核心，它们在GPU上为每一个（渲染管线）阶段运行各自的小程序，从而在图形渲染管线中快速处理你的数据。这些小程序叫做着色器(Shader)。
+
+简单来说，渲染管线就是一个顶点在呈现为像素之前经过的全部过程。
 OpenGL 1.x系列采用的是固定功能管线。
 
 OpenGL ES 2.0开始采用了可编程图形管线。
@@ -68,11 +73,13 @@ OpenGL ES 3.0实现了具有可编程着色功能的图形管线，有两个规
 
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/oepngl_es_pip.jpg)
 
+下面，你会看到一个图形渲染管线的每个阶段的抽象展示。要注意蓝色部分代表的是我们可以注入自定义的着色器的部分:
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_progress.jpg)
 
+首先，我们以数组的形式传递3个3D坐标作为图形渲染管线的输入，用来表示一个三角形，这个数组叫做顶点数据(Vertex Data)；顶点数据是一系列顶点的集合。一个顶点(Vertex)是一个3D坐标的数据的集合。而顶点数据是用顶点属性(Vertex Attribute)表示的，它可以包含任何我们想用的数据，但是简单起见，我们还是假定每个顶点只由一个3D位置和一些颜色值组成的吧。
 
 
-- 顶点着色器(Vertex Shader): 用来渲染图形顶点的OpenGL ES代码。生成每个顶点的最终位置
+- 顶点着色器(Vertex Shader): 图形渲染管线的第一个部分是顶点着色器，他是用来渲染图形顶点的OpenGL ES代码。它把一个单独的顶点作为输入。顶点着色器主要的目的是把3D坐标转为另一种3D坐标（后面会解释）从而生成每个顶点的最终位置，同时顶点着色器允许我们对顶点属性进行一些基本处理。
 
   着色器(shader)是在GPU上运行的小程序。从名称可以看出，可通过处理它们来处理顶点。此程序使用OpenGL ES SL语言来编写。它是一个描述顶点或像素特性的简单程序。OpenGL最本质的概念之一就是着色器，它是图形硬件设备所执行的一类特殊函数。理解着色器最好的办法就是把它看做是专为图形处理单元(即GPU)编译的一种小型程序。任何一种OpenGL程序本质上都可以被分为两部分：CPU端运行的部分，采用C++、Java之类的语言编写；以及GPU端运行的部分，使用GLSL语言编写。
 
@@ -80,7 +87,9 @@ OpenGL ES 3.0实现了具有可编程着色功能的图形管线，有两个规
 
 - 图元装配(Primitive Assembly)
 
-  顶点组合成图元的过程叫做图元装配，这里的图元就是指点、线、三角。OpenGL ES中最基础且唯一的多边形就是三角形，所有更复杂的图形都是由三角形组成的。复杂的图形都可以拆分成多个三角形。比如OpenGL提供给开发者的绘制方法glDrawArrays，这个方法的第一个参数就是指定绘制方式，可选值有:  
+    顶点组合成图元的过程叫做图元装配，这里的图元就是指点、线、三角。
+    图元装配阶段将顶点着色器输出的所有顶点作为输入(如果是GL_POINTS，那么就是一个顶点),并将所有的点装配成指定的图元的形状，上图的例子中是一个三角形。
+    OpenGL ES中最基础且唯一的多边形就是三角形，所有更复杂的图形都是由三角形组成的。复杂的图形都可以拆分成多个三角形。比如OpenGL提供给开发者的绘制方法glDrawArrays，这个方法的第一个参数就是指定绘制方式，可选值有:  
 
   - GL_POINTS:以点的形式绘制
   - GL_LINES:以线的形式绘制
@@ -91,7 +100,11 @@ OpenGL ES 3.0实现了具有可编程着色功能的图形管线，有两个规
   - 裁剪是指对于不在视椎体(屏幕上可见的3D区域)内的图元进行裁剪。
 
   - 淘汰是指根据图元面向前方或后方选择抛弃它们(如事物内部的点)。
+   
+- 几何着色器(Geometry Shader)     
+图元装配阶段的输出会传递给几何着色器(Geometry Shader)。几何着色器把图元形式的一系列顶点的集合作为输入，它可以通过产生新顶点构造出新的图元来生成其他形状。本例子中，它生成了另一个三角形。
 
+几何着色器的输出会被传入光栅化阶段(Rasterization Stage)，这里它会把图元映射为最终屏幕上相应的像素，生成供片段着色器(Fragment Shader)使用的片段(Fragment)。在片段着色器运行之前会执行裁切(Clipping)。裁切会丢弃超出你的视图以外的所有像素，用来提升执行效率。
 - 光栅化阶段(Rasterization Stage)
 
   这里会把图元映射为最终屏幕上相应的像素，生成供片段着色器(fragment shader)使用的片段。在图元装配后传递过来的图元数据中，这些图元信息只是顶点而已。顶点处都还没有像素点，直线段端点之间是空的、多边形的边和内部也是空的，光栅化的任务就是构造这些。将图片转化为片段(fragment)的过程叫做光栅化。 这个阶段会将图元数据分解成更小的单元并对应于帧缓冲区的各个像素，这些单元成为片元，一个片元可能包含窗口颜色、纹理坐标等属性。
@@ -104,6 +117,10 @@ OpenGL ES 3.0实现了具有可编程着色功能的图形管线，有两个规
 
   通常在这里对片段进行处理(纹理采样、颜色汇总等)，将每个片段的颜色等属性计算出来并送给后续阶段。
 
+可以看到，图形渲染管线非常复杂，它包含很多可配置的部分。然而，对于大多数场合，我们只需要配置顶点和片段着色器就行了。几何着色器是可选的，通常使用它默认的着色器就行了。
+
+在现代OpenGL中，我们必须定义至少一个顶点着色器和一个片段着色器（因为GPU中没有默认的顶点/片段着色器）。
+
 - 逐片段操作
 
   具体的细分步骤又分为:  
@@ -185,7 +202,11 @@ OpenGL ES API没有提及如何创建渲染上下文，或者渲染上下文如
 
 在OpenGL的设计中，OpenGL是不负责管理窗口的，窗口的管理交由各个设备自己完成。具体的来说就是iOS平台上使用EAGL提供本地平台对OpenGL的实现，在Android平台上使用EGL提供本地平台对OpenGL的实现。OpenGL其实是通过GPU进行渲染。但是我们的程序是运行在CPU上，要与GPU关联，这就需要通过EGL，它相当于Android上层应用于GPU通讯的中间层。
 
-EGL为双缓冲工作模式，既有一个Back Frame Buffer和一个Front Frame Buffer，正常绘制的目标都是Back Frame Buffer，绘制完成后再调用eglSwapBuffer API，将绘制完毕的FrameBuffer交换到Front Frame Buffer并显示出来。   
+EGL为双缓冲工作模式(Double Buffer)，既有一个Back Frame Buffer和一个Front Frame Buffer，正常绘制的目标都是Back Frame Buffer，绘制完成后再调用eglSwapBuffer API，将绘制完毕的FrameBuffer交换到Front Frame Buffer并显示出来。   
+
+补充说明： 
+应用程序使用单缓冲绘图时可能会存在图像闪烁的问题。这是因为生成的图像不是一下子被绘制出来的，而是按照从左到右，由上到下逐像素的绘制而成的。最终图像不是在瞬间显示给用户，而是通过一步一步生成的，这会导致渲染的结果很不真实。为了规避这些问题，就应用了双缓冲渲染模式，前缓冲保存着最终输出的图像，它会在屏幕上显示；而所有的渲染指令都会在后缓冲上绘制。当所有的渲染指令执行完毕后，我们交互前缓冲和后缓冲，这样图像就立即呈现出来，之前提到的不真实感就消除了。
+
 
 要在Android平台实现OpenGL渲染，需要完成一系列的EGL操作，主要为下面几步(后面分析GLSurfaceView源码的时候也是这样来实现的):   
 
diff --git "a/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md" "b/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
index 88ca3e35..995b49c2 100644
--- "a/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
+++ "b/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
@@ -2,13 +2,13 @@
 
 ### 视频播放
 
-平时的视频播放都是使用mediaplayer+textureview或者mediaplayer+surfaceview，但是如果我们要对视频进行一些OpenGL的操作，打个比方说我要在视频播放的时候添加一个滤镜，这个时候就需要用都SurfaceTexture了。
+平时的视频播放都是使用mediaplayer+textureview或者mediaplayer+surfaceview，但是如果我们要对视频进行一些OpenGL的操作，打个比方说我要在视频播放的时候添加一个滤镜，这个时候就需要用到SurfaceTexture了。
 
 大体步骤如下:
 
-GLSurfaceView -> setRender -> onSurfaceCreated回调方法中构造一个SurfaceTexture对象，然后设置到Camera预览或者MediaPlayer中 -> SurfaceTexture中的回调方法onFrameAvailable来得知一帧的数据真好完成 -> requestRender通知Render来绘制数据 -> 在Render的回调方法onDrawFrame中调用SurfaceTexture的updateTexImage方法来获取一帧数据，然后开始使用GL进行绘制预览。
+GLSurfaceView -> setRender -> onSurfaceCreated回调方法中构造一个SurfaceTexture对象，然后设置到Camera预览或者MediaPlayer中 -> SurfaceTexture中的回调方法onFrameAvailable来得知一帧的数据准备完成 -> requestRender通知Render来绘制数据 -> 在Render的回调方法onDrawFrame中调用SurfaceTexture的updateTexImage方法来获取一帧数据，然后开始使用GL进行绘制预览。
 
-​	具体步骤:  
+具体步骤:  
 
 1. 在GLSurfaceView.Render中创建一个纹理，再使用该纹理创建一个SurfaceTexture。
 2. 使用该SurfaceTexture创建一个Surface传给相机，相机预览数据就会输出到这个纹理上了。
@@ -317,11 +317,11 @@ public class VideoPlayerRender extends BaseGLSurfaceViewRenderer {
 
 下面是具体的效果分别是填充宽和填充高的效果:   
 
-<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_video_player1.jpeg" style="zoom:40%;" />
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_video_player1.jpeg" style="zoom:40%" />
 
 
 
-<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_video_player_2.jpeg" style="zoom:33%;" />
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_video_player_2.jpeg" style="zoom:33%" />
 
 
 
diff --git "a/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md" "b/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"
index ed330195..27d255aa 100644
--- "a/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"	
+++ "b/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"	
@@ -371,6 +371,33 @@ public class BaseFilter {
     }
 ```
 
+#### 常用概念整理
+- OpenGL： 一个定义了函数布局和输出的图形API的正式规范。
+- GLAD： 一个拓展加载库，用来为我们加载并设定所有OpenGL函数指针，从而让我们能够使用所有（现代）OpenGL函数。
+- 视口(Viewport)： 我们需要渲染的窗口。
+- 图形管线(Graphics Pipeline)： 一个顶点在呈现为像素之前经过的全部过程。
+- 着色器(Shader)： 一个运行在显卡上的小型程序。很多阶段的图形管道都可以使用自定义的着色器来代替原有的功能。
+- 标准化设备坐标(Normalized Device Coordinates, NDC)： 顶点在通过在剪裁坐标系中剪裁与透视除法后最终呈现在的坐标系。所有位置在NDC下-1.0到1.0的顶点将不会被丢弃并且可见。
+- 顶点缓冲对象(Vertex Buffer Object)： 一个调用显存并存储所有顶点数据供显卡使用的缓冲对象。
+- 顶点数组对象(Vertex Array Object)： 存储缓冲区和顶点属性状态。
+- 元素缓冲对象(Element Buffer Object，EBO)，也叫索引缓冲对象(Index Buffer Object，IBO)： 一个存储元素索引供索引化绘制使用的缓冲对象。
+- Uniform： 一个特殊类型的GLSL变量。它是全局的（在一个着色器程序中每一个着色器都能够访问uniform变量），并且只需要被设定一次。
+- 纹理(Texture)： 一种包裹着物体的特殊类型图像，给物体精细的视觉效果。
+- 纹理缠绕(Texture Wrapping)： 定义了一种当纹理顶点超出范围(0, 1)时指定OpenGL如何采样纹理的模式。
+- 纹理过滤(Texture Filtering)： 定义了一种当有多种纹素选择时指定OpenGL如何采样纹理的模式。这通常在纹理被放大情况下发生。
+- 多级渐远纹理(Mipmaps)： 被存储的材质的一些缩小版本，根据距观察者的距离会使用材质的合适大小。
+- 纹理单元(Texture Units)： 通过绑定纹理到不同纹理单元从而允许多个纹理在同一对象上渲染。
+- 向量(Vector)： 一个定义了在空间中方向和/或位置的数学实体。
+- 矩阵(Matrix)： 一个矩形阵列的数学表达式。
+- GLM： 一个为OpenGL打造的数学库。
+- 局部空间(Local Space)： 一个物体的初始空间。所有的坐标都是相对于物体的原点的。
+- 世界空间(World Space)： 所有的坐标都相对于全局原点。
+- 观察空间(View Space)： 所有的坐标都是从摄像机的视角观察的。
+- 裁剪空间(Clip Space)： 所有的坐标都是从摄像机视角观察的，但是该空间应用了投影。这个空间应该是一个顶点坐标最终的空间，作为顶点着色器的输出。OpenGL负责处理剩下的事情（裁剪/透视除法）。
+- 屏幕空间(Screen Space)： 所有的坐标都由屏幕视角来观察。坐标的范围是从0到屏幕的宽/高。
+- LookAt矩阵： 一种特殊类型的观察矩阵，它创建了一个坐标系，其中所有坐标都根据从一个位置正在观察目标的用户旋转或者平移。
+- 欧拉角(Euler Angles)： 被定义为偏航角(Yaw)，俯仰角(Pitch)，和滚转角(Roll)从而允许我们通过这三个值构造任何3D方向。
+
 
 
 [上一篇: 10.GLSurfaceView+MediaPlayer播放视频](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md)
diff --git "a/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
index dab69c89..65f48e61 100644
--- "a/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
@@ -114,7 +114,7 @@ class MyGLRenderer implements GLSurfaceView.Renderer {
 ```
 
 效果图就不贴了，就是一个纯绿色的Activity。
-
+上面glClearColor函数是一个状态设置函数，而glClear函数则是一个状态使用的函数，它使用了当前的状态来获取应该清除为的颜色
 Render接口重写的三个方法中调用了GLES31的API方法:   
 
 - glClearColor()：设置清空屏幕用的颜色，参数为RGBA。
diff --git "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md" "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"
index 6e9adc89..3a94df07 100644
--- "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
@@ -4,7 +4,22 @@ OpenGL ES的绘制需要有以下步骤:
 
 - 顶点输入
 
-  开始绘制图形之前，我们必须先给OpenGL输入一些顶点数据。OpenGL是一个3D图形库，所以我们在OpenGL中所指定的所有坐标都是3D坐标(xyz)。OpenGL并不是简单地把所有的3D坐标变换成屏幕上的2D像素。OpenGL仅当3D坐标在3个轴(xyz)上都为-1.0到1.0的范围内采取处理它。所有在所谓的标准化设备坐标范围内的坐标才会最终呈现到屏幕上(在这个范围以外的坐标都不会显示)。
+  开始绘制图形之前，我们必须先给OpenGL输入一些顶点数据。OpenGL是一个3D图形库，所以我们在OpenGL中所指定的所有坐标都是3D坐标(xyz)。OpenGL并不是简单地把所有的3D坐标变换成屏幕上的2D像素。OpenGL仅当3D坐标在3个轴(xyz)上都为-1.0到1.0的范围内才去处理它。所有在这个范围内的坐标叫做标准化设备坐标(Normalized Device Coordinates)，此范围内的坐标最终显示在屏幕上（在这个范围以外的坐标则不会显示）。
+
+由于我们希望渲染一个三角形，我们一共要指定三个顶点，每个顶点都有一个3D位置。我们会将它们以标准化设备坐标的形式（OpenGL的可见区域）定义为一个float数组。
+```glsl
+float vertices[] = {
+    -0.5f, -0.5f, 0.0f,
+     0.5f, -0.5f, 0.0f,
+     0.0f,  0.5f, 0.0f
+};
+```
+定义这样的顶点数据以后，我们会把它作为输入发送给图形渲染管线的第一个处理阶段：顶点着色器。它会在GPU上创建内存用于储存我们的顶点数据，还要配置OpenGL如何解释这些内存，并且指定其如何发送给显卡。顶点着色器接着会处理我们在内存中指定数量的顶点。
+
+我们通过顶点缓冲对象(Vertex Buffer Objects, VBO)管理这个内存，它会在GPU内存（通常被称为显存）中储存大量顶点。使用这些缓冲对象的好处是我们可以一次性的发送一大批数据到显卡上，而不是每个顶点发送一次。从CPU把数据发送到显卡相对较慢，所以只要可能我们都要尝试尽量一次性发送尽可能多的数据。当数据发送至显卡的内存中后，顶点着色器几乎能立即访问顶点，这是个非常快的过程。
+
+顶点缓冲对象是我们在OpenGL教程中第一个出现的OpenGL对象。就像OpenGL中的其它对象一样，这个缓冲有一个独一无二的ID，所以我们可以使用glGenBuffers函数和一个缓冲ID生成一个VBO对象。
+
 
 - 顶点着色器
 
@@ -24,6 +39,10 @@ OpenGL ES的绘制需要有以下步骤:
 
   下一步，使用in关键字，在顶点着色器中声明所有的输入顶点属性(Input Vertex Attribute)。现在我们只关心位置(Position)数据，所以我们只需要一个顶点属性。GLSL有一个向量数据类型，它包含1到4个float分量，包含的数量可以从它的后缀数字看出来。由于每个顶点都有一个3D坐标，我们就创建一个vec3输入变量position。我们同样也通过layout (location = 0)设定了输入变量的位置值(Location)你后面会看到为什么我们会需要这个位置值。
 
+向量(Vector)
+
+在图形编程中我们经常会使用向量这个数学概念，因为它简明地表达了任意空间中的位置和方向，并且它有非常有用的数学属性。在GLSL中一个向量有最多4个分量，每个分量值都代表空间中的一个坐标，它们可以通过vec.x、vec.y、vec.z和vec.w来获取。注意vec.w分量不是用作表达空间中的位置的（我们处理的是3D不是4D），而是用在所谓透视除法(Perspective Division)上。我们会在后面的教程中更详细地讨论向量。
+
   为了设置顶点着色器的输出，我们必须把位置数据赋值给预定义的gl_Position变量，它在幕后是vec4类型的。在main函数中只是将position的值转换后赋值给gl_Position。由于我们的输入是一个3分量的向量，我们必须把它转换为4分量的。我们可以把vec3的数据作为vec4构造器的参数，同时把w分量设置为1.0f（我们会在后面解释为什么）来完成这一任务。
 
   这个position的值是哪里进行赋值的呢？ 是通过后面java代码中的draw函数来进行赋值的。每个顶点着色器都必须在gl_Position变量中输出一个位置。这个变量定义传递给管线下一个阶段的位置。
@@ -43,16 +62,20 @@ OpenGL ES的绘制需要有以下步骤:
       color = vec4(1.0f, 0.5f, 0.2f, 1.0f);
   }
   ```
-
+在计算机图形中颜色被表示为有4个元素的数组：红色、绿色、蓝色和alpha(透明度)分量，通常缩写为RGBA。当在OpenGL或GLSL中定义一个颜色的时候，我们把颜色每个分量的强度设置在0.0到1.0之间。比如说我们设置红为1.0f，绿为1.0f，我们会得到两个颜色的混合色，即黄色。这三种颜色分量的不同调配可以生成超过1600万种不同的颜色！
+ 
   片段着色器只需要一个输出变量，这个变量是一个4分量向量，它表示的是最终的输出颜色，我们应该自己将其计算出来。我们可以用out关键字声明输出变量，这里我们命名为color。下面，我们将一个alpha值为1.0(1.0代表完全不透明)的橘黄色的vec4赋值给颜色输出。之后也是需要编译着色器。片段着色器声明的这个输出变量color的值会被输出到颜色缓冲区。，然后颜色缓冲区再通过EGL窗口显示。
 
+片段着色器只需要一个输出变量，这个变量是一个4分量向量，它表示的是最终的输出颜色，我们应该自己将其计算出来。声明输出变量可以使用out关键字，这里我们命名为color。
+
 - 着色器程序(Shader Program Object)
 
-  着色器程序对象(Shader Program Object)是多个着色器合并之后并最终链接完成的版本。如果要使用刚才编译的着色器我们必须把它们链接为一个着色器程序对象，然后在渲染对象的时候激活这个着色器程序。已激活着色器程序的着色器将在我们发送渲染调用的时候被使用。
+  着色器程序对象(Shader Program Object)是多个着色器合并之后并最终链接完成的版本。如果要使用刚才编译的着色器我们必须把它们链接(Link)为一个着色器程序对象，然后在渲染对象的时候激活这个着色器程序。已激活着色器程序的着色器将在我们发送渲染调用的时候被使用。
 
   当链接着色器至一个程序的时候，它会把每个着色器的输出链接到下个着色器的输入。当输出和输入不匹配的时候，你会得到一个连接错误。我们需要把之前编译的着色器附加到程序队形上，然后使用glLinkProgram链接他们:
 
   ```java
+  shaderProgram = glCreateProgram(); 
   glAttachShader(shaderProgram, vertexShader);
   glAttachShader(shaderProgram, fragmentShader);
   glLinkProgram(shaderProgram);
@@ -60,6 +83,15 @@ OpenGL ES的绘制需要有以下步骤:
 
   链接完后需要使用glUseProgram方法，用刚创建的程序对象作为参数，以激活这个程序对象。调用glUserProgram方法后，所有后续的渲染将用连接到这个程序对象的顶点和片段着色器进行。
 
+对了，在把着色器对象链接到程序对象以后，记得删除着色器对象，我们不再需要它们了：
+```
+glDeleteShader(vertexShader);
+glDeleteShader(fragmentShader);
+```
+
+现在，我们已经把输入顶点数据发送给了GPU，并指示了GPU如何在顶点和片段着色器中处理它。就快要完成了，但还没结束，OpenGL还不知道它该如何解释内存中的顶点数据，以及它该如何将顶点数据链接到顶点着色器的属性上。下面我们需要告诉OpenGL怎么做。
+
+
 - 链接顶点属性
 
   顶点着色器允许我们指定任何以顶点属性为形式的输入。这使其具有很强的灵活性的同时，它还意味着我们必须手动指定输入数据的哪一个部分对应顶点着色器的哪一个顶点属性。所以，我们必须在渲染前指定OpenGL该如何解释顶点数据。
@@ -67,6 +99,10 @@ OpenGL ES的绘制需要有以下步骤:
   我们的顶点缓冲数据会被解析成下面的样子:  
 
   ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/vertex_attribute_pointer.png)
+- 位置数据被储存为32位（4字节）浮点值。
+- 每个位置包含3个这样的值。
+- 在这3个值之间没有空隙（或其他值）。这几个值在数组中紧密排列(Tightly Packed)。
+- 数据中第一个值在缓冲开始的位置。
 
   有了这些信息我们就可以使用glVertexAttribPointer函数告诉OpenGL该如何解析顶点数据（应用到逐个顶点属性上）了：
 
@@ -84,6 +120,28 @@ OpenGL ES的绘制需要有以下步骤:
   - 第五个参数叫做步长(Stride)，它告诉我们在连续的顶点属性组之间的间隔。由于下个组位置数据在3个`GLfloat`之后，我们把步长设置为`3 * sizeof(GLfloat)`。要注意的是由于我们知道这个数组是紧密排列的（在两个顶点属性之间没有空隙）我们也可以设置为0来让OpenGL决定具体步长是多少（只有当数值是紧密排列时才可用）。一旦我们有更多的顶点属性，我们就必须更小心地定义每个顶点属性之间的间隔，我们在后面会看到更多的例子(译注: 这个参数的意思简单说就是从这个属性第二次出现的地方到整个数组0位置之间有多少字节)。
   - 最后一个参数的类型是`GLvoid*`，所以需要我们进行这个奇怪的强制类型转换。它表示位置数据在缓冲中起始位置的偏移量(Offset)。由于位置数据在数组的开头，所以这里是0。我们会在后面详细解释这个参数。
 
+每个顶点属性从一个VBO管理的内存中获得它的数据，而具体是从哪个VBO（程序中可以有多个VBO）获取则是通过在调用glVertexAttribPointer时绑定到GL_ARRAY_BUFFER的VBO决定的。由于在调用glVertexAttribPointer之前绑定的是先前定义的VBO对象，顶点属性0现在会链接到它的顶点数据。
+
+现在我们已经定义了OpenGL该如何解释顶点数据，我们现在应该使用glEnableVertexAttribArray，以顶点属性位置值作为参数，启用顶点属性；顶点属性默认是禁用的。自此，所有东西都已经设置好了：我们使用一个顶点缓冲对象将顶点数据初始化至缓冲中，建立了一个顶点和一个片段着色器，并告诉了OpenGL如何把顶点数据链接到顶点着色器的顶点属性上。在OpenGL中绘制一个物体，代码会像是这样：
+
+// 0. 复制顶点数组到缓冲中供OpenGL使用
+glBindBuffer(GL_ARRAY_BUFFER, VBO);
+glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
+// 1. 设置顶点属性指针
+glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
+glEnableVertexAttribArray(0);
+// 2. 当我们渲染一个物体时要使用着色器程序
+glUseProgram(shaderProgram);
+// 3. 绘制物体
+someOpenGLFunctionThatDrawsOurTriangle();
+
+每当我们绘制一个物体的时候都必须重复这一过程。这看起来可能不多，但是如果有超过5个顶点属性，上百个不同物体呢（这其实并不罕见）。绑定正确的缓冲对象，为每个物体配置所有顶点属性很快就变成一件麻烦事。有没有一些方法可以使我们把所有这些状态配置储存在一个对象中，并且可以通过绑定这个对象来恢复状态呢？
+
+顶点数组对象(Vertex Array Object, VAO)可以像顶点缓冲对象那样被绑定，任何随后的顶点属性调用都会储存在这个VAO中。这样的好处就是，当配置顶点属性指针时，你只需要将那些调用执行一次，之后再绘制物体的时候只需要绑定相应的VAO就行了。这使在不同顶点数据和属性配置之间切换变得非常简单，只需要绑定不同的VAO就行了。刚刚设置的所有状态都将存储在VAO中。
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/vertex_array_objects.png)
+
+
+
 
 
 下面需要实现GLSurfaceView.Render接口，实现要绘制的部分:   
@@ -131,7 +189,7 @@ Preferences -> Plugins -> 搜GLSL Support安装就可以了。
   }
   ```
 
-  大体意思：使用OpenGL ES3.0版本，将图形顶点数据采用4分向量的数据结构绑定到着色器的第0个属性上，属性的名字是vPosition，然后再有一个颜色的4分向量绑定到做色漆的第1个属性上，属性的名字是aColor，另外还会输出一个vColor，着色器执行的时候，会将vPosition的值传递给用来表示顶点最终位置的内建变量gl_Position，将顶点最终大小的gl_PointSize设置为10，并将aColor的值复制给要输出额vColor。
+  大体意思：使用OpenGL ES3.0版本，将图形顶点数据采用4分向量的数据结构绑定到着色器的第0个属性上，属性的名字是vPosition，然后再有一个颜色的4分向量绑定到做色器的第1个属性上，属性的名字是aColor，另外还会输出一个vColor，着色器执行的时候，会将vPosition的值传递给用来表示顶点最终位置的内建变量gl_Position，将顶点最终大小的gl_PointSize设置为10，并将aColor的值复制给要输出额vColor。
 
 - 片段着色器(triangle_fragment_shader.glsl)
 
@@ -424,10 +482,12 @@ public class TriangleRender implements GLSurfaceView.Renderer {
 ```
 
 
+调用glCreateShader将根据传入的type参数创建一个新的顶点或片段着色器。返回值是指向新着色器对象的句柄。当完成着色器对象时，可以用glDeleteShader删除。
+注意，如果一个着色器连接到一个程序对象，那么调用glDeleteShader不会立即删除着色器，而是将着色器编标记为删除，在着色器不再连接到任何程序对象时，它的内存将被释放。
 
 效果如下:   
 
-<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_tri.jpg" style="zoom:20%;" />
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_tri.jpg" style="zoom:20%" />
 
 我们设置的是数据来看，应该是等腰三角形，但是实际效果并不是，这是因为前面说到的OpenGL ES使用的是虚拟坐标导致的。如果想让绘制一个等腰三角形该怎么做呢？ 
 
@@ -437,7 +497,7 @@ public class TriangleRender implements GLSurfaceView.Renderer {
 
 这里就牵扯到了要对坐标向量进行换算，这里的换算需要使用矩阵来进行。总体分为两部分:   
 
-- 或者获得一个矩阵，可以把坐标范围从【-2，2】换算成【-1，1】的范围内。(提供了Matrix.orthoM来处理矩阵)
+- 如何获得一个矩阵，可以把坐标范围从【-2，2】换算成【-1，1】的范围内。(提供了Matrix.orthoM来处理矩阵)
 - 如何将这个矩阵传递给GLSL中。(与获取顶点索引类似，可以在GLSL中声明一个mat4类型的矩阵变量，获取其索引，再传递值给它)
 
 
@@ -462,7 +522,7 @@ public class TriangleRender implements GLSurfaceView.Renderer {
 
 1. 相机位置:相机在3D空间里面的坐标点。
 2. 相机观察方向:相机镜头的朝向，朝前拍、朝后拍、朝左拍、朝右拍。
-3. 相机UP方向:相机顶端志祥的方向，例如斜着拿、反着拿。
+3. 相机UP方向:相机顶端指向的方向，例如斜着拿、反着拿。
 
 Android OpenGL ES程序中，我们可以通过Matrix.setLookAtm来对相机进行设置:   
 
@@ -593,7 +653,7 @@ Matrix.multiplyMM (float[] result, //接收相乘结果
 
 ### 绘制等腰三角形
 
-​	在上面绘制三角形的基础上进行修改。
+在上面绘制三角形的基础上进行修改。
 
 ### 工具类
 
diff --git "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md" "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
index 7e935fbd..4c79a8dd 100644
--- "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
+++ "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
@@ -1,5 +1,14 @@
 ## 7.OpenGL ES着色器语言GLSL
 
+在计算机图形中，两个基本数据类型组成了变换的基础：
+- 向量
+- 矩阵
+这两种数据类型在OpenGL ES着色语言中也是核心，下图具体描述了着色语言中存在的机遇标量、向量和矩阵的数据类型。
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/glsl_basic_data_type.png" style="zoom:80%" />
+
+
+
 ### 顶点着色器:
 
 ```
@@ -17,7 +26,7 @@ void main()
 
 #version 300 es是表示GLSL语言的版本为300，对应的是OpenGL ES 3.0版本。
 
-<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_vertex_shader.jpg" style="zoom:80%;" />
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_vertex_shader.jpg" style="zoom:80%" />
 
 顶点着色器的输入包括:
 
@@ -28,6 +37,49 @@ void main()
 
 顶点着色器的输出在OpenGL ES 2.0中称作可变(varying)变量，但在OpenGL ES 3.0中改名为顶点着色器输出(out)变量。在图元光栅化阶段，为每个生成的片段计算顶点着色器输出值，并作为输入传递给片段着色器。
 
+虽然着色器是各自独立的小程序，但是它们都是一个整体的一部分，出于这样的原因，我们希望每个着色器都有输入和输出，这样才能进行数据交流和传递。GLSL定义了in和out关键字专门来实现这个目的。每个着色器使用这两个关键字设定输入和输出，只要一个输出变量与下一个着色器阶段的输入匹配，它就会传递下去。但在顶点和片段着色器中会有点不同。
+
+
+
+
+
+#### in、out
+顶点着色器应该接收的是一种特殊形式的输入，否则就会效率低下。顶点着色器的输入特殊在，它从顶点数据中直接接收输入。为了定义顶点数据该如何管理，我们使用location这一元数据指定输入变量，这样我们才可以在CPU上配置顶点属性。我们已经在前面的教程看过这个了，layout (location = 0)。顶点着色器需要为它的输入提供一个额外的layout标识，这样我们才能把它链接到顶点数据。
+
+你也可以忽略layout (location = 0)标识符，通过在OpenGL代码中使用glGetAttribLocation查询属性位置值(Location)，但是我更喜欢在着色器中设置它们，这样会更容易理解而且节省你（和OpenGL）的工作量。
+
+#### Uniform
+Uniform是一种从CPU中的应用向GPU中的着色器发送数据的方式，但uniform和顶点属性有些不同。首先，uniform是全局的(Global)。全局意味着uniform变量必须在每个着色器程序对象中都是独一无二的，而且它可以被着色器程序的任意着色器在任意阶段访问。第二，无论你把uniform值设置成什么，uniform会一直保存它们的数据，直到它们被重置或更新。
+
+我们可以在一个着色器中添加uniform关键字至类型和变量名前来声明一个GLSL的uniform。从此处开始我们就可以在着色器中使用新声明的uniform了。我们来看看这次是否能通过uniform设置三角形的颜色：
+
+#version 330 core
+out vec4 FragColor;
+
+uniform vec4 ourColor; // 在OpenGL程序代码中设定这个变量
+
+void main()
+{
+    FragColor = ourColor;
+}
+我们在片段着色器中声明了一个uniform vec4的ourColor，并把片段着色器的输出颜色设置为uniform值的内容。因为uniform是全局变量，我们可以在任何着色器中定义它们，而无需通过顶点着色器作为中介。顶点着色器中不需要这个uniform，所以我们不用在那里定义它。
+
+如果你声明了一个uniform却在GLSL代码中没用过，编译器会静默移除这个变量，导致最后编译出的版本中并不会包含它，这可能导致几个非常麻烦的错误，记住这点！
+
+这个uniform现在还是空的；我们还没有给它添加任何数据，所以下面我们就做这件事。我们首先需要找到着色器中uniform属性的索引/位置值。当我们得到uniform的索引/位置值后，我们就可以更新它的值了。这次我们不去给像素传递单独一个颜色，而是让它随着时间改变颜色：
+
+float timeValue = glfwGetTime();
+float greenValue = (sin(timeValue) / 2.0f) + 0.5f;
+int vertexColorLocation = glGetUniformLocation(shaderProgram, "ourColor");
+glUseProgram(shaderProgram);
+glUniform4f(vertexColorLocation, 0.0f, greenValue, 0.0f, 1.0f);
+首先我们通过glfwGetTime()获取运行的秒数。然后我们使用sin函数让颜色在0.0到1.0之间改变，最后将结果储存到greenValue里。
+
+接着，我们用glGetUniformLocation查询uniform ourColor的位置值。我们为查询函数提供着色器程序和uniform的名字（这是我们希望获得的位置值的来源）。如果glGetUniformLocation返回-1就代表没有找到这个位置值。最后，我们可以通过glUniform4f函数设置uniform值。注意，查询uniform地址不要求你之前使用过着色器程序，但是更新一个uniform之前你必须先使用程序（调用glUseProgram)，因为它是在当前激活的着色器程序中设置uniform的。
+
+
+
+
 内建变量包括:
 
 - gl_Position:用于输出顶点位置的裁剪坐标。
@@ -114,7 +166,7 @@ GLSL中的数据类型主要分为标量、向量、矩阵、采样器、结构
 
 - 矩阵
 
-  在GLSL中矩阵拥有2*2、3*3、4*4三种类型的矩阵，分别用mat2、mat3、mat4表示。我们可以把矩阵看做是一个二维数组，也可以用二维数组下表的方式取里面具体位置的值。
+  在GLSL中矩阵拥有2 * 2、3 * 3、4 * 4三种类型的矩阵，分别用mat2、mat3、mat4表示。我们可以把矩阵看做是一个二维数组，也可以用二维数组下表的方式取里面具体位置的值。
 
 - 采样器
 
diff --git "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md" "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"
index 962345b9..6be99fb8 100644
--- "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
+++ "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
@@ -7,7 +7,6 @@
 在OpenGL中简单理解就是一张图片，在学习之前需要明白这几个概念，不然很容易迷糊，不知道为什么要这样去调用api，到底是什么意思.
 
 - 纹理Id:句柄，纹理的直接引用
-
 - 纹理单元:纹理的操作容器，有GL_TEXTURE0、GL_TEXTURE1、GL_TEXTURE2等，纹理单元的数量是有限的，最多16个。所以在最多只能同时操作16个纹理。在切换使用纹理单元的时候，使用glActiveTexture方法。也就是说OpenGL ES中内置了很多个纹理单元，并且是连续的，我们在使用的时候要选择其中一个，一般默认选择第一个(GLES_TEXTURE0)，并且如果不选的话OpenGL默认激活的也就是第一个纹理单元。采样器统一变量将加载一个指定纹理绑定的纹理单元的数值，例如，用数值0指定采样器表示从单元GL_TEXTURE0读取，指定数值1表示从GL_TEXTURE1读取，以此类推。激活纹理单元后需要把它和纹理Id绑定，然后再通过GLES30.glUniform1i()方法将纹理单元，与GLSL中的采样器属性相关联。
 
 - 纹理目标:一个纹理单元中包含了多个类型的纹理目标，有GL_TEXTURE_1D、GL_TEXTURE_2D、CUBE_MAP等。本章中，将纹理ID绑定到纹理单元0的GL_TEXTURE_2D纹理目标上，之后对纹理目标的操作都是对纹理Id对应的数据进行操作。
@@ -18,7 +17,7 @@
 
 ### 纹理与渐变色的区别
 
-渐变色:光栅化过程中计算出颜色值，然后再片段着色器的时候可以直接赋值。
+渐变色:光栅化过程中计算出颜色值，然后在使用片段着色器的时候可以直接赋值。
 
 纹理:光栅化过程中，计算出当前片段在纹理上的坐标位置，然后在片段着色器中根据这个纹理上的坐标，去纹理中取出相应的颜色值。
 
@@ -36,7 +35,7 @@ OpenGL不能直接加载jpg或者png这类被编码的压缩格式，需要加
 
 ### 纹理过滤
 
-当我们通过光栅化将图形处理成一个个小片段的时候，再讲纹理采样，渲染到指定位置上时，通常会遇到纹理元素和小片段并非一一对应。这时候，会出现纹理的压缩或者放大。那么在这两种情况下，就会有不同的处理方案，这就是纹理过滤了。
+当我们通过光栅化将图形处理成一个个小片段的时候，再将纹理采样，渲染到指定位置上时，通常会遇到纹理元素和小片段并非一一对应。这时候，会出现纹理的压缩或者放大。那么在这两种情况下，就会有不同的处理方案，这就是纹理过滤了。
 
 ### 纹理对象和纹理的加载
 
@@ -54,7 +53,7 @@ OpenGL不能直接加载jpg或者png这类被编码的压缩格式，需要加
 
   GLenum format, GLenum type, const void* pixels)
 
-  加载2D和立方图纹理图像数据。
+  加载2D和立方图纹理图像数据,生成最终纹理。
 
 
 
@@ -216,7 +215,12 @@ public class TextureUtil {
 
 - 片段着色器
 
-  之前直接输出顶点着色器来的颜色，现在变为经过纹理处理最终成为输出颜色`。
+片段着色器也应该能访问纹理对象，但是我们怎样能把纹理对象传给片段着色器呢？GLSL有一个供纹理对象使用的内建数据类型，叫做采样器(Sampler)，它以纹理类型作为后缀，比如sampler1D、sampler3D，或在我们的例子中的sampler2D。我们可以简单声明一个uniform sampler2D把一个纹理添加到片段着色器中，稍后我们会把纹理赋值给这个uniform。
+
+我们使用GLSL内建的texture函数来采样纹理的颜色，它第一个参数是纹理采样器，第二个参数是对应的纹理坐标。texture函数会使用之前设置的纹理参数对相应的颜色值进行采样。这个片段着色器的输出就是纹理的（插值）纹理坐标上的(过滤后的)颜色。
+
+
+  之前直接输出顶点着色器来的颜色，现在变为经过纹理处理最终成为输出颜色。
 
   ```
   #version 300 es
@@ -249,7 +253,7 @@ public class TextureUtil {
   GLES20.glUniform1i(aTextureLocation, 0);
   ```
 
-  这里有没有很奇怪，sampler2D的变量是uniform的，但是我们并不是用glUniform()方法给他赋值，而是使用glUniform1i()。这事因为可以给纹理采样器分配一个位置值，这样我们就能够在一个片段着色器中设置多个纹理单元。一个纹理的话，纹理单元是默认为0，它是默认激活的，纹理单元的主要目的就是给着色器多一个使用的纹理。通过纹理单元赋值给采样器，我们可以一次绑定多个纹理，只要我们在使用的时候激活纹理。
+  这里有没有很奇怪，sampler2D的变量是uniform的，但是我们并不是用glUniform()方法给他赋值，而是使用glUniform1i()。这是因为可以给纹理采样器分配一个位置值，这样我们就能够在一个片段着色器中设置多个纹理单元。一个纹理的话，纹理单元是默认为0，它是默认激活的，纹理单元的主要目的就是给着色器多一个使用的纹理。通过纹理单元赋值给采样器，我们可以一次绑定多个纹理，只要我们在使用的时候激活纹理。
 
   
 
@@ -444,7 +448,7 @@ public class TextureUtil {
   
   
   
-- 多纹理单元，单词绘制
+- 多纹理单元，单次绘制
 
   OpenGL可以同时操作的纹理单元是16个，那么我们可以利用多个纹理单元来进行绘制同一个图层，从而达到目的。多纹理单元需要修改片段着色器的代码，顶点着色器不用改变，这种方式的优点是可以控制多个纹理的关系，做出复杂的效果。缺点是多个纹理单元的顶点坐标必须是一样的。
   
@@ -456,7 +460,7 @@ public class TextureUtil {
   // 采样器(sampler)是用于从纹理贴图读取的特殊统一变量。采样器统一变量将加载一个指定纹理绑定的纹理单元额数据，java代码里面需要把它设置为0
   uniform sampler2D uTextureUnit;
   uniform sampler2D uTextureUnit2;
-  // 接受刚才顶点着色器传入的纹理坐标(s, t)
+  // 接收刚才顶点着色器传入的纹理坐标(s, t)
   in vec2 vTexCoord;
   out vec4 vFragColor;
   

From ac92eb798e89ec60ef1c6ec384026c71049e47c0 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Fri, 28 Apr 2023 19:46:03 +0800
Subject: [PATCH 104/213] update

---
 .../1.OpenGL\347\256\200\344\273\213.md"      |  4 ++
 ....GLSurfaceView\347\256\200\344\273\213.md" |  2 +-
 ...66\344\270\211\350\247\222\345\275\242.md" | 47 ++++++++++---------
 3 files changed, 31 insertions(+), 22 deletions(-)

diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
index 0f8f0c43..193f3a83 100644
--- "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -85,10 +85,14 @@ OpenGL ES 3.0实现了具有可编程着色功能的图形管线，有两个规
 
   顶点着色器可以操作的属性有: 位置、颜色、纹理坐标，但是不能创建新的顶点。最终产生纹理坐标、颜色、点位置等信息送往后续阶段。
 
+    顶点着色器会在GPU上创建内存用于存储我们的顶点数据，还要配置OpenGL如何解释这些内存，并且指定其如何发送给显卡。顶点着色器接着回处理我们在内存中指定数量的顶点。
+    我们通过顶点缓冲对象(Vertex Buffer Object, VBO)管理这个内存，它会在GPU内存(通常被称为显存)中储存大量顶点。使用这些缓冲对象的好处是我们可以一次性的发送一大批数据到显卡上，而不是每个顶点发送一次。从CPU把数据发送到显卡相对较慢，所以只要可能我们都尝试尽量一次性发送尽可能多的数据。当数据发送至显卡的内存中后，顶点着色器几乎能立即访问顶点，这个是非常快的过程。
 - 图元装配(Primitive Assembly)
 
     顶点组合成图元的过程叫做图元装配，这里的图元就是指点、线、三角。
     图元装配阶段将顶点着色器输出的所有顶点作为输入(如果是GL_POINTS，那么就是一个顶点),并将所有的点装配成指定的图元的形状，上图的例子中是一个三角形。
+    也就是说图元装配是将顶点着色器中设置的顶点数据装配成指定图元的形状。
+
     OpenGL ES中最基础且唯一的多边形就是三角形，所有更复杂的图形都是由三角形组成的。复杂的图形都可以拆分成多个三角形。比如OpenGL提供给开发者的绘制方法glDrawArrays，这个方法的第一个参数就是指定绘制方式，可选值有:  
 
   - GL_POINTS:以点的形式绘制
diff --git "a/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
index 65f48e61..fa6b2098 100644
--- "a/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
@@ -118,7 +118,7 @@ class MyGLRenderer implements GLSurfaceView.Renderer {
 Render接口重写的三个方法中调用了GLES31的API方法:   
 
 - glClearColor()：设置清空屏幕用的颜色，参数为RGBA。
-- glClear()：清空屏幕，清空屏幕后调用glClearColor()中设置的颜色填充屏幕。
+- glClear()：清空屏幕，当调用glClear函数清除颜色缓冲之后，整个颜色缓冲都会被填充为glClearColor里所设置的颜色。glClear函数来清空屏幕的颜色缓冲时会接受一个缓冲位(Buffer Bit)来指定要清空的缓冲，可能的缓冲位有GL_COLOR_BUFFER_BIT、GL_DEPTH_BUFFER_BIT和GL_STENCIL_BUFFER_BIT，由于这里我们只关心颜色值，所以我们只清空颜色缓冲。
 - glViewport()：设置视图的尺寸，告诉OpenGL可以用来渲染surface的大小。
 
 
diff --git "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md" "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"
index 3a94df07..20bd1b33 100644
--- "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
@@ -124,8 +124,14 @@ glDeleteShader(fragmentShader);
 
 现在我们已经定义了OpenGL该如何解释顶点数据，我们现在应该使用glEnableVertexAttribArray，以顶点属性位置值作为参数，启用顶点属性；顶点属性默认是禁用的。自此，所有东西都已经设置好了：我们使用一个顶点缓冲对象将顶点数据初始化至缓冲中，建立了一个顶点和一个片段着色器，并告诉了OpenGL如何把顶点数据链接到顶点着色器的顶点属性上。在OpenGL中绘制一个物体，代码会像是这样：
 
-// 0. 复制顶点数组到缓冲中供OpenGL使用
+// 0. 复制顶点数组到缓冲中供OpenGL使用,使用glGenBuffers函数和一个缓冲ID生成一个VBO对象
+glGenBuffers(1, VBO);
+// 使用glBindBuffer函数把新创建的缓冲绑定到GL_ARRAY_BUFFER目标上
 glBindBuffer(GL_ARRAY_BUFFER, VBO);
+// glBufferData是一个专门用来把用户定义的数据复制到当前绑定缓冲的函数
+// 它的第一个参数是目标缓冲类型。 第二个参数是指定传输数据的大小(以字节为单位),用一个简单的sizeof计算出顶点数据的大小就行
+// 第三个参数是我们希望发送的实际数据
+// 第四个参数指定了我们希望显卡如何管理这些数据，有三种形式: GL_STATIC_DRAW(数据不会或几乎不会改变)， GL_DYNAMIC_DRAW(数据会被改变很多)， GL_STREAM_DRAW(数据每次绘制时都会改变)
 glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
 // 1. 设置顶点属性指针
 glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
@@ -150,7 +156,7 @@ someOpenGLFunctionThatDrawsOurTriangle();
 - 写顶点着色器和片段着色器文件。
 - 加载编译顶点着色器和片段着色器。
 - 确定需要绘制图形的坐标和颜色数据。
-- 创建program对象，连接顶点和片断着色器，将坐标数据、颜色数据传到OpenGL ES程序中。]
+- 创建program对象，连接顶点和片断着色器，将坐标数据、颜色数据传到OpenGL ES程序中。
 - 设置视图窗口(viewport)。
 - 使颜色缓冲区的内容显示到EGL窗口上。
 
@@ -169,25 +175,10 @@ Preferences -> Plugins -> 搜GLSL Support安装就可以了。
 安装完GLSL插件后，就可以开始了。一般将GLSL文件放到raw或assets目录，我们这里在raw目录上右键New，然后选择GLSL Shader创建就可以了，创建后默认会生成一个main()函数。
 
 - 顶点着色器(triangle_vertex_shader.glsl)
-
-  ```glsl
-  // 声明着色器的版本
-  #version 300 es
-  // 顶点着色器的顶点位置，输入一个名为vPosition的4分量向量，layout (location = 0)表示这个变量的位置是顶点属性中的第0个属性。
-  layout (location = 0) in vec4 vPosition;
-  // 顶点着色器的顶点颜色数据，输入一个名为aColor的4分量向量，layout (location = 1)表示这个变量的位置是顶点属性中的第1个属性。
-  layout (location = 1) in vec4 aColor;
-  // 输出一个名为vColor的4分量向量，后面输入到片段着色器中。
-  out vec4 vColor;
-  void main() {
-      // gl_Position为Shader内置变量，为顶点位置，将其赋值为vPosition
-      gl_Position  = vPosition;
-      // gl_PointSize为Shader内置变量，为点的直径
-      gl_PointSize = 10.0;
-      // 将输入数据aColor拷贝到vColor的变量中。
-      vColor = aColor;
-  }
-  ```
+```glsl 
+// 声明着色器的版本 
+#version 300 es 
+// 顶点着色器的顶点位置，输入一个名为vPosition的4分量向量，layout (location = 0)表示这个变量的位置是顶点属性中的第0个属性。 layout (location = 0) in vec4 vPosition; // 顶点着色器的顶点颜色数据，输入一个名为aColor的4分量向量，layout (location = 1)表示这个变量的位置是顶点属性中的第1个属性。 layout (location = 1) in vec4 aColor; // 输出一个名为vColor的4分量向量，后面输入到片段着色器中。 out vec4 vColor; void main() { // gl_Position为Shader内置变量，为顶点位置，将其赋值为vPosition gl_Position  = vPosition; // gl_PointSize为Shader内置变量，为点的直径 gl_PointSize = 10.0; // 将输入数据aColor拷贝到vColor的变量中。 vColor = aColor; } ```
 
   大体意思：使用OpenGL ES3.0版本，将图形顶点数据采用4分向量的数据结构绑定到着色器的第0个属性上，属性的名字是vPosition，然后再有一个颜色的4分向量绑定到做色器的第1个属性上，属性的名字是aColor，另外还会输出一个vColor，着色器执行的时候，会将vPosition的值传递给用来表示顶点最终位置的内建变量gl_Position，将顶点最终大小的gl_PointSize设置为10，并将aColor的值复制给要输出额vColor。
 
@@ -207,7 +198,21 @@ Preferences -> Plugins -> 搜GLSL Support安装就可以了。
       fragColor = vColor;
   }
   ```
+precision是精度限定符，它可以使着色器创作者指定着色器变量的计算精度。变量可以声明为低、中或高精度。这些限定符用于提示编译器允许在较低的范围和精度上执行变量的计算。在较低的精度上，有些OpenGL ES实现在运行着色器时可能更快，或者电源效率更高。当然这种效率提升是以精度为代价的，在没有正确使用精度限定符时可能造成伪像。
 
+精度限定符可以用于指定任何浮点数或整数的变量的精度。指定精度的关键字是lowp、mediump和highp。下面是一些带有精度限定符的声明示例: 
+```
+highp vec4 position;
+mediump float specularExp;
+```
+除了精度限定符之外，还有默认精度的概念。也就是说，如果变量声明时没有使用精度限定符，它将拥有该类型的默认精度。默认精度限定符在顶点或片段着色器的开头用以下语法指定： 
+```
+precision highp float;
+precision mediump int;
+```
+为float类型指定的精度将用作所有基于浮点值变量的默认精度。同样，为int指定的精度将用作所有基于整数的变量的默认精度。
+在顶点着色器中，如果没有指定默认精度，则int和float的默认精度都是highp。也就是说，顶点着色器中所有没有精度限定符声明的变量都使用最高的精度。
+片段着色器的规则与此不同。在片段着色器中，浮点值没有默认的精度值:每个着色器必须声明一个默认的float精度，或者为每个float变量指定精度。
 
 
 ```java

From a75e14c5d312131a70a825564c7093d6c989e1ea Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Fri, 28 Apr 2023 21:41:29 +0800
Subject: [PATCH 105/213] update notes

---
 ...66\344\270\211\350\247\222\345\275\242.md" | 22 ++++++++--
 ...45\231\250\350\257\255\350\250\200GLSL.md" | 41 ++++++++++++++++++-
 2 files changed, 58 insertions(+), 5 deletions(-)

diff --git "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md" "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"
index 20bd1b33..d29e7cdb 100644
--- "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
@@ -123,7 +123,7 @@ glDeleteShader(fragmentShader);
 每个顶点属性从一个VBO管理的内存中获得它的数据，而具体是从哪个VBO（程序中可以有多个VBO）获取则是通过在调用glVertexAttribPointer时绑定到GL_ARRAY_BUFFER的VBO决定的。由于在调用glVertexAttribPointer之前绑定的是先前定义的VBO对象，顶点属性0现在会链接到它的顶点数据。
 
 现在我们已经定义了OpenGL该如何解释顶点数据，我们现在应该使用glEnableVertexAttribArray，以顶点属性位置值作为参数，启用顶点属性；顶点属性默认是禁用的。自此，所有东西都已经设置好了：我们使用一个顶点缓冲对象将顶点数据初始化至缓冲中，建立了一个顶点和一个片段着色器，并告诉了OpenGL如何把顶点数据链接到顶点着色器的顶点属性上。在OpenGL中绘制一个物体，代码会像是这样：
-
+```java
 // 0. 复制顶点数组到缓冲中供OpenGL使用,使用glGenBuffers函数和一个缓冲ID生成一个VBO对象
 glGenBuffers(1, VBO);
 // 使用glBindBuffer函数把新创建的缓冲绑定到GL_ARRAY_BUFFER目标上
@@ -140,7 +140,7 @@ glEnableVertexAttribArray(0);
 glUseProgram(shaderProgram);
 // 3. 绘制物体
 someOpenGLFunctionThatDrawsOurTriangle();
-
+```
 每当我们绘制一个物体的时候都必须重复这一过程。这看起来可能不多，但是如果有超过5个顶点属性，上百个不同物体呢（这其实并不罕见）。绑定正确的缓冲对象，为每个物体配置所有顶点属性很快就变成一件麻烦事。有没有一些方法可以使我们把所有这些状态配置储存在一个对象中，并且可以通过绑定这个对象来恢复状态呢？
 
 顶点数组对象(Vertex Array Object, VAO)可以像顶点缓冲对象那样被绑定，任何随后的顶点属性调用都会储存在这个VAO中。这样的好处就是，当配置顶点属性指针时，你只需要将那些调用执行一次，之后再绘制物体的时候只需要绑定相应的VAO就行了。这使在不同顶点数据和属性配置之间切换变得非常简单，只需要绑定不同的VAO就行了。刚刚设置的所有状态都将存储在VAO中。
@@ -178,7 +178,21 @@ Preferences -> Plugins -> 搜GLSL Support安装就可以了。
 ```glsl 
 // 声明着色器的版本 
 #version 300 es 
-// 顶点着色器的顶点位置，输入一个名为vPosition的4分量向量，layout (location = 0)表示这个变量的位置是顶点属性中的第0个属性。 layout (location = 0) in vec4 vPosition; // 顶点着色器的顶点颜色数据，输入一个名为aColor的4分量向量，layout (location = 1)表示这个变量的位置是顶点属性中的第1个属性。 layout (location = 1) in vec4 aColor; // 输出一个名为vColor的4分量向量，后面输入到片段着色器中。 out vec4 vColor; void main() { // gl_Position为Shader内置变量，为顶点位置，将其赋值为vPosition gl_Position  = vPosition; // gl_PointSize为Shader内置变量，为点的直径 gl_PointSize = 10.0; // 将输入数据aColor拷贝到vColor的变量中。 vColor = aColor; } ```
+// 顶点着色器的顶点位置，输入一个名为vPosition的4分量向量，layout (location = 0)表示这个变量的位置是顶点属性中的第0个属性。 
+layout (location = 0) in vec4 vPosition; 
+// 顶点着色器的顶点颜色数据，输入一个名为aColor的4分量向量，layout (location = 1)表示这个变量的位置是顶点属性中的第1个属性。 
+layout (location = 1) in vec4 aColor; 
+// 输出一个名为vColor的4分量向量，后面输入到片段着色器中。 
+out vec4 vColor; 
+void main() {
+    // gl_Position为Shader内置变量，为顶点位置，将其赋值为vPosition 
+    gl_Position  = vPosition; 
+    // gl_PointSize为Shader内置变量，为点的直径 
+    gl_PointSize = 10.0; 
+    // 将输入数据aColor拷贝到vColor的变量中。 
+    vColor = aColor; 
+} 
+```
 
   大体意思：使用OpenGL ES3.0版本，将图形顶点数据采用4分向量的数据结构绑定到着色器的第0个属性上，属性的名字是vPosition，然后再有一个颜色的4分向量绑定到做色器的第1个属性上，属性的名字是aColor，另外还会输出一个vColor，着色器执行的时候，会将vPosition的值传递给用来表示顶点最终位置的内建变量gl_Position，将顶点最终大小的gl_PointSize设置为10，并将aColor的值复制给要输出额vColor。
 
@@ -494,6 +508,8 @@ public class TriangleRender implements GLSurfaceView.Renderer {
 
 <img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_tri.jpg" style="zoom:20%" />
 
+
+
 我们设置的是数据来看，应该是等腰三角形，但是实际效果并不是，这是因为前面说到的OpenGL ES使用的是虚拟坐标导致的。如果想让绘制一个等腰三角形该怎么做呢？ 
 
 ### 变成等腰三角形的原理
diff --git "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md" "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
index 4c79a8dd..86fe7b91 100644
--- "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
+++ "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
@@ -17,14 +17,14 @@ layout (location = 0) in vec3 position; // position变量的属性位置值为0
 
 out vec4 vertexColor; // 为片段着色器指定一个颜色输出
 
-void main()
-{
+void main() {
     gl_Position = vec4(position, 1.0); // 注意我们如何把一个vec3作为vec4的构造器的参数
     vertexColor = vec4(0.5f, 0.0f, 0.0f, 1.0f); // 把输出变量设置为暗红色
 }
 ```
 
 #version 300 es是表示GLSL语言的版本为300，对应的是OpenGL ES 3.0版本。
+#version必须写在文件的第一行，即是第一行是注释也不行。
 
 <img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_vertex_shader.jpg" style="zoom:80%" />
 
@@ -48,6 +48,37 @@ void main()
 
 你也可以忽略layout (location = 0)标识符，通过在OpenGL代码中使用glGetAttribLocation查询属性位置值(Location)，但是我更喜欢在着色器中设置它们，这样会更容易理解而且节省你（和OpenGL）的工作量。
 
+如果我们打算从一个着色器向另一个着色器发送数据，我们必须在发送方着色器中声明一个输出，在接收方着色器中声明一个类似的输入。当类型和名字都一样的时候，OpenGL就会把两个变量链接到一起，它们之间就能发送数据了（这是在链接程序对象时完成的）。
+
+顶点着色器
+```glsl
+#version 330 core
+layout (location = 0) in vec3 aPos; // 位置变量的属性位置值为0
+
+out vec4 vertexColor; // 为片段着色器指定一个颜色输出
+
+void main()
+{
+    gl_Position = vec4(aPos, 1.0); // 注意我们如何把一个vec3作为vec4的构造器的参数
+    vertexColor = vec4(0.5, 0.0, 0.0, 1.0); // 把输出变量设置为暗红色
+}
+```
+片段着色器
+```glsl
+#version 330 core
+out vec4 FragColor;
+
+in vec4 vertexColor; // 从顶点着色器传来的输入变量（名称相同、类型相同）
+
+void main()
+{
+    FragColor = vertexColor;
+}
+```
+你可以看到我们在顶点着色器中声明了一个vertexColor变量作为vec4输出，并在片段着色器中声明了一个类似的vertexColor。由于它们名字相同且类型相同，片段着色器中的vertexColor就和顶点着色器中的vertexColor链接了。由于我们在顶点着色器中将颜色设置为深红色，最终的片段也是深红色的。
+
+
+
 #### Uniform
 Uniform是一种从CPU中的应用向GPU中的着色器发送数据的方式，但uniform和顶点属性有些不同。首先，uniform是全局的(Global)。全局意味着uniform变量必须在每个着色器程序对象中都是独一无二的，而且它可以被着色器程序的任意着色器在任意阶段访问。第二，无论你把uniform值设置成什么，uniform会一直保存它们的数据，直到它们被重置或更新。
 
@@ -164,6 +195,12 @@ GLSL中的数据类型主要分为标量、向量、矩阵、采样器、结构
   作为位置向量时，用xyzw表示分量，xyz分别表示xyz坐标，w表示向量的模。三维坐标向量为xyz表示分量，二维向量为xy表示分量。
   作为纹理向量时，用stpq表示分量，三维用stp表示分量，二维用st表示分量。
 
+  我们大部分时候使用vecn，因为float足够满足大多数要求了。
+  ```glsl
+vec2 vect = vec2(0.5, 0.7);
+vec4 result = vec4(vect, 0.0, 0.0);
+  ```
+
 - 矩阵
 
   在GLSL中矩阵拥有2 * 2、3 * 3、4 * 4三种类型的矩阵，分别用mat2、mat3、mat4表示。我们可以把矩阵看做是一个二维数组，也可以用二维数组下表的方式取里面具体位置的值。

From 5a028c457833237665da9714c7ba2ca08123572d Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 8 May 2023 21:21:09 +0800
Subject: [PATCH 106/213] update

---
 .../1.OpenGL\347\256\200\344\273\213.md"      | 80 +++++++++++++------
 ...45\231\250\350\257\255\350\250\200GLSL.md" | 36 ++++++++-
 ...\261\273\345\217\212Matrix\347\261\273.md" | 23 ++++++
 3 files changed, 110 insertions(+), 29 deletions(-)

diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
index 193f3a83..fdadeeed 100644
--- "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -81,12 +81,31 @@ OpenGL ES 3.0实现了具有可编程着色功能的图形管线，有两个规
 
 - 顶点着色器(Vertex Shader): 图形渲染管线的第一个部分是顶点着色器，他是用来渲染图形顶点的OpenGL ES代码。它把一个单独的顶点作为输入。顶点着色器主要的目的是把3D坐标转为另一种3D坐标（后面会解释）从而生成每个顶点的最终位置，同时顶点着色器允许我们对顶点属性进行一些基本处理。
 
-  着色器(shader)是在GPU上运行的小程序。从名称可以看出，可通过处理它们来处理顶点。此程序使用OpenGL ES SL语言来编写。它是一个描述顶点或像素特性的简单程序。OpenGL最本质的概念之一就是着色器，它是图形硬件设备所执行的一类特殊函数。理解着色器最好的办法就是把它看做是专为图形处理单元(即GPU)编译的一种小型程序。任何一种OpenGL程序本质上都可以被分为两部分：CPU端运行的部分，采用C++、Java之类的语言编写；以及GPU端运行的部分，使用GLSL语言编写。
+    着色器(shader)是在GPU上运行的小程序。从名称可以看出，可通过处理它们来处理顶点。此程序使用OpenGL ES SL语言来编写。它是一个描述顶点或像素特性的简单程序。OpenGL最本质的概念之一就是着色器，它是图形硬件设备所执行的一类特殊函数。理解着色器最好的办法就是把它看做是专为图形处理单元(即GPU)编译的一种小型程序。任何一种OpenGL程序本质上都可以被分为两部分：CPU端运行的部分，采用C++、Java之类的语言编写；以及GPU端运行的部分，使用GLSL语言编写。
 
-  顶点着色器可以操作的属性有: 位置、颜色、纹理坐标，但是不能创建新的顶点。最终产生纹理坐标、颜色、点位置等信息送往后续阶段。
+    顶点着色器可以操作的属性有: 位置、颜色、纹理坐标，但是不能创建新的顶点。最终产生纹理坐标、颜色、点位置等信息送往后续阶段。
 
     顶点着色器会在GPU上创建内存用于存储我们的顶点数据，还要配置OpenGL如何解释这些内存，并且指定其如何发送给显卡。顶点着色器接着回处理我们在内存中指定数量的顶点。
     我们通过顶点缓冲对象(Vertex Buffer Object, VBO)管理这个内存，它会在GPU内存(通常被称为显存)中储存大量顶点。使用这些缓冲对象的好处是我们可以一次性的发送一大批数据到显卡上，而不是每个顶点发送一次。从CPU把数据发送到显卡相对较慢，所以只要可能我们都尝试尽量一次性发送尽可能多的数据。当数据发送至显卡的内存中后，顶点着色器几乎能立即访问顶点，这个是非常快的过程。
+
+
+把数据发送给OpenGL管线还要更加复杂一点，有两种方式：
+·通过顶点属性的缓冲区；
+·直接发送给统一变量。
+理解这两种方式的机制非常重要，因为这样我们才能为每个要发送的项目选取合适的方式。
+下面从渲染一个简单的立方体开始。
+#####　缓冲区和顶点属性
+想要绘制一个对象，它的顶点数据需要发送给顶点着色器。通常会把顶点数据在C++端放入一个缓冲区，并把这个缓冲区和着色器中声明的顶点属性相关联。要完成这件事，有好几个步骤需要做，有些步骤只需要做一次，而对于动画场景，一些步骤则需要每帧做一次。只做一次的步骤如下，它们一般包含在init()中。
+(1)创建缓冲区。
+(2)将顶点数据复制到缓冲区。
+每帧都要做的步骤如下，它们一般包含在display()中。
+(1)启用包含顶点数据的缓冲区。
+(2)将这个缓冲区和一个顶点属性相关联。
+(3)启用这个顶点属性。
+(4)使用glDrawArrays()绘制对象。
+所有缓冲区通常都在程序开始的时候统一创建，可以在init()中，或者在被init()调用的函数中。在OpenGL中，缓冲区被包含在顶点缓冲对象(Vertex Buffer Object, VBO)中，VBO在C++/OpenGL应用程序中被声明和实例化。一个场景可能需要很多VBO，所以我们常常会在init()中生成并填充若干个VBO，以备程序需要时直接使用。
+
+
 - 图元装配(Primitive Assembly)
 
     顶点组合成图元的过程叫做图元装配，这里的图元就是指点、线、三角。
@@ -95,15 +114,15 @@ OpenGL ES 3.0实现了具有可编程着色功能的图形管线，有两个规
 
     OpenGL ES中最基础且唯一的多边形就是三角形，所有更复杂的图形都是由三角形组成的。复杂的图形都可以拆分成多个三角形。比如OpenGL提供给开发者的绘制方法glDrawArrays，这个方法的第一个参数就是指定绘制方式，可选值有:  
 
-  - GL_POINTS:以点的形式绘制
-  - GL_LINES:以线的形式绘制
-  - GL_TRIANGLE_STRIP:以三角形的形式绘制，所有二维图像的渲染都会使用这种方式。
+    - GL_POINTS:以点的形式绘制
+    - GL_LINES:以线的形式绘制
+    - GL_TRIANGLE_STRIP:以三角形的形式绘制，所有二维图像的渲染都会使用这种方式。
 
-  该过程还有两个重要操作：裁剪和淘汰。
+    该过程还有两个重要操作：裁剪和淘汰。
 
-  - 裁剪是指对于不在视椎体(屏幕上可见的3D区域)内的图元进行裁剪。
+        - 裁剪是指对于不在视椎体(屏幕上可见的3D区域)内的图元进行裁剪。
 
-  - 淘汰是指根据图元面向前方或后方选择抛弃它们(如事物内部的点)。
+        - 淘汰是指根据图元面向前方或后方选择抛弃它们(如事物内部的点)。
    
 - 几何着色器(Geometry Shader)     
 图元装配阶段的输出会传递给几何着色器(Geometry Shader)。几何着色器把图元形式的一系列顶点的集合作为输入，它可以通过产生新顶点构造出新的图元来生成其他形状。本例子中，它生成了另一个三角形。
@@ -111,15 +130,15 @@ OpenGL ES 3.0实现了具有可编程着色功能的图形管线，有两个规
 几何着色器的输出会被传入光栅化阶段(Rasterization Stage)，这里它会把图元映射为最终屏幕上相应的像素，生成供片段着色器(Fragment Shader)使用的片段(Fragment)。在片段着色器运行之前会执行裁切(Clipping)。裁切会丢弃超出你的视图以外的所有像素，用来提升执行效率。
 - 光栅化阶段(Rasterization Stage)
 
-  这里会把图元映射为最终屏幕上相应的像素，生成供片段着色器(fragment shader)使用的片段。在图元装配后传递过来的图元数据中，这些图元信息只是顶点而已。顶点处都还没有像素点，直线段端点之间是空的、多边形的边和内部也是空的，光栅化的任务就是构造这些。将图片转化为片段(fragment)的过程叫做光栅化。 这个阶段会将图元数据分解成更小的单元并对应于帧缓冲区的各个像素，这些单元成为片元，一个片元可能包含窗口颜色、纹理坐标等属性。
+    这里会把图元映射为最终屏幕上相应的像素，生成供片段着色器(fragment shader)使用的片段。在图元装配后传递过来的图元数据中，这些图元信息只是顶点而已。顶点处都还没有像素点，直线段端点之间是空的、多边形的边和内部也是空的，光栅化的任务就是构造这些。将图片转化为片段(fragment)的过程叫做光栅化。 这个阶段会将图元数据分解成更小的单元并对应于帧缓冲区的各个像素，这些单元成为片元，一个片元可能包含窗口颜色、纹理坐标等属性。
 
-  光栅化其实是一种将几何图元变成二维图像的过程。在这里，虚拟3D世界中的物体投影到平面上，并生成一系列的片段。  
+    光栅化其实是一种将几何图元变成二维图像的过程。在这里，虚拟3D世界中的物体投影到平面上，并生成一系列的片段。  
 
 - 片段着色器或片元着色器(Fragment Shader):使用颜色或纹理(texture)渲染图形表面的OpenGLES代码。
 
-  主要目的是计算一个像素的最终颜色。光栅化操作构造了像素点，这个阶段就是处理这些像素点，根据自己的业务，例如高亮、饱和度调节、高斯模糊等来变化这个片元的颜色。为组成点、直线和三角形的每个片元生成最终颜色/纹理，针对每个片元都会执行一次，一个片元是一个小的、单一颜色的长方形区域，类似于计算机屏幕上的一个像素。一旦最终颜色生成，OpenGL就会把它们写到一块成为帧缓冲区的内存块中，然后Android就会把这个帧缓冲区显示到屏幕上。
+    主要目的是计算一个像素的最终颜色。光栅化操作构造了像素点，这个阶段就是处理这些像素点，根据自己的业务，例如高亮、饱和度调节、高斯模糊等来变化这个片元的颜色。为组成点、直线和三角形的每个片元生成最终颜色/纹理，针对每个片元都会执行一次，一个片元是一个小的、单一颜色的长方形区域，类似于计算机屏幕上的一个像素。一旦最终颜色生成，OpenGL就会把它们写到一块成为帧缓冲区的内存块中，然后Android就会把这个帧缓冲区显示到屏幕上。
 
-  通常在这里对片段进行处理(纹理采样、颜色汇总等)，将每个片段的颜色等属性计算出来并送给后续阶段。
+    通常在这里对片段进行处理(纹理采样、颜色汇总等)，将每个片段的颜色等属性计算出来并送给后续阶段。
 
 可以看到，图形渲染管线非常复杂，它包含很多可配置的部分。然而，对于大多数场合，我们只需要配置顶点和片段着色器就行了。几何着色器是可选的，通常使用它默认的着色器就行了。
 
@@ -127,9 +146,9 @@ OpenGL ES 3.0实现了具有可编程着色功能的图形管线，有两个规
 
 - 逐片段操作
 
-  具体的细分步骤又分为:  
+    具体的细分步骤又分为:  
 
-  ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_fragment_opera.jpg)
+    ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_fragment_opera.jpg)
 
   - 像素归属测试
 
@@ -156,37 +175,37 @@ OpenGL ES 3.0实现了具有可编程着色功能的图形管线，有两个规
     用于最小化，因为使用有限精度在帧缓冲区中保存颜色值而产生的伪像，使用少量颜色模拟更宽的颜色范围。
 
 - 帧缓冲区
-
-  OpenGL管线的最终渲染目的地被称为帧缓存(framebuffer也被记做FBO)
+    OpenGL实际上并不是把图像直接绘制到计算机屏幕上，而是将之渲染到一个帧缓冲区，然后由计算机来负责把帧缓冲区中的内容绘制到屏幕上的一个窗口中。
+    OpenGL管线的最终渲染目的地被称为帧缓存(framebuffer也被记做FBO)
 
 - 着色器语言
 
-  GLSL(OpenGL Shading Language)是OpenGL着色语言。
+    GLSL(OpenGL Shading Language)是OpenGL着色语言。
 
-  在图形卡的GPU上执行，代替了固定的渲染管线的一部分，是渲染管线中不同层次具有可编程性，例如：视图转换、投影转换等。GLSL的着色器代码分为两个部分: 
+    在图形卡的GPU上执行，代替了固定的渲染管线的一部分，是渲染管线中不同层次具有可编程性，例如：视图转换、投影转换等。GLSL的着色器代码分为两个部分: 
 
   - 顶点着色器(Vertex Shader)
   - 片段着色器(Fragment Shader)
 
 - 坐标系
 
-  OpenGL ES是一个3D的世界，由x、y、z坐标组成顶点坐标。采用虚拟的右手坐标。
+    OpenGL ES是一个3D的世界，由x、y、z坐标组成顶点坐标。采用虚拟的右手坐标。
 
-  ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_xy.png)
+    ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_xy.png)
 
-  OpenGL ES采用的是右手坐标，选取屏幕中心为原点，从原点到屏幕边缘默认长度为1，也就是默认情况下，从原点到x左边的1和到y左边的1的位置在屏幕上显示的并不相同。
+    OpenGL ES采用的是右手坐标，选取屏幕中心为原点，从原点到屏幕边缘默认长度为1，也就是默认情况下，从原点到x左边的1和到y左边的1的位置在屏幕上显示的并不相同。
 
 - 形状面和缠绕
 
-  在OpenGL的世界里，我们只能画点、线、三角形，图元装配中说到所有复杂的图形都是由三角形组成。
+    在OpenGL的世界里，我们只能画点、线、三角形，图元装配中说到所有复杂的图形都是由三角形组成。
 
-  ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_ex_xy_1.jpg)
+    ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_ex_xy_1.jpg)
 
-  三角形的点按顺序定义，使得它们以逆时针方向绘制。绘制这些坐标的顺序定义了形状的缠绕方向。默认情况下，在OpenGL中，逆时针绘制的面是正面。
+    三角形的点按顺序定义，使得它们以逆时针方向绘制。绘制这些坐标的顺序定义了形状的缠绕方向。默认情况下，在OpenGL中，逆时针绘制的面是正面。
 
 - 程式(Program)
 
-  一个OpenGL ES对象，包含了你所希望用来绘制图形所要用到的着色器，最后顶点着色器和片元着色器都要放入到程式中，然后才可以使用，简单的说就是将两个着色器变为一个对象。
+    一个OpenGL ES对象，包含了你所希望用来绘制图形所要用到的着色器，最后顶点着色器和片元着色器都要放入到程式中，然后才可以使用，简单的说就是将两个着色器变为一个对象。
 
 
 
@@ -202,6 +221,9 @@ OpenGL是一个仅仅关注图像渲染的图像接口库，在渲染过程中
 
 ### EGL
 
+EGL提供了OpenGL ES和运行于计算机上的原生窗口系统(如Windows、Mac OSX)之间的一个“结合”层次。在EGL能够确定可用的绘制表面类型(或者底层系统的其他特性)之前，它必须打开和窗口系统的通信渠道。注意。Apple提供自己的EGL API的iOS实现，成为EAGL。
+因为每个窗口系统都有不同的语音，所以EGL提供基本的不透明类型--EGLDisplay，该类型封装了所有系统相关性，用于和原生窗口系统接口。任何使用EGL的应用程序必须执行的第一个操作就是创建和初始化与本地EGL现实的连接。
+
 OpenGL ES API没有提及如何创建渲染上下文，或者渲染上下文如何连接到原生窗口系统。EGL是Khronos渲染API(如OpenGL ES)和原生窗口系统之间的接口。
 
 在OpenGL的设计中，OpenGL是不负责管理窗口的，窗口的管理交由各个设备自己完成。具体的来说就是iOS平台上使用EAGL提供本地平台对OpenGL的实现，在Android平台上使用EGL提供本地平台对OpenGL的实现。OpenGL其实是通过GPU进行渲染。但是我们的程序是运行在CPU上，要与GPU关联，这就需要通过EGL，它相当于Android上层应用于GPU通讯的中间层。
@@ -240,6 +262,14 @@ EGL为双缓冲工作模式(Double Buffer)，既有一个Back Frame Buffer和一
 
 通过上述操作，就完成了EGL的初始化设置，便可以进行OpenGL的渲染操作。所有EGL命令都是以egl前缀开始，对组成命令名的每个单词使用首字母大写(如eglCreateWindowSurface)。
 
+#### 创建屏幕外渲染区域: EGL Pbuffer
+除了可以用OpenGL ES在屏幕上的窗口渲染之外，还可以渲染称作pbuffer(像素缓冲区Pixel buffer的缩写)的不可见屏幕外表面。
+和窗口一样，Pbuffer可以利用OpenGL ES3.0中的任何硬件加速。
+Pbuffer最常用于生成纹理贴图。如果你想要做的事渲染到一个纹理，那么我们建议使用帧缓冲区对象代替Pbuffer，因为帧缓冲区更高效。不过，在某些帧缓冲区对象无法使用的情况下，Pbuffer仍然有用，例如用OpenGL ES在屏幕外表面上渲染，然后将其作为其他API(如OpenVG)中的纹理。
+创建Pbuffer和创建EGL窗口非常相似，只有少数微小的不同。为了创建Pbuffer，需要和窗口一样找到EGLConfig，并作一处修改：我们需要扩增EGL_SURFACE_TYPE的值，使其包含EGL_PBUFFER_BIT。
+
+
+
 #### OpenGL纹理
 
 纹理(Texture)是一个2D图片(也有1D和3D纹理)，他可以用来添加物体的细节，你可以想象纹理是一张绘有砖块的纸，无缝折叠贴合到你的3D房子上，这样你的房子看起来就有砖墙的外表了。
diff --git "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md" "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
index 86fe7b91..d2bc64a1 100644
--- "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
+++ "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
@@ -78,12 +78,36 @@ void main()
 你可以看到我们在顶点着色器中声明了一个vertexColor变量作为vec4输出，并在片段着色器中声明了一个类似的vertexColor。由于它们名字相同且类型相同，片段着色器中的vertexColor就和顶点着色器中的vertexColor链接了。由于我们在顶点着色器中将颜色设置为深红色，最终的片段也是深红色的。
 
 
+####  精度限定符
+
+精度限定符使着色器创作者可以指定着色器变量的计算精度。变量可以声明为低、中或者高精度。这些限定符用于提示编译器允许在较低的范围和精度上执行变量计算。在较低的精度上，有些OpenGL ES实现在运行着色器时可能更快，或者电源效率更高。
+当然，这种效率提升是以精度为代价的，在没有正确使用精度限定符时可能造成伪像。
+精度限定符可以用于指定任何基于浮点数或者整数的变量的精度。指定精度的关键字是lowp、mediump和highp。
+```glsl
+highp vec4 position;
+mediump float specularExp;
+```
+除了精度限定符之外，还有默认精度的概念。也就是说，如果变量声明时没有使用精度限定符，它将拥有该类型的默认精度。默认精度限定符在顶点或片段着色器的开头用如下语法指定：  
+```glsl
+precision highp float;
+precision mediump int;
+```
+为float类型指定的精度将用作所有基于浮点值的变量的默认精度。同样，为int指定的精度将用作所有基于整数的变量的默认精度。
+在顶点着色器中，如果没有指定默认精度，则int和float的默认精度都为highp，也就是说，顶点着色器中所有没有精度限定符声明的变量都使用最高的精度。
+
+但片段着色器的规则与此不同，在片段着色器中，浮点值没有默认的精度值：每个着色器必须声明一个默认的float精度，或者为每个float变量指定精度。
+
+
 
 #### Uniform
 Uniform是一种从CPU中的应用向GPU中的着色器发送数据的方式，但uniform和顶点属性有些不同。首先，uniform是全局的(Global)。全局意味着uniform变量必须在每个着色器程序对象中都是独一无二的，而且它可以被着色器程序的任意着色器在任意阶段访问。第二，无论你把uniform值设置成什么，uniform会一直保存它们的数据，直到它们被重置或更新。
 
-我们可以在一个着色器中添加uniform关键字至类型和变量名前来声明一个GLSL的uniform。从此处开始我们就可以在着色器中使用新声明的uniform了。我们来看看这次是否能通过uniform设置三角形的颜色：
+统一变量通常保存在硬件中，这个区域被称作“常量存储”，是硬件中为存储常量值而分配的特殊空间。因为常量存储的大小一般是固定的，所以程序中可以使用的统一变量数量受到限制。这种限制可以通过读取内建变量gl_MaxVertexUniformVectors和gl_MaxFragmentUniformVectors的值来确定。
+但是对于在编译时已知值的变量应该是常量，而不是统一变量，这样可以提高效率。
 
+
+我们可以在一个着色器中添加uniform关键字至类型和变量名前来声明一个GLSL的uniform。从此处开始我们就可以在着色器中使用新声明的uniform了。我们来看看这次是否能通过uniform设置三角形的颜色：
+```glsl
 #version 330 core
 out vec4 FragColor;
 
@@ -93,22 +117,26 @@ void main()
 {
     FragColor = ourColor;
 }
+```
 我们在片段着色器中声明了一个uniform vec4的ourColor，并把片段着色器的输出颜色设置为uniform值的内容。因为uniform是全局变量，我们可以在任何着色器中定义它们，而无需通过顶点着色器作为中介。顶点着色器中不需要这个uniform，所以我们不用在那里定义它。
 
 如果你声明了一个uniform却在GLSL代码中没用过，编译器会静默移除这个变量，导致最后编译出的版本中并不会包含它，这可能导致几个非常麻烦的错误，记住这点！
 
 这个uniform现在还是空的；我们还没有给它添加任何数据，所以下面我们就做这件事。我们首先需要找到着色器中uniform属性的索引/位置值。当我们得到uniform的索引/位置值后，我们就可以更新它的值了。这次我们不去给像素传递单独一个颜色，而是让它随着时间改变颜色：
-
+```glsl
 float timeValue = glfwGetTime();
 float greenValue = (sin(timeValue) / 2.0f) + 0.5f;
 int vertexColorLocation = glGetUniformLocation(shaderProgram, "ourColor");
 glUseProgram(shaderProgram);
 glUniform4f(vertexColorLocation, 0.0f, greenValue, 0.0f, 1.0f);
+```
 首先我们通过glfwGetTime()获取运行的秒数。然后我们使用sin函数让颜色在0.0到1.0之间改变，最后将结果储存到greenValue里。
 
-接着，我们用glGetUniformLocation查询uniform ourColor的位置值。我们为查询函数提供着色器程序和uniform的名字（这是我们希望获得的位置值的来源）。如果glGetUniformLocation返回-1就代表没有找到这个位置值。最后，我们可以通过glUniform4f函数设置uniform值。注意，查询uniform地址不要求你之前使用过着色器程序，但是更新一个uniform之前你必须先使用程序（调用glUseProgram)，因为它是在当前激活的着色器程序中设置uniform的。
-
+接着，我们用glGetUniformLocation查询uniform ourColor的位置值。我们为查询函数提供着色器程序和uniform的名字（这是我们希望获得的位置值的来源）。
+如果glGetUniformLocation返回-1就代表没有找到这个位置值。
+最后，我们可以通过glUniform4f函数设置uniform值。注意，查询uniform地址不要求你之前使用过着色器程序，但是更新一个uniform之前你必须先使用程序（调用glUseProgram)，因为它是在当前激活的着色器程序中设置uniform的。
 
+现在你知道如何设置uniform变量的值了，我们可以使用它们来渲染了。如果我们打算让颜色慢慢变化，我们就要在游戏循环的每一次迭代中（所以他会逐帧改变）更新这个uniform，否则三角形就不会改变颜色。
 
 
 内建变量包括:
diff --git "a/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md" "b/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
index 2eb24927..67fb2790 100644
--- "a/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
+++ "b/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
@@ -163,6 +163,29 @@ Matrix就是专门设计出来帮助我们简化矩阵和向量运算操作的
 
   获取逆矩阵
 
+
+
+顶点着色器可赋予程序员一次操作一个顶点（“按顶点”处理）的能力，片段着色器（稍后会看到）可赋予程序员一次操作一个像素（“按片段”处理）的能力，几何着色器可赋予程序员一次操作一个图元（“按图元”处理）的能力。
+
+到目前为止，我们所接触的变换矩阵全都可以在3D空间中操作。但是，我们最终需要将3D空间或它的一部分展示在2D显示器上。为了达成这个目标，我们需要找到一个有利点。正如我们在现实世界通过眼睛从一点观察一样，我们也必须找到一点并确立观察方向作为我们观察虚拟世界的窗口。这个点叫作视图或视觉空间，或“合成相机”（简称相机）。
+
+观察3D世界需要：(a)将相机放入世界的某个位置；(b)调整相机的角度，通常需要一套它自己的直角坐标轴u、v、n（由向量U，V，N构成）；(c)定义一个视体(view volume)；(d)将视体内的对象投影到投影平面(projection plane)上。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_eye.jpg?raw=true)
+
+OpenGL有一个固定在原点(0,0,0)并朝向z轴负方向的相机，如下图所示。
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_eye_00.jpg?raw=true)
+为了应用OpenGL相机，我们需要将它移动到适合的位置和方向。我们需要先找出在世界中的物体与我们期望的相机位置的相对位置（如物体应该在由图3.12所示相机U、V、N向量定义的“相机空间”中的位置）。给定世界空间中的点PW，我们需要通过变换将它转换成相应相机空间中的点，从而让它看起来好像是从我们期望的相机位置CW看到的样子。我们通过计算它在相机空间中的位置PC实现。已知OpenGL相机位置永远固定在点(0,0,0)，那么我们如何变换来实现上述功能？
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_eye_01.jpg?raw=true)
+
+当我们设置好相机之后，就可以学习投影矩阵了。我们需要学习的两个重要的投影矩阵：透视投影矩阵和正射投影矩阵。透视投影通过使用透视概念模仿我们看真实世界的方式，尝试让2D图像看起来像是3D的。物体近大远小，3D空间中有的平行线用透视法画出来就不再平行。我们可以通过使用变换矩阵将平行线变为恰当的不平行线来实现这个效果，这个矩阵叫作透视矩阵或者透视变换。
+
+在正射投影中，平行线仍然是平行的，即不使用透视，如下图所示。正射与透视相反，在视体中的物体不因其与相机的距离而改变，可以直接投影。正射投影是一种平行投影，其中所有的投影过程都沿与投影平面垂直的方向进行。
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_zheng.jpg?raw=true)
+
+我们最后要学习的变换矩阵是LookAt矩阵。当你想要把相机放在某处并看向一个特定的位置时，就需要用到它了，LookAt矩阵的元素如图3.19所示。当然，用我们已经学到的方法也可以实现LookAt变换，但是这个操作非常频繁，因此为它专门构建一个矩阵通常比较有用。
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_lookat.jpg?raw=true)
+
 - invertM
 
   计算正交投影和透视投影

From d0706b45ee1a70fc61e4bbb6b414aee2334b3719 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Tue, 9 May 2023 16:56:33 +0800
Subject: [PATCH 107/213] update opengl part

---
 .../1.OpenGL\347\256\200\344\273\213.md"      | 23 +++++-
 ...66\344\270\211\350\247\222\345\275\242.md" | 34 +++++++++
 ...42\345\217\212\345\234\206\345\275\242.md" | 58 +++++++++++++++
 ...45\231\250\350\257\255\350\250\200GLSL.md" | 73 ++++++++++++++++++-
 4 files changed, 186 insertions(+), 2 deletions(-)

diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
index fdadeeed..c0ae0d62 100644
--- "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -85,9 +85,30 @@ OpenGL ES 3.0实现了具有可编程着色功能的图形管线，有两个规
 
     顶点着色器可以操作的属性有: 位置、颜色、纹理坐标，但是不能创建新的顶点。最终产生纹理坐标、颜色、点位置等信息送往后续阶段。
 
-    顶点着色器会在GPU上创建内存用于存储我们的顶点数据，还要配置OpenGL如何解释这些内存，并且指定其如何发送给显卡。顶点着色器接着回处理我们在内存中指定数量的顶点。
+    顶点着色器会在GPU上创建内存用于存储我们的顶点数据，还要配置OpenGL如何解释这些内存，并且指定其如何发送给显卡。顶点着色器接着会处理我们在内存中指定数量的顶点。
     我们通过顶点缓冲对象(Vertex Buffer Object, VBO)管理这个内存，它会在GPU内存(通常被称为显存)中储存大量顶点。使用这些缓冲对象的好处是我们可以一次性的发送一大批数据到显卡上，而不是每个顶点发送一次。从CPU把数据发送到显卡相对较慢，所以只要可能我们都尝试尽量一次性发送尽可能多的数据。当数据发送至显卡的内存中后，顶点着色器几乎能立即访问顶点，这个是非常快的过程。
 
+    顶点缓冲对象是OpenGL中的一个对象，就像OpenGL中的其它对象一样，这个缓冲有一个独一无二的ID，所以我们可以使用glGenBuffers()函数和一个缓冲ID生成一个VBO对象: 
+    ```c++
+    unsigned int VBO;
+    glGenBuffers(1, &VBO)
+    ```
+    在OpenGL中有很多缓冲对象类型，顶点缓冲对象的缓冲类型是GL_ARRAY_BUFFER。OpenGL允许我们同时绑定多个缓冲，只要它们是不同的缓冲类型。我们可以使用glBindBuffer函数把新创建的缓冲绑定到GL_ARRAY_BUFFER目标上:  
+    ```c++
+    glBindBuffer(GL_ARRAY_BUFFER, VBO);
+    ```
+    从这一刻起，我们使用的任何(在GL_ARRAY_BUFFER目标上的)缓冲调用都会用来配置当前绑定的缓冲(VBO)。然后我们可以调用glBufferData()函数，它会把之前定义的顶点数据复制到缓冲的内存中:   
+    ```c++
+    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
+    ```
+    glBufferData是一个专门用来把用户定义的数据复制到当前绑定缓冲的函数。
+    他的第一个参数是目标缓冲的类型：顶点缓冲对象当前绑定到GL_ARRAY_BUFFER目标上。
+    第二个参数是指定传输数据的大小(以字节为单位)，用一个简单的sizeof计算顶点数据的大小就可以。
+    第三个参数是我们希望发送的实际数据。
+    第四个参数指定了我们希望显卡如何管理给定的数据。它有三种形式: 
+    - GL_STATIC_DRAW ：数据不会或几乎不会改变。
+    - GL_DYNAMIC_DRAW：数据会被改变很多。
+    - GL_STREAM_DRAW ：数据每次绘制时都会改变。
 
 把数据发送给OpenGL管线还要更加复杂一点，有两种方式：
 ·通过顶点属性的缓冲区；
diff --git "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md" "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"
index d29e7cdb..63a69e62 100644
--- "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
@@ -144,8 +144,42 @@ someOpenGLFunctionThatDrawsOurTriangle();
 每当我们绘制一个物体的时候都必须重复这一过程。这看起来可能不多，但是如果有超过5个顶点属性，上百个不同物体呢（这其实并不罕见）。绑定正确的缓冲对象，为每个物体配置所有顶点属性很快就变成一件麻烦事。有没有一些方法可以使我们把所有这些状态配置储存在一个对象中，并且可以通过绑定这个对象来恢复状态呢？
 
 顶点数组对象(Vertex Array Object, VAO)可以像顶点缓冲对象那样被绑定，任何随后的顶点属性调用都会储存在这个VAO中。这样的好处就是，当配置顶点属性指针时，你只需要将那些调用执行一次，之后再绘制物体的时候只需要绑定相应的VAO就行了。这使在不同顶点数据和属性配置之间切换变得非常简单，只需要绑定不同的VAO就行了。刚刚设置的所有状态都将存储在VAO中。
+
+一个顶点数组对象会储存以下这些内容：
+
+- glEnableVertexAttribArray和glDisableVertexAttribArray的调用。
+- 通过glVertexAttribPointer设置的顶点属性配置。
+- 通过glVertexAttribPointer调用与顶点属性关联的顶点缓冲对象。
+
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/vertex_array_objects.png)
 
+创建一个VAO和创建一个VBO很类似：
+```c++
+unsigned int VAO;
+glGenVertexArrays(1, &VAO);
+```
+要想使用VAO，要做的只是使用glBindVertexArray绑定VAO。从绑定之后起，我们应该绑定和配置对应的VBO和属性指针，之后解绑VAO供之后使用。当我们打算绘制一个物体的时候，我们只要在绘制物体前简单地把VAO绑定到希望使用的设定上就行了。这段代码应该看起来像这样：
+```c++
+// ..:: 初始化代码（只运行一次 (除非你的物体频繁改变)） :: ..
+// 1. 绑定VAO
+glBindVertexArray(VAO);
+// 2. 把顶点数组复制到缓冲中供OpenGL使用
+glBindBuffer(GL_ARRAY_BUFFER, VBO);
+glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
+// 3. 设置顶点属性指针
+glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
+glEnableVertexAttribArray(0);
+
+[...]
+
+// ..:: 绘制代码（渲染循环中） :: ..
+// 4. 绘制物体
+glUseProgram(shaderProgram);
+glBindVertexArray(VAO);
+someOpenGLFunctionThatDrawsOurTriangle();
+```
+
+就这么多了！前面做的一切都是等待这一刻，一个储存了我们顶点属性配置和应使用的VBO的顶点数组对象。一般当你打算绘制多个物体时，你首先要生成/配置所有的VAO（和必须的VBO及属性指针)，然后储存它们供后面使用。当我们打算绘制物体的时候就拿出相应的VAO，绑定它，绘制完物体后，再解绑VAO。
 
 
 
diff --git "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md" "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"
index 37e1661c..380db0a9 100644
--- "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"	
@@ -155,6 +155,64 @@ public abstract class BaseGLSurfaceViewRenderer implements GLSurfaceView.Rendere
 之前说过OpenGL ES提供的的图元单位是三角形，想要绘制其他多边形，就要利用三角形来拼成。 矩形是两个三角形，而圆形则是由很多个三角形组成，个数越多，圆越圆。
 
 
+### 元素缓冲对象(EBO)
+在渲染顶点这一话题上我们还有最后一个需要讨论的东西——元素缓冲对象(Element Buffer Object，EBO)，也叫索引缓冲对象(Index Buffer Object，IBO)。要解释元素缓冲对象的工作方式最好还是举个例子：假设我们不再绘制一个三角形而是绘制一个矩形。我们可以绘制两个三角形来组成一个矩形（OpenGL主要处理三角形）。这会生成下面的顶点的集合：
+```
+float vertices[] = {
+    // 第一个三角形
+    0.5f, 0.5f, 0.0f,   // 右上角
+    0.5f, -0.5f, 0.0f,  // 右下角
+    -0.5f, 0.5f, 0.0f,  // 左上角
+    // 第二个三角形
+    0.5f, -0.5f, 0.0f,  // 右下角
+    -0.5f, -0.5f, 0.0f, // 左下角
+    -0.5f, 0.5f, 0.0f   // 左上角
+};
+```
+可以看到，有几个顶点叠加了。我们指定了右下角和左上角两次！一个矩形只有4个而不是6个顶点，这样就产生50%的额外开销。当我们有包括上千个三角形的模型之后这个问题会更糟糕，这会产生一大堆浪费。更好的解决方案是只储存不同的顶点，并设定绘制这些顶点的顺序。这样子我们只要储存4个顶点就能绘制矩形了，之后只要指定绘制的顺序就行了。如果OpenGL提供这个功能就好了，对吧？
+
+值得庆幸的是，元素缓冲区对象的工作方式正是如此。 EBO是一个缓冲区，就像一个顶点缓冲区对象一样，它存储 OpenGL 用来决定要绘制哪些顶点的索引。这种所谓的索引绘制(Indexed Drawing)正是我们问题的解决方案。首先，我们先要定义（不重复的）顶点，和绘制出矩形所需的索引：
+```
+float vertices[] = {
+    0.5f, 0.5f, 0.0f,   // 右上角
+    0.5f, -0.5f, 0.0f,  // 右下角
+    -0.5f, -0.5f, 0.0f, // 左下角
+    -0.5f, 0.5f, 0.0f   // 左上角
+};
+
+unsigned int indices[] = {
+    // 注意索引从0开始! 
+    // 此例的索引(0,1,2,3)就是顶点数组vertices的下标，
+    // 这样可以由下标代表顶点组合成矩形
+
+    0, 1, 3, // 第一个三角形
+    1, 2, 3  // 第二个三角形
+};
+```
+你可以看到，当使用索引的时候，我们只定义了4个顶点，而不是6个。下一步我们需要创建元素缓冲对象：
+```
+unsigned int EBO;
+glGenBuffers(1, &EBO);
+```
+与VBO类似，我们先绑定EBO然后用glBufferData把索引复制到缓冲里。同样，和VBO类似，我们会把这些函数调用放在绑定和解绑函数调用之间，只不过这次我们把缓冲的类型定义为GL_ELEMENT_ARRAY_BUFFER。
+```
+glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
+glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
+```
+注意：我们传递了GL_ELEMENT_ARRAY_BUFFER当作缓冲目标。最后一件要做的事是用glDrawElements来替换glDrawArrays函数，表示我们要从索引缓冲区渲染三角形。使用glDrawElements时，我们会使用当前绑定的索引缓冲对象中的索引进行绘制：
+```
+glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
+glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
+```
+第一个参数指定了我们绘制的模式，这个和glDrawArrays的一样。第二个参数是我们打算绘制顶点的个数，这里填6，也就是说我们一共需要绘制6个顶点。第三个参数是索引的类型，这里是GL_UNSIGNED_INT。最后一个参数里我们可以指定EBO中的偏移量（或者传递一个索引数组，但是这是当你不在使用索引缓冲对象的时候），但是我们会在这里填写0。
+
+glDrawElements函数从当前绑定到GL_ELEMENT_ARRAY_BUFFER目标的EBO中获取其索引。这意味着我们每次想要使用索引渲染对象时都必须绑定相应的EBO，这又有点麻烦。碰巧顶点数组对象也跟踪元素缓冲区对象绑定。在绑定VAO时，绑定的最后一个元素缓冲区对象存储为VAO的元素缓冲区对象。然后，绑定到VAO也会自动绑定该EBO。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/vertex_array_objects_ebo.png?raw=true)
+
+当目标是GL_ELEMENT_ARRAY_BUFFER的时候，VAO会储存glBindBuffer的函数调用。这也意味着它也会储存解绑调用，所以确保你没有在解绑VAO之前解绑索引数组缓冲，否则它就没有这个EBO配置了。
+
+
 
 ### 绘制矩形
 
diff --git "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md" "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
index d2bc64a1..28295e70 100644
--- "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
+++ "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
@@ -1,5 +1,13 @@
 ## 7.OpenGL ES着色器语言GLSL
 
+着色器是使用一种叫GLSL的类C语言写成的。GLSL是为图形计算量身定制的，它包含一些针对向量和矩阵操作的有用特性。
+
+着色器的开头总是要声明版本，接着是输入和输出变量、uniform和main函数。每个着色器的入口点都是main函数，在这个函数中我们处理所有的输入变量，并将结果输出到输出变量中。
+
+和其他编程语言一样，GLSL有数据类型可以来指定变量的种类。GLSL中包含C等其它语言大部分的默认基础数据类型：int、float、double、uint和bool。GLSL也有两种容器类型，它们会在这个教程中使用很多，分别是向量(Vector)和矩阵(Matrix)。
+
+
+
 在计算机图形中，两个基本数据类型组成了变换的基础：
 - 向量
 - 矩阵
@@ -136,6 +144,16 @@ glUniform4f(vertexColorLocation, 0.0f, greenValue, 0.0f, 1.0f);
 如果glGetUniformLocation返回-1就代表没有找到这个位置值。
 最后，我们可以通过glUniform4f函数设置uniform值。注意，查询uniform地址不要求你之前使用过着色器程序，但是更新一个uniform之前你必须先使用程序（调用glUseProgram)，因为它是在当前激活的着色器程序中设置uniform的。
 
+因为OpenGL在其核心是一个C库，所以它不支持类型重载，在函数参数不同的时候就要为其定义新的函数；glUniform是一个典型例子。这个函数有一个特定的后缀，标识设定的uniform的类型。可能的后缀有：
+
+- f : 函数需要一个float作为它的值
+- i : 函数需要一个int作为它的值
+- ui: 函数需要一个unsigned int作为它的值
+- 3f: 函数需要3个float作为它的值
+- fv: 函数需要一个float向量/数组作为它的值
+
+每当你打算配置一个OpenGL的选项时就可以简单地根据这些规则选择适合你的数据类型的重载函数。在我们的例子里，我们希望分别设定uniform的4个float值，所以我们通过glUniform4f传递我们的数据(注意，我们也可以使用fv版本)。
+
 现在你知道如何设置uniform变量的值了，我们可以使用它们来渲染了。如果我们打算让颜色慢慢变化，我们就要在游戏循环的每一次迭代中（所以他会逐帧改变）更新这个uniform，否则三角形就不会改变颜色。
 
 
@@ -231,7 +249,11 @@ vec4 result = vec4(vect, 0.0, 0.0);
 
 - 矩阵
 
-  在GLSL中矩阵拥有2 * 2、3 * 3、4 * 4三种类型的矩阵，分别用mat2、mat3、mat4表示。我们可以把矩阵看做是一个二维数组，也可以用二维数组下表的方式取里面具体位置的值。
+在GLSL中矩阵拥有2 * 2、3 * 3、4 * 4三种类型的矩阵，分别用mat2、mat3、mat4表示。我们可以把矩阵看做是一个二维数组，也可以用二维数组下表的方式取里面具体位置的值。
+现在我们已经讨论了向量的全部内容，是时候看看矩阵了！简单来说矩阵就是一个矩形的数字、符号或表达式数组。矩阵中每一项叫做矩阵的元素(Element)。下面是一个2×3矩阵的例子：
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/juzhen_0.png?raw=true)
+
+矩阵可以通过(i, j)进行索引，i是行，j是列，这就是上面的矩阵叫做2×3矩阵的原因（3列2行，也叫做矩阵的维度(Dimension)）。这与你在索引2D图像时的(x, y)相反，获取4的索引是(2, 1)（第二行，第一列）（译注：如果是图像索引应该是(1, 2)，先算列，再算行）
 
 - 采样器
 
@@ -363,7 +385,56 @@ GLSL的类型转换与C不同。在GLSL中类型不可以自动提升，比如fl
 - not(bvec x)：x所有分量执行逻辑非运算
 
 
+### 更多
+
+在前面的教程中，我们了解了如何填充VBO、配置顶点属性指针以及如何把它们都储存到一个VAO里。这次，我们同样打算把颜色数据加进顶点数据中。我们将把颜色数据添加为3个float值至vertices数组。我们将把三角形的三个角分别指定为红色、绿色和蓝色：
+
+float vertices[] = {
+    // 位置              // 颜色
+     0.5f, -0.5f, 0.0f,  1.0f, 0.0f, 0.0f,   // 右下
+    -0.5f, -0.5f, 0.0f,  0.0f, 1.0f, 0.0f,   // 左下
+     0.0f,  0.5f, 0.0f,  0.0f, 0.0f, 1.0f    // 顶部
+};
+由于现在有更多的数据要发送到顶点着色器，我们有必要去调整一下顶点着色器，使它能够接收颜色值作为一个顶点属性输入。需要注意的是我们用layout标识符来把aColor属性的位置值设置为1：
+
+#version 330 core
+layout (location = 0) in vec3 aPos;   // 位置变量的属性位置值为 0 
+layout (location = 1) in vec3 aColor; // 颜色变量的属性位置值为 1
+
+out vec3 ourColor; // 向片段着色器输出一个颜色
 
+void main()
+{
+    gl_Position = vec4(aPos, 1.0);
+    ourColor = aColor; // 将ourColor设置为我们从顶点数据那里得到的输入颜色
+}
+由于我们不再使用uniform来传递片段的颜色了，现在使用ourColor输出变量，我们必须再修改一下片段着色器：
+
+#version 330 core
+out vec4 FragColor;  
+in vec3 ourColor;
+
+void main()
+{
+    FragColor = vec4(ourColor, 1.0);
+}
+因为我们添加了另一个顶点属性，并且更新了VBO的内存，我们就必须重新配置顶点属性指针。更新后的VBO内存中的数据现在看起来像这样：
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/vertex_attribute_pointer_interleaved.png?raw=true)
+
+知道了现在使用的布局，我们就可以使用glVertexAttribPointer函数更新顶点格式，
+```
+// 位置属性
+glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0);
+glEnableVertexAttribArray(0);
+// 颜色属性
+glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3* sizeof(float)));
+// 1是对应上面着色器代码中的位置： layout (location = 1) in vec3 aColor; 颜色变量的属性位置值为 1
+glEnableVertexAttribArray(1);
+glVertexAttribPointer函数的前几个参数比较明了。这次我们配置属性位置值为1的顶点属性。颜色值有3个float那么大，我们不去标准化这些值。
+```
+由于我们现在有了两个顶点属性，我们不得不重新计算步长值。为获得数据队列中下一个属性值（比如位置向量的下个x分量）我们必须向右移动6个float，其中3个是位置值，另外3个是颜色值。这使我们的步长值为6乘以float的字节数（=24字节）。
+同样，这次我们必须指定一个偏移量。对于每个顶点来说，位置顶点属性在前，所以它的偏移量是0。颜色属性紧随位置数据之后，所以偏移量就是3 * sizeof(float)，用字节来计算就是12字节。
 
 
 

From 144205bf4384b5c944564cf497385825345bd964 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Tue, 9 May 2023 21:48:58 +0800
Subject: [PATCH 108/213] update opengl

---
 .../1.OpenGL\347\256\200\344\273\213.md"      |  95 ++++----
 ...66\344\270\211\350\247\222\345\275\242.md" | 215 +++++++++++-------
 2 files changed, 180 insertions(+), 130 deletions(-)

diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
index c0ae0d62..effb8b0d 100644
--- "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -89,49 +89,55 @@ OpenGL ES 3.0实现了具有可编程着色功能的图形管线，有两个规
     我们通过顶点缓冲对象(Vertex Buffer Object, VBO)管理这个内存，它会在GPU内存(通常被称为显存)中储存大量顶点。使用这些缓冲对象的好处是我们可以一次性的发送一大批数据到显卡上，而不是每个顶点发送一次。从CPU把数据发送到显卡相对较慢，所以只要可能我们都尝试尽量一次性发送尽可能多的数据。当数据发送至显卡的内存中后，顶点着色器几乎能立即访问顶点，这个是非常快的过程。
 
     顶点缓冲对象是OpenGL中的一个对象，就像OpenGL中的其它对象一样，这个缓冲有一个独一无二的ID，所以我们可以使用glGenBuffers()函数和一个缓冲ID生成一个VBO对象: 
-    ```c++
-    unsigned int VBO;
-    glGenBuffers(1, &VBO)
+    ```java
+    // 下面只生成一个vbo对象，所以vbo的容量设置为1即可
+    IntBuffer vbo = IntBuffer.allocate(1);
+    // 该方法有两个参数，第一个是输入生成纹理的数量，然后把它们的id储存在第二个参数的IntBuffer数组中
+    GLES30.glGenBuffers(1, vbo);
     ```
     在OpenGL中有很多缓冲对象类型，顶点缓冲对象的缓冲类型是GL_ARRAY_BUFFER。OpenGL允许我们同时绑定多个缓冲，只要它们是不同的缓冲类型。我们可以使用glBindBuffer函数把新创建的缓冲绑定到GL_ARRAY_BUFFER目标上:  
-    ```c++
-    glBindBuffer(GL_ARRAY_BUFFER, VBO);
+    ```java
+    GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, vbo.get(0));
     ```
     从这一刻起，我们使用的任何(在GL_ARRAY_BUFFER目标上的)缓冲调用都会用来配置当前绑定的缓冲(VBO)。然后我们可以调用glBufferData()函数，它会把之前定义的顶点数据复制到缓冲的内存中:   
-    ```c++
-    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
+    ```java
+    GLES30.glBufferData(GLES30.GL_ARRAY_BUFFER, POSITION_VERTEX.size * 4,
+                    vertexBuffer, GLES30.GL_STATIC_DRAW);
     ```
     glBufferData是一个专门用来把用户定义的数据复制到当前绑定缓冲的函数。
     他的第一个参数是目标缓冲的类型：顶点缓冲对象当前绑定到GL_ARRAY_BUFFER目标上。
-    第二个参数是指定传输数据的大小(以字节为单位)，用一个简单的sizeof计算顶点数据的大小就可以。
+    第二个参数是指定传输数据的大小(以字节为单位)，c++中用一个简单的sizeof计算顶点数据的大小就可以，这里float的大小为4个字节。
     第三个参数是我们希望发送的实际数据。
     第四个参数指定了我们希望显卡如何管理给定的数据。它有三种形式: 
     - GL_STATIC_DRAW ：数据不会或几乎不会改变。
     - GL_DYNAMIC_DRAW：数据会被改变很多。
     - GL_STREAM_DRAW ：数据每次绘制时都会改变。
 
-把数据发送给OpenGL管线还要更加复杂一点，有两种方式：
-·通过顶点属性的缓冲区；
-·直接发送给统一变量。
-理解这两种方式的机制非常重要，因为这样我们才能为每个要发送的项目选取合适的方式。
-下面从渲染一个简单的立方体开始。
-#####　缓冲区和顶点属性
-想要绘制一个对象，它的顶点数据需要发送给顶点着色器。通常会把顶点数据在C++端放入一个缓冲区，并把这个缓冲区和着色器中声明的顶点属性相关联。要完成这件事，有好几个步骤需要做，有些步骤只需要做一次，而对于动画场景，一些步骤则需要每帧做一次。只做一次的步骤如下，它们一般包含在init()中。
-(1)创建缓冲区。
-(2)将顶点数据复制到缓冲区。
-每帧都要做的步骤如下，它们一般包含在display()中。
-(1)启用包含顶点数据的缓冲区。
-(2)将这个缓冲区和一个顶点属性相关联。
-(3)启用这个顶点属性。
-(4)使用glDrawArrays()绘制对象。
-所有缓冲区通常都在程序开始的时候统一创建，可以在init()中，或者在被init()调用的函数中。在OpenGL中，缓冲区被包含在顶点缓冲对象(Vertex Buffer Object, VBO)中，VBO在C++/OpenGL应用程序中被声明和实例化。一个场景可能需要很多VBO，所以我们常常会在init()中生成并填充若干个VBO，以备程序需要时直接使用。
+    把数据发送给OpenGL管线还要更加复杂一点，有两种方式:      
+    - 通过顶点属性的缓冲区；
+    - 直接发送给统一变量。
+    理解这两种方式的机制非常重要，因为这样我们才能为每个要发送的项目选取合适的方式。  
+
+
+#####　缓冲区和顶点属性    
+
+想要绘制一个对象，它的顶点数据需要发送给顶点着色器。通常会把顶点数据在放入一个缓冲区，并把这个缓冲区和着色器中声明的顶点属性相关联。要完成这件事，有好几个步骤需要做，有些步骤只需要做一次，而对于动画场景，一些步骤则需要每帧做一次。只做一次的步骤如下，它们一般包含在init()中:      
+
+- 创建缓冲区。
+- 将顶点数据复制到缓冲区。    
+    每帧都要做的步骤如下，它们一般包含在display()中。
+- 启用包含顶点数据的缓冲区。
+- 将这个缓冲区和一个顶点属性相关联。
+- 启用这个顶点属性。
+- 使用glDrawArrays()绘制对象。
+所有缓冲区通常都在程序开始的时候统一创建，可以在init()中，或者在被init()调用的函数中。在OpenGL中，缓冲区被包含在顶点缓冲对象(Vertex Buffer Object, VBO)中，VBO在OpenGL应用程序中被声明和实例化。一个场景可能需要很多VBO，所以我们常常会在init()中生成并填充若干个VBO，以备程序需要时直接使用。
 
 
 - 图元装配(Primitive Assembly)
 
-    顶点组合成图元的过程叫做图元装配，这里的图元就是指点、线、三角。
-    图元装配阶段将顶点着色器输出的所有顶点作为输入(如果是GL_POINTS，那么就是一个顶点),并将所有的点装配成指定的图元的形状，上图的例子中是一个三角形。
-    也就是说图元装配是将顶点着色器中设置的顶点数据装配成指定图元的形状。
+    顶点组合成图元的过程叫做图元装配，这里的图元就是指点、线、三角。     
+    图元装配阶段将顶点着色器输出的所有顶点作为输入(如果是GL_POINTS，那么就是一个顶点),并将所有的点装配成指定的图元的形状。           
+    也就是说图元装配是将顶点着色器中设置的顶点数据装配成指定图元的形状。    
 
     OpenGL ES中最基础且唯一的多边形就是三角形，所有更复杂的图形都是由三角形组成的。复杂的图形都可以拆分成多个三角形。比如OpenGL提供给开发者的绘制方法glDrawArrays，这个方法的第一个参数就是指定绘制方式，可选值有:  
 
@@ -140,18 +146,18 @@ OpenGL ES 3.0实现了具有可编程着色功能的图形管线，有两个规
     - GL_TRIANGLE_STRIP:以三角形的形式绘制，所有二维图像的渲染都会使用这种方式。
 
     该过程还有两个重要操作：裁剪和淘汰。
-
-        - 裁剪是指对于不在视椎体(屏幕上可见的3D区域)内的图元进行裁剪。
-
-        - 淘汰是指根据图元面向前方或后方选择抛弃它们(如事物内部的点)。
+    - 裁剪是指对于不在视椎体(屏幕上可见的3D区域)内的图元进行裁剪。
+    - 淘汰是指根据图元面向前方或后方选择抛弃它们(如事物内部的点)。
    
 - 几何着色器(Geometry Shader)     
-图元装配阶段的输出会传递给几何着色器(Geometry Shader)。几何着色器把图元形式的一系列顶点的集合作为输入，它可以通过产生新顶点构造出新的图元来生成其他形状。本例子中，它生成了另一个三角形。
+    图元装配阶段的输出会传递给几何着色器(Geometry Shader)。几何着色器把图元形式的一系列顶点的集合作为输入，它可以通过产生新顶点构造出新的图元来生成其他形状。本例子中，它生成了另一个三角形。
 
-几何着色器的输出会被传入光栅化阶段(Rasterization Stage)，这里它会把图元映射为最终屏幕上相应的像素，生成供片段着色器(Fragment Shader)使用的片段(Fragment)。在片段着色器运行之前会执行裁切(Clipping)。裁切会丢弃超出你的视图以外的所有像素，用来提升执行效率。
+    几何着色器的输出会被传入光栅化阶段(Rasterization Stage)，这里它会把图元映射为最终屏幕上相应的像素，生成供片段着色器(Fragment Shader)使用的片段(Fragment)。在片段着色器运行之前会执行裁切(Clipping)。裁切会丢弃超出你的视图以外的所有像素，用来提升执行效率。
 - 光栅化阶段(Rasterization Stage)
 
-    这里会把图元映射为最终屏幕上相应的像素，生成供片段着色器(fragment shader)使用的片段。在图元装配后传递过来的图元数据中，这些图元信息只是顶点而已。顶点处都还没有像素点，直线段端点之间是空的、多边形的边和内部也是空的，光栅化的任务就是构造这些。将图片转化为片段(fragment)的过程叫做光栅化。 这个阶段会将图元数据分解成更小的单元并对应于帧缓冲区的各个像素，这些单元成为片元，一个片元可能包含窗口颜色、纹理坐标等属性。
+    这里会把图元映射为最终屏幕上相应的像素，生成供片段着色器(fragment shader)使用的片段。     
+    在图元装配后传递过来的图元数据中，这些图元信息只是顶点而已。顶点处都还没有像素点，直线段端点之间是空的、多边形的边和内部也是空的，光栅化的任务就是构造这些。将图片转化为片段(fragment)的过程叫做光栅化。      
+    这个阶段会将图元数据分解成更小的单元并对应于帧缓冲区的各个像素，这些单元成为片元，一个片元可能包含窗口颜色、纹理坐标等属性。
 
     光栅化其实是一种将几何图元变成二维图像的过程。在这里，虚拟3D世界中的物体投影到平面上，并生成一系列的片段。  
 
@@ -236,23 +242,26 @@ OpenGL ES 3.0实现了具有可编程着色功能的图形管线，有两个规
 
 ### OpenGL Context
 
-OpenGL是一个仅仅关注图像渲染的图像接口库，在渲染过程中它需要将顶点信息、纹理信息、编译好的着色器等渲染状态信息存储起来，而存储这些信息调用任何OpenGL函数前，必须先创建OpenGL Context，它存储了OpenGL的状态变量以及其他渲染有关的信息。OpenGL是个状态机，有很多状态变量，是个标准的过程式操作过程，改变状态会影响后续所有的操作，这和面向对象的解耦原则不符，毕竟渲染本身就是个复杂的过程。OpenGL采用Client-Server模型来解释OpenGL程序，即Server存储OpenGL Context，Client提出渲染请求，Server给予响应。之后的渲染工作就要依赖这些渲染状态信息来完成，当一个上下文被销毁时，它所对应的OpenGL渲染工作也将结束。
-
+OpenGL是一个仅仅关注图像渲染的图像接口库，在渲染过程中它需要将顶点信息、纹理信息、编译好的着色器等渲染状态信息存储起来，而存储这些信息调用任何OpenGL函数前，必须先创建OpenGL Context，它存储了OpenGL的状态变量以及其他渲染有关的信息。     
+OpenGL是个状态机，有很多状态变量，是个标准的过程式操作过程，改变状态会影响后续所有的操作，这和面向对象的解耦原则不符，毕竟渲染本身就是个复杂的过程。
+OpenGL采用Client-Server模型来解释OpenGL程序，即Server存储OpenGL Context，Client提出渲染请求，Server给予响应。之后的渲染工作就要依赖这些渲染状态信息来完成，当一个上下文被销毁时，它所对应的OpenGL渲染工作也将结束。
 
 
+OpenGL ES API没有提及如何创建渲染上下文，或者渲染上下文如何连接到原生窗口系统。EGL是Khronos渲染API(如OpenGL ES)和原生窗口系统之间的接口。
 ### EGL
 
-EGL提供了OpenGL ES和运行于计算机上的原生窗口系统(如Windows、Mac OSX)之间的一个“结合”层次。在EGL能够确定可用的绘制表面类型(或者底层系统的其他特性)之前，它必须打开和窗口系统的通信渠道。注意。Apple提供自己的EGL API的iOS实现，成为EAGL。
-因为每个窗口系统都有不同的语音，所以EGL提供基本的不透明类型--EGLDisplay，该类型封装了所有系统相关性，用于和原生窗口系统接口。任何使用EGL的应用程序必须执行的第一个操作就是创建和初始化与本地EGL现实的连接。
+在OpenGL的设计中，OpenGL是不负责管理窗口的，窗口的管理交由各个设备自己完成。具体的来说就是iOS平台上使用EAGL提供本地平台对OpenGL的实现，在Android平台上使用EGL提供本地平台对OpenGL的实现。OpenGL其实是通过GPU进行渲染。但是我们的程序是运行在CPU上，要与GPU关联，这就需要通过EGL，它相当于Android上层应用于GPU通讯的中间层。
 
-OpenGL ES API没有提及如何创建渲染上下文，或者渲染上下文如何连接到原生窗口系统。EGL是Khronos渲染API(如OpenGL ES)和原生窗口系统之间的接口。
+EGL提供了OpenGL ES和运行于计算机上的原生窗口系统(如Windows、Mac OSX)之间的一个“结合”层次。    
+在EGL能够确定可用的绘制表面类型(或者底层系统的其他特性)之前，它必须打开和窗口系统的通信渠道。注意。Apple提供自己的EGL API的iOS实现，成为EAGL。     
+因为每个窗口系统都有不同的语言，所以EGL提供基本的不透明类型--EGLDisplay，该类型封装了所有系统相关性，用于和原生窗口系统接口。任何使用EGL的应用程序必须执行的第一个操作就是创建和初始化与本地EGL显示的连接。
 
-在OpenGL的设计中，OpenGL是不负责管理窗口的，窗口的管理交由各个设备自己完成。具体的来说就是iOS平台上使用EAGL提供本地平台对OpenGL的实现，在Android平台上使用EGL提供本地平台对OpenGL的实现。OpenGL其实是通过GPU进行渲染。但是我们的程序是运行在CPU上，要与GPU关联，这就需要通过EGL，它相当于Android上层应用于GPU通讯的中间层。
 
 EGL为双缓冲工作模式(Double Buffer)，既有一个Back Frame Buffer和一个Front Frame Buffer，正常绘制的目标都是Back Frame Buffer，绘制完成后再调用eglSwapBuffer API，将绘制完毕的FrameBuffer交换到Front Frame Buffer并显示出来。   
 
 补充说明： 
-应用程序使用单缓冲绘图时可能会存在图像闪烁的问题。这是因为生成的图像不是一下子被绘制出来的，而是按照从左到右，由上到下逐像素的绘制而成的。最终图像不是在瞬间显示给用户，而是通过一步一步生成的，这会导致渲染的结果很不真实。为了规避这些问题，就应用了双缓冲渲染模式，前缓冲保存着最终输出的图像，它会在屏幕上显示；而所有的渲染指令都会在后缓冲上绘制。当所有的渲染指令执行完毕后，我们交互前缓冲和后缓冲，这样图像就立即呈现出来，之前提到的不真实感就消除了。
+应用程序使用单缓冲绘图时可能会存在图像闪烁的问题。这是因为生成的图像不是一下子被绘制出来的，而是按照从左到右，由上到下逐像素的绘制而成的。最终图像不是在瞬间显示给用户，而是通过一步一步生成的，这会导致渲染的结果很不真实。为了规避这些问题，就应用了双缓冲渲染模式，前缓冲保存着最终输出的图像，它会在屏幕上显示；    
+而所有的渲染指令都会在后缓冲上绘制。当所有的渲染指令执行完毕后，我们交换前缓冲和后缓冲，这样图像就立即呈现出来，刚才提到的不真实感就消除了。
 
 
 要在Android平台实现OpenGL渲染，需要完成一系列的EGL操作，主要为下面几步(后面分析GLSurfaceView源码的时候也是这样来实现的):   
@@ -284,9 +293,9 @@ EGL为双缓冲工作模式(Double Buffer)，既有一个Back Frame Buffer和一
 通过上述操作，就完成了EGL的初始化设置，便可以进行OpenGL的渲染操作。所有EGL命令都是以egl前缀开始，对组成命令名的每个单词使用首字母大写(如eglCreateWindowSurface)。
 
 #### 创建屏幕外渲染区域: EGL Pbuffer
-除了可以用OpenGL ES在屏幕上的窗口渲染之外，还可以渲染称作pbuffer(像素缓冲区Pixel buffer的缩写)的不可见屏幕外表面。
-和窗口一样，Pbuffer可以利用OpenGL ES3.0中的任何硬件加速。
-Pbuffer最常用于生成纹理贴图。如果你想要做的事渲染到一个纹理，那么我们建议使用帧缓冲区对象代替Pbuffer，因为帧缓冲区更高效。不过，在某些帧缓冲区对象无法使用的情况下，Pbuffer仍然有用，例如用OpenGL ES在屏幕外表面上渲染，然后将其作为其他API(如OpenVG)中的纹理。
+除了可以用OpenGL ES在屏幕上的窗口渲染之外，还可以渲染称作pbuffer(像素缓冲区Pixel buffer的缩写)的不可见屏幕外表面。         
+和窗口一样，Pbuffer可以利用OpenGL ES3.0中的任何硬件加速。      
+Pbuffer最常用于生成纹理贴图。如果你想要做的是渲染到一个纹理，那么我们建议使用帧缓冲区对象代替Pbuffer，因为帧缓冲区更高效。不过，在某些帧缓冲区对象无法使用的情况下，Pbuffer仍然有用，例如用OpenGL ES在屏幕外表面上渲染，然后将其作为其他API(如OpenVG)中的纹理。     
 创建Pbuffer和创建EGL窗口非常相似，只有少数微小的不同。为了创建Pbuffer，需要和窗口一样找到EGLConfig，并作一处修改：我们需要扩增EGL_SURFACE_TYPE的值，使其包含EGL_PBUFFER_BIT。
 
 
diff --git "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md" "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"
index 63a69e62..f8c2d583 100644
--- "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
@@ -4,7 +4,10 @@ OpenGL ES的绘制需要有以下步骤:
 
 - 顶点输入
 
-  开始绘制图形之前，我们必须先给OpenGL输入一些顶点数据。OpenGL是一个3D图形库，所以我们在OpenGL中所指定的所有坐标都是3D坐标(xyz)。OpenGL并不是简单地把所有的3D坐标变换成屏幕上的2D像素。OpenGL仅当3D坐标在3个轴(xyz)上都为-1.0到1.0的范围内才去处理它。所有在这个范围内的坐标叫做标准化设备坐标(Normalized Device Coordinates)，此范围内的坐标最终显示在屏幕上（在这个范围以外的坐标则不会显示）。
+  开始绘制图形之前，我们必须先给OpenGL输入一些顶点数据。    
+  OpenGL是一个3D图形库，所以我们在OpenGL中所指定的所有坐标都是3D坐标(xyz)。OpenGL并不是简单地把所有的3D坐标变换成屏幕上的2D像素。    
+  OpenGL仅当3D坐标在3个轴(xyz)上都为-1.0到1.0的范围内才去处理它。    
+  所有在这个范围内的坐标叫做标准化设备坐标(Normalized Device Coordinates)，此范围内的坐标最终显示在屏幕上（在这个范围以外的坐标则不会显示）。
 
 由于我们希望渲染一个三角形，我们一共要指定三个顶点，每个顶点都有一个3D位置。我们会将它们以标准化设备坐标的形式（OpenGL的可见区域）定义为一个float数组。
 ```glsl
@@ -14,9 +17,12 @@ float vertices[] = {
      0.0f,  0.5f, 0.0f
 };
 ```
-定义这样的顶点数据以后，我们会把它作为输入发送给图形渲染管线的第一个处理阶段：顶点着色器。它会在GPU上创建内存用于储存我们的顶点数据，还要配置OpenGL如何解释这些内存，并且指定其如何发送给显卡。顶点着色器接着会处理我们在内存中指定数量的顶点。
+定义这样的顶点数据以后，我们会把它作为输入发送给图形渲染管线的第一个处理阶段：顶点着色器。    
+它会在GPU上创建内存用于储存我们的顶点数据，还要配置OpenGL如何解释这些内存，并且指定其如何发送给显卡。顶点着色器接着会处理我们在内存中指定数量的顶点。
 
-我们通过顶点缓冲对象(Vertex Buffer Objects, VBO)管理这个内存，它会在GPU内存（通常被称为显存）中储存大量顶点。使用这些缓冲对象的好处是我们可以一次性的发送一大批数据到显卡上，而不是每个顶点发送一次。从CPU把数据发送到显卡相对较慢，所以只要可能我们都要尝试尽量一次性发送尽可能多的数据。当数据发送至显卡的内存中后，顶点着色器几乎能立即访问顶点，这是个非常快的过程。
+我们通过顶点缓冲对象(Vertex Buffer Objects, VBO)管理这个内存，它会在GPU内存（通常被称为显存）中储存大量顶点。    
+使用这些缓冲对象的好处是我们可以一次性的发送一大批数据到显卡上，而不是每个顶点发送一次。   
+从CPU把数据发送到显卡相对较慢，所以只要可能我们都要尝试尽量一次性发送尽可能多的数据。当数据发送至显卡的内存中后，顶点着色器几乎能立即访问顶点，这是个非常快的过程。
 
 顶点缓冲对象是我们在OpenGL教程中第一个出现的OpenGL对象。就像OpenGL中的其它对象一样，这个缓冲有一个独一无二的ID，所以我们可以使用glGenBuffers函数和一个缓冲ID生成一个VBO对象。
 
@@ -37,15 +43,19 @@ float vertices[] = {
 
   每个着色器都起始于一个版本声明，这里声明的是GLSL ES 300版本，在Android中它对应的OpenGL ES版本为3.0，而GLSL ES 100版本则对应的是OpenGL ES 2.0版本。如果不写版本默认的就是100。
 
-  下一步，使用in关键字，在顶点着色器中声明所有的输入顶点属性(Input Vertex Attribute)。现在我们只关心位置(Position)数据，所以我们只需要一个顶点属性。GLSL有一个向量数据类型，它包含1到4个float分量，包含的数量可以从它的后缀数字看出来。由于每个顶点都有一个3D坐标，我们就创建一个vec3输入变量position。我们同样也通过layout (location = 0)设定了输入变量的位置值(Location)你后面会看到为什么我们会需要这个位置值。
+  下一步，使用in关键字，在顶点着色器中声明所有的输入顶点属性(Input Vertex Attribute)。现在我们只关心位置(Position)数据，所以我们只需要一个顶点属性。GLSL有一个向量数据类型，它包含1到4个float分量，包含的数量可以从它的后缀数字看出来。    
+  由于每个顶点都有一个3D坐标，我们就创建一个vec3输入变量position。我们同样也通过layout (location = 0)设定了输入变量的位置值(Location)你后面会看到为什么我们会需要这个位置值。
 
 向量(Vector)
 
-在图形编程中我们经常会使用向量这个数学概念，因为它简明地表达了任意空间中的位置和方向，并且它有非常有用的数学属性。在GLSL中一个向量有最多4个分量，每个分量值都代表空间中的一个坐标，它们可以通过vec.x、vec.y、vec.z和vec.w来获取。注意vec.w分量不是用作表达空间中的位置的（我们处理的是3D不是4D），而是用在所谓透视除法(Perspective Division)上。我们会在后面的教程中更详细地讨论向量。
+在图形编程中我们经常会使用向量这个数学概念，因为它简明地表达了任意空间中的位置和方向，并且它有非常有用的数学属性。    
+在GLSL中一个向量有最多4个分量，每个分量值都代表空间中的一个坐标，它们可以通过vec.x、vec.y、vec.z和vec.w来获取。    
+注意vec.w分量不是用作表达空间中的位置的（我们处理的是3D不是4D），而是用在所谓透视除法(Perspective Division)上。我们会在后面的教程中更详细地讨论向量。
 
-  为了设置顶点着色器的输出，我们必须把位置数据赋值给预定义的gl_Position变量，它在幕后是vec4类型的。在main函数中只是将position的值转换后赋值给gl_Position。由于我们的输入是一个3分量的向量，我们必须把它转换为4分量的。我们可以把vec3的数据作为vec4构造器的参数，同时把w分量设置为1.0f（我们会在后面解释为什么）来完成这一任务。
+为了设置顶点着色器的输出，我们必须把位置数据赋值给预定义的gl_Position变量，它在幕后是vec4类型的。在main函数中只是将position的值转换后赋值给gl_Position。    
+由于我们的输入是一个3分量的向量，我们必须把它转换为4分量的。我们可以把vec3的数据作为vec4构造器的参数，同时把w分量设置为1.0f（我们会在后面解释为什么）来完成这一任务。
 
-  这个position的值是哪里进行赋值的呢？ 是通过后面java代码中的draw函数来进行赋值的。每个顶点着色器都必须在gl_Position变量中输出一个位置。这个变量定义传递给管线下一个阶段的位置。
+这个position的值是哪里进行赋值的呢？ 是通过后面java代码中的draw函数来进行赋值的。每个顶点着色器都必须在gl_Position变量中输出一个位置。这个变量定义传递给管线下一个阶段的位置。
 
 - 编译着色器
 
@@ -62,39 +72,44 @@ float vertices[] = {
       color = vec4(1.0f, 0.5f, 0.2f, 1.0f);
   }
   ```
-在计算机图形中颜色被表示为有4个元素的数组：红色、绿色、蓝色和alpha(透明度)分量，通常缩写为RGBA。当在OpenGL或GLSL中定义一个颜色的时候，我们把颜色每个分量的强度设置在0.0到1.0之间。比如说我们设置红为1.0f，绿为1.0f，我们会得到两个颜色的混合色，即黄色。这三种颜色分量的不同调配可以生成超过1600万种不同的颜色！
+在计算机图形中颜色被表示为有4个元素的数组：红色、绿色、蓝色和alpha(透明度)分量，通常缩写为RGBA。    
+当在OpenGL或GLSL中定义一个颜色的时候，我们把颜色每个分量的强度设置在0.0到1.0之间。比如说我们设置红为1.0f，绿为1.0f，我们会得到两个颜色的混合色，即黄色。    
+这三种颜色分量的不同调配可以生成超过1600万种不同的颜色！
  
-  片段着色器只需要一个输出变量，这个变量是一个4分量向量，它表示的是最终的输出颜色，我们应该自己将其计算出来。我们可以用out关键字声明输出变量，这里我们命名为color。下面，我们将一个alpha值为1.0(1.0代表完全不透明)的橘黄色的vec4赋值给颜色输出。之后也是需要编译着色器。片段着色器声明的这个输出变量color的值会被输出到颜色缓冲区。，然后颜色缓冲区再通过EGL窗口显示。
-
-片段着色器只需要一个输出变量，这个变量是一个4分量向量，它表示的是最终的输出颜色，我们应该自己将其计算出来。声明输出变量可以使用out关键字，这里我们命名为color。
+片段着色器只需要一个输出变量，这个变量是一个4分量向量，它表示的是最终的输出颜色，我们应该自己将其计算出来。    
+我们可以用out关键字声明输出变量，这里我们命名为color。下面，我们将一个alpha值为1.0(1.0代表完全不透明)的橘黄色的vec4赋值给颜色输出。    
+之后也是需要编译着色器。片段着色器声明的这个输出变量color的值会被输出到颜色缓冲区，然后颜色缓冲区再通过EGL窗口显示。
 
 - 着色器程序(Shader Program Object)
 
-  着色器程序对象(Shader Program Object)是多个着色器合并之后并最终链接完成的版本。如果要使用刚才编译的着色器我们必须把它们链接(Link)为一个着色器程序对象，然后在渲染对象的时候激活这个着色器程序。已激活着色器程序的着色器将在我们发送渲染调用的时候被使用。
+着色器程序对象(Shader Program Object)是多个着色器合并之后并最终链接完成的版本。    
+如果要使用刚才编译的着色器我们必须把它们链接(Link)为一个着色器程序对象，然后在渲染对象的时候激活这个着色器程序。    
+已激活着色器程序的着色器将在我们发送渲染调用的时候被使用。    
 
-  当链接着色器至一个程序的时候，它会把每个着色器的输出链接到下个着色器的输入。当输出和输入不匹配的时候，你会得到一个连接错误。我们需要把之前编译的着色器附加到程序队形上，然后使用glLinkProgram链接他们:
+当链接着色器至一个程序的时候，它会把每个着色器的输出链接到下个着色器的输入。当输出和输入不匹配的时候，你会得到一个连接错误。我们需要把之前编译的着色器附加到程序队形上，然后使用glLinkProgram链接他们:
 
-  ```java
-  shaderProgram = glCreateProgram(); 
-  glAttachShader(shaderProgram, vertexShader);
-  glAttachShader(shaderProgram, fragmentShader);
-  glLinkProgram(shaderProgram);
-  ```
+```java
+final int shaderProgramId = GLES30.glCreateProgram(); 
+GLES30.glAttachShader(shaderProgramId, vertexShaderId);
+GLES30.glAttachShader(shaderProgramId, fragmentShaderId);
+GLES30.glLinkProgram(shaderProgramId);
+```
 
-  链接完后需要使用glUseProgram方法，用刚创建的程序对象作为参数，以激活这个程序对象。调用glUserProgram方法后，所有后续的渲染将用连接到这个程序对象的顶点和片段着色器进行。
+链接完后需要使用glUseProgram方法，用刚创建的程序对象的Id作为参数，以激活这个程序对象。调用glUserProgram方法后，所有后续的渲染将用连接到这个程序对象的顶点和片段着色器进行。
 
 对了，在把着色器对象链接到程序对象以后，记得删除着色器对象，我们不再需要它们了：
+```java
+GLES30.glDeleteShader(vertexShaderId);
+GLES30.glDeleteShader(fragmentShaderId);
 ```
-glDeleteShader(vertexShader);
-glDeleteShader(fragmentShader);
-```
-
-现在，我们已经把输入顶点数据发送给了GPU，并指示了GPU如何在顶点和片段着色器中处理它。就快要完成了，但还没结束，OpenGL还不知道它该如何解释内存中的顶点数据，以及它该如何将顶点数据链接到顶点着色器的属性上。下面我们需要告诉OpenGL怎么做。
 
+现在，我们已经把输入顶点数据发送给了GPU，并指示了GPU如何在顶点和片段着色器中处理它。    
+就快要完成了，但还没结束，OpenGL还不知道它该如何解释内存中的顶点数据，以及它该如何将顶点数据链接到顶点着色器的属性上。下面我们需要告诉OpenGL怎么做。
 
 - 链接顶点属性
 
-  顶点着色器允许我们指定任何以顶点属性为形式的输入。这使其具有很强的灵活性的同时，它还意味着我们必须手动指定输入数据的哪一个部分对应顶点着色器的哪一个顶点属性。所以，我们必须在渲染前指定OpenGL该如何解释顶点数据。
+  顶点着色器允许我们指定任何以顶点属性为形式的输入。这使其具有很强的灵活性的同时，它还意味着我们必须手动指定输入数据的哪一个部分对应顶点着色器的哪一个顶点属性。    
+  所以，我们必须在渲染前指定OpenGL该如何解释顶点数据。
 
   我们的顶点缓冲数据会被解析成下面的样子:  
 
@@ -104,11 +119,16 @@ glDeleteShader(fragmentShader);
 - 在这3个值之间没有空隙（或其他值）。这几个值在数组中紧密排列(Tightly Packed)。
 - 数据中第一个值在缓冲开始的位置。
 
-  有了这些信息我们就可以使用glVertexAttribPointer函数告诉OpenGL该如何解析顶点数据（应用到逐个顶点属性上）了：
+有了这些信息我们就可以使用glVertexAttribPointer函数告诉OpenGL该如何解析顶点数据（应用到逐个顶点属性上）了：
 
   ```
-  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (GLvoid*)0);
-  glEnableVertexAttribArray(0);
+// glVertexAttribPointer是把顶点位置属性赋值给着色器程序
+// 第一个参数0是上面着色器中写的vPosition的变量位置(location = 0)。意思就是绑定vertex坐标数据，然后将在vertextBuffer中的顶点数据传给vPosition变量。
+// 你肯定会想，如果我在着色器中不写呢？int vposition = glGetAttribLocation(program, "vPosition");就可以获得他的属性位置了
+// 第二个size是3，是因为上面我们triangleCoords声明的属性就是3位，xyz
+GLES30.glVertexAttribPointer(0, 3, GLES30.GL_FLOAT, false, 3 * 4, vertexBuffer);
+//启用顶点变量，这个0也是vPosition在着色器变量中的位置，和上面一样，在着色器文件中的location=0声明的
+GLES30.glEnableVertexAttribArray(0);
   ```
 
   glVertexAttribPointer函数的参数非常多，所以我会逐一介绍它们：
@@ -117,33 +137,43 @@ glDeleteShader(fragmentShader);
   - 第二个参数指定顶点属性的大小。顶点属性是一个`vec3`，它由3个值组成，所以大小是3。
   - 第三个参数指定数据的类型，这里是GL_FLOAT(GLSL中`vec*`都是由浮点数值组成的)。
   - 下个参数定义我们是否希望数据被标准化(Normalize)。如果我们设置为GL_TRUE，所有数据都会被映射到0（对于有符号型signed数据是-1）到1之间。我们把它设置为GL_FALSE。
-  - 第五个参数叫做步长(Stride)，它告诉我们在连续的顶点属性组之间的间隔。由于下个组位置数据在3个`GLfloat`之后，我们把步长设置为`3 * sizeof(GLfloat)`。要注意的是由于我们知道这个数组是紧密排列的（在两个顶点属性之间没有空隙）我们也可以设置为0来让OpenGL决定具体步长是多少（只有当数值是紧密排列时才可用）。一旦我们有更多的顶点属性，我们就必须更小心地定义每个顶点属性之间的间隔，我们在后面会看到更多的例子(译注: 这个参数的意思简单说就是从这个属性第二次出现的地方到整个数组0位置之间有多少字节)。
-  - 最后一个参数的类型是`GLvoid*`，所以需要我们进行这个奇怪的强制类型转换。它表示位置数据在缓冲中起始位置的偏移量(Offset)。由于位置数据在数组的开头，所以这里是0。我们会在后面详细解释这个参数。
+  - 第五个参数叫做步长(Stride)，它告诉我们在连续的顶点属性组之间的间隔。由于下个组位置数据在3个`GLfloat`之后，我们把步长设置为`3 * sizeof(GLfloat)`也就是3*4。
+      要注意的是由于我们知道这个数组是紧密排列的（在两个顶点属性之间没有空隙）我们也可以设置为0来让OpenGL决定具体步长是多少（只有当数值是紧密排列时才可用）。
+      一旦我们有更多的顶点属性，我们就必须更小心地定义每个顶点属性之间的间隔，我们在后面会看到更多的例子(译注: 这个参数的意思简单说就是从这个属性第二次出现的地方到整个数组0位置之间有多少字节)。
+  - 最后一个参数的类型是数据。
 
-每个顶点属性从一个VBO管理的内存中获得它的数据，而具体是从哪个VBO（程序中可以有多个VBO）获取则是通过在调用glVertexAttribPointer时绑定到GL_ARRAY_BUFFER的VBO决定的。由于在调用glVertexAttribPointer之前绑定的是先前定义的VBO对象，顶点属性0现在会链接到它的顶点数据。
+每个顶点属性从一个VBO管理的内存中获得它的数据，而具体是从哪个VBO（程序中可以有多个VBO）获取则是通过在调用glVertexAttribPointer时绑定到GL_ARRAY_BUFFER的VBO决定的。    
+由于在调用glVertexAttribPointer之前绑定的是先前定义的VBO对象，顶点属性现在会链接到它的顶点数据。
 
-现在我们已经定义了OpenGL该如何解释顶点数据，我们现在应该使用glEnableVertexAttribArray，以顶点属性位置值作为参数，启用顶点属性；顶点属性默认是禁用的。自此，所有东西都已经设置好了：我们使用一个顶点缓冲对象将顶点数据初始化至缓冲中，建立了一个顶点和一个片段着色器，并告诉了OpenGL如何把顶点数据链接到顶点着色器的顶点属性上。在OpenGL中绘制一个物体，代码会像是这样：
+现在我们已经定义了OpenGL该如何解释顶点数据，接着应该使用glEnableVertexAttribArray，以顶点属性位置值作为参数，启用顶点属性；顶点属性默认是禁用的。    
+自此，所有东西都已经设置好了：我们使用一个顶点缓冲对象将顶点数据初始化至缓冲中，建立了一个顶点和一个片段着色器，并告诉了OpenGL如何把顶点数据链接到顶点着色器的顶点属性上。    
+在OpenGL中绘制一个物体，代码会像是这样：
 ```java
 // 0. 复制顶点数组到缓冲中供OpenGL使用,使用glGenBuffers函数和一个缓冲ID生成一个VBO对象
-glGenBuffers(1, VBO);
+IntBuffer vbo = IntBuffer.allocate(1);
+GLES30.glGenBuffers(1, vbo);
 // 使用glBindBuffer函数把新创建的缓冲绑定到GL_ARRAY_BUFFER目标上
-glBindBuffer(GL_ARRAY_BUFFER, VBO);
+GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, vbo.get(0));
 // glBufferData是一个专门用来把用户定义的数据复制到当前绑定缓冲的函数
 // 它的第一个参数是目标缓冲类型。 第二个参数是指定传输数据的大小(以字节为单位),用一个简单的sizeof计算出顶点数据的大小就行
 // 第三个参数是我们希望发送的实际数据
 // 第四个参数指定了我们希望显卡如何管理这些数据，有三种形式: GL_STATIC_DRAW(数据不会或几乎不会改变)， GL_DYNAMIC_DRAW(数据会被改变很多)， GL_STREAM_DRAW(数据每次绘制时都会改变)
-glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
+GLES30.glBufferData(GLES30.GL_ARRAY_BUFFER, POSITION_VERTEX.size * Float.BYTES,
+                    vertexBuffer, GLES30.GL_STATIC_DRAW);
 // 1. 设置顶点属性指针
-glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
-glEnableVertexAttribArray(0);
+GLES30.glVertexAttribPointer(0, 3, GLES30.GL_FLOAT, false, 3 * Float.BYTES, vertexBuffer);
+GLES30.glEnableVertexAttribArray(0);
 // 2. 当我们渲染一个物体时要使用着色器程序
-glUseProgram(shaderProgram);
+GLES30.glUseProgram(shaderProgram);
 // 3. 绘制物体
 someOpenGLFunctionThatDrawsOurTriangle();
 ```
-每当我们绘制一个物体的时候都必须重复这一过程。这看起来可能不多，但是如果有超过5个顶点属性，上百个不同物体呢（这其实并不罕见）。绑定正确的缓冲对象，为每个物体配置所有顶点属性很快就变成一件麻烦事。有没有一些方法可以使我们把所有这些状态配置储存在一个对象中，并且可以通过绑定这个对象来恢复状态呢？
+每当我们绘制一个物体的时候都必须重复这一过程。这看起来可能不多，但是如果有超过5个顶点属性，上百个不同物体呢（这其实并不罕见）。     
+绑定正确的缓冲对象，为每个物体配置所有顶点属性很快就变成一件麻烦事。有没有一些方法可以使我们把所有这些状态配置储存在一个对象中，并且可以通过绑定这个对象来恢复状态呢？
 
-顶点数组对象(Vertex Array Object, VAO)可以像顶点缓冲对象那样被绑定，任何随后的顶点属性调用都会储存在这个VAO中。这样的好处就是，当配置顶点属性指针时，你只需要将那些调用执行一次，之后再绘制物体的时候只需要绑定相应的VAO就行了。这使在不同顶点数据和属性配置之间切换变得非常简单，只需要绑定不同的VAO就行了。刚刚设置的所有状态都将存储在VAO中。
+顶点数组对象(Vertex Array Object, VAO)可以像顶点缓冲对象那样被绑定，任何随后的顶点属性调用都会储存在这个VAO中。    
+这样的好处就是，当配置顶点属性指针时，你只需要将那些调用执行一次，之后再绘制物体的时候只需要绑定相应的VAO就行了。    
+这使在不同顶点数据和属性配置之间切换变得非常简单，只需要绑定不同的VAO就行了。刚刚设置的所有状态都将存储在VAO中。
 
 一个顶点数组对象会储存以下这些内容：
 
@@ -154,32 +184,35 @@ someOpenGLFunctionThatDrawsOurTriangle();
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/vertex_array_objects.png)
 
 创建一个VAO和创建一个VBO很类似：
-```c++
-unsigned int VAO;
-glGenVertexArrays(1, &VAO);
+```java
+IntBuffer arrays = IntBuffer.allocate(1);
+GLES30.glGenVertexArrays(1, arrays);
 ```
-要想使用VAO，要做的只是使用glBindVertexArray绑定VAO。从绑定之后起，我们应该绑定和配置对应的VBO和属性指针，之后解绑VAO供之后使用。当我们打算绘制一个物体的时候，我们只要在绘制物体前简单地把VAO绑定到希望使用的设定上就行了。这段代码应该看起来像这样：
-```c++
+要想使用VAO，要做的只是使用glBindVertexArray绑定VAO。从绑定之后起，我们应该绑定和配置对应的VBO和属性指针，之后解绑VAO供之后使用。    
+当我们打算绘制一个物体的时候，我们只要在绘制物体前简单地把VAO绑定到希望使用的设定上就行了。这段代码应该看起来像这样：
+```java
 // ..:: 初始化代码（只运行一次 (除非你的物体频繁改变)） :: ..
 // 1. 绑定VAO
-glBindVertexArray(VAO);
-// 2. 把顶点数组复制到缓冲中供OpenGL使用
-glBindBuffer(GL_ARRAY_BUFFER, VBO);
-glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
+GLES30.glBindVertexArray(arrays.get(0));
+// 2. 把顶点数组复制到缓冲中供OpenGL使用。 注意： 这里绑定了VAO后再绑定VBO，这样他们才能关联起来
+GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, vbo.get(0));
+GLES30.glBufferData(GLES30.GL_ARRAY_BUFFER, Float.BYTES, vertices, GLES30.GL_STATIC_DRAW);
 // 3. 设置顶点属性指针
-glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
-glEnableVertexAttribArray(0);
+GLES30.glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * Float.BYTES, vertexBuffer);
+GLES30.glEnableVertexAttribArray(0);
 
 [...]
 
 // ..:: 绘制代码（渲染循环中） :: ..
 // 4. 绘制物体
-glUseProgram(shaderProgram);
-glBindVertexArray(VAO);
+GLES30.glUseProgram(shaderProgram);
+// 解绑数据：GLES30.glBindVertexArray(0)
+GLES30.glBindVertexArray(0);
 someOpenGLFunctionThatDrawsOurTriangle();
 ```
 
-就这么多了！前面做的一切都是等待这一刻，一个储存了我们顶点属性配置和应使用的VBO的顶点数组对象。一般当你打算绘制多个物体时，你首先要生成/配置所有的VAO（和必须的VBO及属性指针)，然后储存它们供后面使用。当我们打算绘制物体的时候就拿出相应的VAO，绑定它，绘制完物体后，再解绑VAO。
+就这么多了！前面做的一切都是等待这一刻，一个储存了我们顶点属性配置和应使用的VBO的顶点数组对象。一般当你打算绘制多个物体时，你首先要生成/配置所有的VAO（和必须的VBO及属性指针)，然后储存它们供后面使用。    
+注意： 先绑定VAO后再绑定VBO，这样他们才能关联起来当我们打算绘制物体的时候就拿出相应的VAO，绑定它，绘制完物体后，再解绑VAO。
 
 
 
@@ -228,7 +261,7 @@ void main() {
 } 
 ```
 
-  大体意思：使用OpenGL ES3.0版本，将图形顶点数据采用4分向量的数据结构绑定到着色器的第0个属性上，属性的名字是vPosition，然后再有一个颜色的4分向量绑定到做色器的第1个属性上，属性的名字是aColor，另外还会输出一个vColor，着色器执行的时候，会将vPosition的值传递给用来表示顶点最终位置的内建变量gl_Position，将顶点最终大小的gl_PointSize设置为10，并将aColor的值复制给要输出额vColor。
+  大体意思：使用OpenGL ES3.0版本，将图形顶点数据采用4分向量的数据结构绑定到着色器的第0个属性上，属性的名字是vPosition，然后再有一个颜色的4分向量绑定到做色器的第1个属性上，属性的名字是aColor，另外还会输出一个vColor，着色器执行的时候，会将vPosition的值传递给用来表示顶点最终位置的内建变量gl_Position，将顶点最终大小的gl_PointSize设置为10，并将aColor的值复制给要输出给vColor。
 
 - 片段着色器(triangle_fragment_shader.glsl)
 
@@ -246,7 +279,8 @@ void main() {
       fragColor = vColor;
   }
   ```
-precision是精度限定符，它可以使着色器创作者指定着色器变量的计算精度。变量可以声明为低、中或高精度。这些限定符用于提示编译器允许在较低的范围和精度上执行变量的计算。在较低的精度上，有些OpenGL ES实现在运行着色器时可能更快，或者电源效率更高。当然这种效率提升是以精度为代价的，在没有正确使用精度限定符时可能造成伪像。
+precision是精度限定符，它可以使着色器创作者指定着色器变量的计算精度。变量可以声明为低、中或高精度。这些限定符用于提示编译器允许在较低的范围和精度上执行变量的计算。    
+在较低的精度上，有些OpenGL ES实现在运行着色器时可能更快，或者电源效率更高。当然这种效率提升是以精度为代价的，在没有正确使用精度限定符时可能造成伪像。
 
 精度限定符可以用于指定任何浮点数或整数的变量的精度。指定精度的关键字是lowp、mediump和highp。下面是一些带有精度限定符的声明示例: 
 ```
@@ -298,8 +332,6 @@ TriangleRender的实现如下:
 
 ```java
 public class TriangleRender implements GLSurfaceView.Renderer {
-    //一个Float占用4Byte
-    private static final int BYTES_PER_FLOAT = 4;
     //三个顶点
     private static final int POSITION_COMPONENT_COUNT = 3;
     //顶点位置缓存
@@ -329,7 +361,7 @@ public class TriangleRender implements GLSurfaceView.Renderer {
         /****************2.为顶点位置及颜色申请本地内存 start************/
         //将顶点数据拷贝映射到native内存中，以便OpenGL能够访问
         //分配本地内存空间,每个浮点型占4字节空间；将坐标数据转换为FloatBuffer，用以传入给OpenGL ES程序
-        vertexBuffer = ByteBuffer.allocateDirect(triangleCoords.length * BYTES_PER_FLOAT) // 直接分配native内存
+        vertexBuffer = ByteBuffer.allocateDirect(triangleCoords.length * Float.BYTES) // 直接分配native内存
                 .order(ByteOrder.nativeOrder()) // 和本地平台保持一致的字节序
                 .asFloatBuffer(); // 将底层字节映射到FloatBuffer实例，方便使用
         vertexBuffer.put(triangleCoords); // 将顶点数据拷贝到native内存中
@@ -337,7 +369,7 @@ public class TriangleRender implements GLSurfaceView.Renderer {
         vertexBuffer.position(0);
 
         //顶点颜色相关
-        colorBuffer = ByteBuffer.allocateDirect(color.length * BYTES_PER_FLOAT)
+        colorBuffer = ByteBuffer.allocateDirect(color.length * Float.BYTES)
                 .order(ByteOrder.nativeOrder())
                 .asFloatBuffer();
         colorBuffer.put(color);
@@ -379,7 +411,7 @@ public class TriangleRender implements GLSurfaceView.Renderer {
         //0是上面着色器中写的vPosition的变量位置(location = 0)。意思就是绑定vertex坐标数据，然后将在vertextBuffer中的顶点数据传给vPosition变量。
         // 你肯定会想，如果我在着色器中不写呢？int vposition = glGetAttribLocation(program, "vPosition");就可以获得他的属性位置了
         // 第二个size是3，是因为上面我们triangleCoords声明的属性就是3位，xyz
-        GLES30.glVertexAttribPointer(0, 3, GLES30.GL_FLOAT, false, 0, vertexBuffer);
+        GLES30.glVertexAttribPointer(0, 3, GLES30.GL_FLOAT, false, 3 * Float.BYTES, vertexBuffer);
         //启用顶点变量，这个0也是vPosition在着色器变量中的位置，和上面一样，在着色器文件中的location=0声明的
         GLES30.glEnableVertexAttribArray(0);
 
@@ -394,7 +426,7 @@ public class TriangleRender implements GLSurfaceView.Renderer {
          * ptr： 本地数据缓存（这里我们的是顶点的位置和颜色数据）。
          */
         // 1是aColor在属性的位置，4是因为我们声明的颜色是4位，r、g、b、a。
-        GLES30.glVertexAttribPointer(1, 4, GLES30.GL_FLOAT, false, 0, colorBuffer);
+        GLES30.glVertexAttribPointer(1, 4, GLES30.GL_FLOAT, false, 4 * Float.BYTES, colorBuffer);
         //启用顶点颜色句柄
         GLES30.glEnableVertexAttribArray(1);
 
@@ -479,6 +511,9 @@ public class TriangleRender implements GLSurfaceView.Renderer {
             GLES30.glAttachShader(programId, fragmentShaderId);
             //链接着色器程序
             GLES30.glLinkProgram(programId);
+            // 删除
+            GLES30.glDeleteShader(vertexShaderId);
+            GLES30.glDeleteShader(fragmentShaderId);
             final int[] linkStatus = new int[1];
 
             GLES30.glGetProgramiv(programId, GLES30.GL_LINK_STATUS, linkStatus, 0);
@@ -535,12 +570,12 @@ public class TriangleRender implements GLSurfaceView.Renderer {
 ```
 
 
-调用glCreateShader将根据传入的type参数创建一个新的顶点或片段着色器。返回值是指向新着色器对象的句柄。当完成着色器对象时，可以用glDeleteShader删除。
+调用glCreateShader将根据传入的type参数创建一个新的顶点或片段着色器。返回值是指向新着色器对象的句柄。当完成链接着色器对象时，可以用glDeleteShader删除。            
 注意，如果一个着色器连接到一个程序对象，那么调用glDeleteShader不会立即删除着色器，而是将着色器编标记为删除，在着色器不再连接到任何程序对象时，它的内存将被释放。
 
 效果如下:   
 
-<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_tri.jpg" style="zoom:20%" />
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_tri.jpg" width="20%" height="20%" />
 
 
 
@@ -704,7 +739,8 @@ Matrix.multiplyMM (float[] result, //接收相乘结果
 
 
 
-也就是说为了解决坐标中宽高不一样的问题，我们可以应用OpenGL正确的比例下通过投影模式和相机视图坐标转换图形对象来完成。为了应用投影和相机视图，我们创建一个投影矩阵和一个相机视图矩阵，并把他们应用于OpenGL渲染管道中，投影矩阵重新计算你的图形的坐标，使他们正确的映射到Android设备的屏幕，相机视图矩阵创建一个转换，它将从一个特定的位置显示对象。
+也就是说为了解决坐标中宽高不一样的问题，我们可以应用OpenGL正确的比例下通过投影模式和相机视图坐标转换图形对象来完成。    
+为了应用投影和相机视图，我们创建一个投影矩阵和一个相机视图矩阵，并把他们应用于OpenGL渲染管道中，投影矩阵重新计算你的图形的坐标，使他们正确的映射到Android设备的屏幕，相机视图矩阵创建一个转换，它将从一个特定的位置显示对象。
 
 ### 绘制等腰三角形
 
@@ -777,6 +813,9 @@ public class ShaderUtils {
             GLES30.glAttachShader(programId, fragmentShaderId);
             //链接着色器程序
             GLES30.glLinkProgram(programId);
+            //删除
+            GLES30.glDeleteShader(vertexShaderId);
+            GLES30.glDeleteShader(fragmentShaderId);
             final int[] linkStatus = new int[1];
 
             GLES30.glGetProgramiv(programId, GLES30.GL_LINK_STATUS, linkStatus, 0);
@@ -840,26 +879,28 @@ public class ResReadUtils {
 
 - 修改顶点着色器，增加矩阵变换(修改iso_triangle_vertex_shader.glsl)，片段着色器不用修改
 
-  ```glsl
-  // 声明着色器的版本，OpenGL ES 3.0版本对应的着色器语言版本是 GLSL 300 ES
-  #version 300 es
-  // 顶点着色器的顶点位置，输入一个名为vPosition的4分量向量，layout (location = 0)表示这个变量的位置是顶点属性中的第0个属性。
-  layout (location = 0) in vec4 vPosition;
-  // 顶点着色器的顶点颜色数据，输入一个名为aColor的4分量向量，layout (location = 1)表示这个变量的位置是顶点属性中的第1个属性。
-  layout (location = 1) in vec4 aColor;
-  // 输出一个名为vColor的4分量向量，后面输入到片段着色器中。
-  out vec4 vColor;
-  // 变换矩阵4*4
-  uniform mat4 u_Matrix;
-  void main() {
-      // gl_Position为Shader内置变量，为顶点位置，将其赋值为vPosition
-      gl_Position  = u_Matrix * vPosition;
-      // gl_PointSize为Shader内置变量，为点的直径
-      gl_PointSize = 10.0;
-      // 将输入数据aColor拷贝到vColor的变量中。
-      vColor = aColor;
-  }
-  ```
+```glsl
+#version 300 es
+// 声明着色器的版本，OpenGL ES 3.0版本对应的着色器语言版本是 GLSL 300 ES
+// 顶点着色器的顶点位置，输入一个名为vPosition的3分量向量，layout (location = 0)表示这个变量的位置是顶点属性中的第0个属性。
+layout (location = 0) in vec3 vPosition;
+// 顶点着色器的顶点颜色数据，输入一个名为aColor的4分量向量，layout (location = 1)表示这个变量的位置是顶点属性中的第1个属性。
+layout (location = 1) in vec4 aColor;
+// 输出一个名为vColor的4分量向量，后面输入到片段着色器中。
+out vec4 vColor;
+// 变换矩阵4*4
+uniform mat4 u_Matrix;
+void main() {
+    // 先把vec3转成vec4
+    vec4 pos = vec4(vPosition.x, vPosition.y, vPosition.z, 1.0);
+    // gl_Position为Shader内置变量，为顶点位置，将其赋值为vPosition
+    gl_Position  = u_Matrix * pos;
+    // gl_PointSize为Shader内置变量，为点的直径
+    gl_PointSize = 10.0;
+    // 将输入数据aColor拷贝到vColor的变量中。
+    vColor = aColor;
+}
+```
 
 - 在GLSurfaceView.Render实现类中定义矩阵变量
 
@@ -1001,7 +1042,7 @@ public class IsoTriangleRender implements GLTextureView.Renderer {
     public boolean onDrawFrame(GL10 gl) {
         //把颜色缓冲区设置为我们预设的颜色
         GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT);
-        //绑定vertex坐标数据，告诉OpenGL可以在缓冲区vertexBuffer中获取vPosition的护具
+        //绑定vertex坐标数据，告诉OpenGL可以在缓冲区vertexBuffer中获取vPosition的数据
         GLES30.glVertexAttribPointer(0, 3, GLES30.GL_FLOAT, false, 0, vertexBuffer);
         //启用顶点位置句柄
         GLES30.glEnableVertexAttribArray(0);

From c922915da76b83007dc985db663447ad3ebceece Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Tue, 9 May 2023 21:50:13 +0800
Subject: [PATCH 109/213] update opengl

---
 ...237\251\345\275\242\345\217\212\345\234\206\345\275\242.md" | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md" "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"
index 380db0a9..d739b69b 100644
--- "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"	
@@ -1,6 +1,7 @@
 ## 6.OpenGL ES绘制矩形及圆形
 
-写完上面的绘制三角形的部分，手快抽筋了，为啥？ 一个就是每个方法都要调用GLES30.还有一个就是我们完全可以把公共的代码再封装到一个Base类里面啊，所以我这里就抽了一个BaseGLSurfaceViewRenderer类，然后把GLES30中一些常用的方法写了一遍。为什么要这样做呢？ 我们也可以通过import static来省去GLES30的写法，但我不喜欢那样。另外还弄了BufferUtil、ProjectionMatrixUtil的类:  
+写完上面的绘制三角形的部分，手快抽筋了，为啥？      一个就是每个方法都要调用GLES30.还有一个就是我们完全可以把公共的代码再封装到一个Base类里面啊，所以我这里就抽了一个BaseGLSurfaceViewRenderer类，然后把GLES30中一些常用的方法写了一遍。
+为什么要这样做呢？ 我们也可以通过import static来省去GLES30的写法，但我不喜欢那样。另外还弄了BufferUtil、ProjectionMatrixUtil的类:  
 
 ```java
 public class BufferUtil {

From e1cf1ac93b7bc22388bfc2b7756bfa343d8fa7e9 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 10 May 2023 21:42:24 +0800
Subject: [PATCH 110/213] update opengl

---
 ...42\345\217\212\345\234\206\345\275\242.md" |  37 ++---
 ...45\231\250\350\257\255\350\250\200GLSL.md" | 135 +++++++-----------
 2 files changed, 71 insertions(+), 101 deletions(-)

diff --git "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md" "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"
index d739b69b..a44d86be 100644
--- "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"	
@@ -1,6 +1,7 @@
 ## 6.OpenGL ES绘制矩形及圆形
 
-写完上面的绘制三角形的部分，手快抽筋了，为啥？      一个就是每个方法都要调用GLES30.还有一个就是我们完全可以把公共的代码再封装到一个Base类里面啊，所以我这里就抽了一个BaseGLSurfaceViewRenderer类，然后把GLES30中一些常用的方法写了一遍。
+写完上面的绘制三角形的部分，手快抽筋了，为啥？    
+一个就是每个方法都要调用GLES30.还有一个就是我们完全可以把公共的代码再封装到一个Base类里面啊，所以我这里就抽了一个BaseGLSurfaceViewRenderer类，然后把GLES30中一些常用的方法写了一遍。     
 为什么要这样做呢？ 我们也可以通过import static来省去GLES30的写法，但我不喜欢那样。另外还弄了BufferUtil、ProjectionMatrixUtil的类:  
 
 ```java
@@ -151,14 +152,14 @@ public abstract class BaseGLSurfaceViewRenderer implements GLSurfaceView.Rendere
 
 - 索引法
 
-  根据索引序列，在顶点序列中找到对应的顶点，并根据绘制的方式，组成相应的图元绘制，用的是GLES30.glDrawElements()，称为索引法。相对于顶点法在复杂图形的绘制中无法避免大量顶点重复的情况，索引法可以减少很多重复顶点占用的空间，所以复杂的图形下推荐使用索引法。顶点复用情况多，客读性高。
+  根据索引序列，在顶点序列中找到对应的顶点，并根据绘制的方式，组成相应的图元绘制，用的是GLES30.glDrawElements()，称为索引法。相对于顶点法在复杂图形的绘制中无法避免大量顶点重复的情况，索引法可以减少很多重复顶点占用的空间，所以复杂的图形下推荐使用索引法。顶点复用情况多，可读性高。
 
 之前说过OpenGL ES提供的的图元单位是三角形，想要绘制其他多边形，就要利用三角形来拼成。 矩形是两个三角形，而圆形则是由很多个三角形组成，个数越多，圆越圆。
 
 
 ### 元素缓冲对象(EBO)
 在渲染顶点这一话题上我们还有最后一个需要讨论的东西——元素缓冲对象(Element Buffer Object，EBO)，也叫索引缓冲对象(Index Buffer Object，IBO)。要解释元素缓冲对象的工作方式最好还是举个例子：假设我们不再绘制一个三角形而是绘制一个矩形。我们可以绘制两个三角形来组成一个矩形（OpenGL主要处理三角形）。这会生成下面的顶点的集合：
-```
+```java
 float vertices[] = {
     // 第一个三角形
     0.5f, 0.5f, 0.0f,   // 右上角
@@ -172,8 +173,9 @@ float vertices[] = {
 ```
 可以看到，有几个顶点叠加了。我们指定了右下角和左上角两次！一个矩形只有4个而不是6个顶点，这样就产生50%的额外开销。当我们有包括上千个三角形的模型之后这个问题会更糟糕，这会产生一大堆浪费。更好的解决方案是只储存不同的顶点，并设定绘制这些顶点的顺序。这样子我们只要储存4个顶点就能绘制矩形了，之后只要指定绘制的顺序就行了。如果OpenGL提供这个功能就好了，对吧？
 
-值得庆幸的是，元素缓冲区对象的工作方式正是如此。 EBO是一个缓冲区，就像一个顶点缓冲区对象一样，它存储 OpenGL 用来决定要绘制哪些顶点的索引。这种所谓的索引绘制(Indexed Drawing)正是我们问题的解决方案。首先，我们先要定义（不重复的）顶点，和绘制出矩形所需的索引：
-```
+值得庆幸的是，元素缓冲区对象的工作方式正是如此。 EBO是一个缓冲区，就像一个顶点缓冲区对象一样，它存储 OpenGL 用来决定要绘制哪些顶点的索引。    
+这种所谓的索引绘制(Indexed Drawing)正是我们问题的解决方案。首先，我们先要定义（不重复的）顶点，和绘制出矩形所需的索引：
+```java
 float vertices[] = {
     0.5f, 0.5f, 0.0f,   // 右上角
     0.5f, -0.5f, 0.0f,  // 右下角
@@ -181,7 +183,7 @@ float vertices[] = {
     -0.5f, 0.5f, 0.0f   // 左上角
 };
 
-unsigned int indices[] = {
+int indices[] = {
     // 注意索引从0开始! 
     // 此例的索引(0,1,2,3)就是顶点数组vertices的下标，
     // 这样可以由下标代表顶点组合成矩形
@@ -191,19 +193,22 @@ unsigned int indices[] = {
 };
 ```
 你可以看到，当使用索引的时候，我们只定义了4个顶点，而不是6个。下一步我们需要创建元素缓冲对象：
-```
-unsigned int EBO;
-glGenBuffers(1, &EBO);
+```java
+//创建 ebo
+GLES30.glGenBuffers(1,ebo,0)
+//绑定 ebo 到上下文
+GLES30.glBindBuffer(GLES30.GL_ELEMENT_ARRAY_BUFFER,ebo[0])
+//昂丁
+GLES30.glBufferData(GLES30.GL_ELEMENT_ARRAY_BUFFER,
+    indexData.capacity() * 4,
+    indexData,
+    GLES30.GL_STATIC_DRAW
+)
 ```
 与VBO类似，我们先绑定EBO然后用glBufferData把索引复制到缓冲里。同样，和VBO类似，我们会把这些函数调用放在绑定和解绑函数调用之间，只不过这次我们把缓冲的类型定义为GL_ELEMENT_ARRAY_BUFFER。
-```
-glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
-glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
-```
 注意：我们传递了GL_ELEMENT_ARRAY_BUFFER当作缓冲目标。最后一件要做的事是用glDrawElements来替换glDrawArrays函数，表示我们要从索引缓冲区渲染三角形。使用glDrawElements时，我们会使用当前绑定的索引缓冲对象中的索引进行绘制：
-```
-glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
-glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
+```java
+GLES30.glDrawElements(GLES30.GL_TRIANGLE_STRIP,6,GLES30.GL_UNSIGNED_INT,0)
 ```
 第一个参数指定了我们绘制的模式，这个和glDrawArrays的一样。第二个参数是我们打算绘制顶点的个数，这里填6，也就是说我们一共需要绘制6个顶点。第三个参数是索引的类型，这里是GL_UNSIGNED_INT。最后一个参数里我们可以指定EBO中的偏移量（或者传递一个索引数组，但是这是当你不在使用索引缓冲对象的时候），但是我们会在这里填写0。
 
diff --git "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md" "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
index 28295e70..b2f3e96d 100644
--- "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
+++ "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
@@ -8,15 +8,6 @@
 
 
 
-在计算机图形中，两个基本数据类型组成了变换的基础：
-- 向量
-- 矩阵
-这两种数据类型在OpenGL ES着色语言中也是核心，下图具体描述了着色语言中存在的机遇标量、向量和矩阵的数据类型。
-
-<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/glsl_basic_data_type.png" style="zoom:80%" />
-
-
-
 ### 顶点着色器:
 
 ```
@@ -43,7 +34,28 @@ void main() {
 - 采样器:代表顶点着色器使用纹理的特殊统一变量类型。
 - 着色器程序:描述顶点上执行操作的顶点着色器的程序源代码或可执行文件。
 
-顶点着色器的输出在OpenGL ES 2.0中称作可变(varying)变量，但在OpenGL ES 3.0中改名为顶点着色器输出(out)变量。在图元光栅化阶段，为每个生成的片段计算顶点着色器输出值，并作为输入传递给片段着色器。
+这里需要重点讲一下上面的版本:   OpenGL ES版本有自己的着色器语言，其中OpenGL ES的版本与GLSL的版本有对应的关联关系，如果没有在着色器文件中用#version标明使用版本的时候默认使用的是OpenGL ES 2.0版本（GLSL ES 100）:
+
+- OpenGL ES 2.0版本对应GLSL ES 100版本
+- OpenGL ES 3.0版本对应GLSL ES 300版本
+
+我们这里使用的都是GLSL ES 300版本。但是GLSL ES 100 和 300版本中间有一些差异，这就是为什么我们有时候网上的一些代码编译时却报错的原因:
+
+- GLSL ES 300版本中in和out代替了之前的属性和变化(attribute和varying)，
+
+    OpenGL ES 3.0中将2.0的attribute改成了in，顶点着色器的varying改成out，片段着色器的varying改成了in，也就是说顶点着色器的输出就是片段着色器的输入，另外uniform跟2.0用法一样。
+
+- OpenGL ES 3.0的shader中没有texture2D()和texture3D等了，全部使用texture()方法替换。
+
+- 300版本中布局限定符可以声明顶点着色器输入和片段着色器输出的问题，例如layout(location = 2) in vec3 values[4];
+
+- 舍弃了gl_FragColor和gl_FragData内置属性，变成我们需要自己使用out关键字定义的属性，例如out vec4 fragColor，这就是为什么你从网还是哪个找到的代码换成GLSL ES 300版本后报错的原因。
+
+- GL_OES_EGL_image_external被废弃
+
+    当使用samplerExternalOES是，如果在\#extension GL_OES_EGL_image_external : require会报错，需要变成#extension GL_OES_EGL_image_external_essl3 : require
+
+- #version 300 es这种声明版本的语句，必须放到第一行，并且shader中不能有Tab键，只能用空格替换。
 
 虽然着色器是各自独立的小程序，但是它们都是一个整体的一部分，出于这样的原因，我们希望每个着色器都有输入和输出，这样才能进行数据交流和传递。GLSL定义了in和out关键字专门来实现这个目的。每个着色器使用这两个关键字设定输入和输出，只要一个输出变量与下一个着色器阶段的输入匹配，它就会传递下去。但在顶点和片段着色器中会有点不同。
 
@@ -157,62 +169,6 @@ glUniform4f(vertexColorLocation, 0.0f, greenValue, 0.0f, 1.0f);
 现在你知道如何设置uniform变量的值了，我们可以使用它们来渲染了。如果我们打算让颜色慢慢变化，我们就要在游戏循环的每一次迭代中（所以他会逐帧改变）更新这个uniform，否则三角形就不会改变颜色。
 
 
-内建变量包括:
-
-- gl_Position:用于输出顶点位置的裁剪坐标。
-- gl_PointSize:用于写入以像素标示的点尺寸。
-
-### 片段着色器:
-
-```
-#version 300 es
-in vec4 vertexColor; // 从顶点着色器传来的输入变量（名称相同、类型相同）
-
-out vec4 color; // 片段着色器输出的变量名可以任意命名，类型必须是vec4
-
-void main()
-{
-    color = vertexColor;
-}
-```
-
-<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_fragment_shader.jpg" style="zoom:80%;" />
-
-片段着色器为片段操作提供了通用功能的可编程方法。片段着色器的输入由以下部分组成:
-
-- 输入变量:光栅化单元用插值为每个片段生成的顶点着色器输出。
-- 统一变量:片段(或者顶点)着色器使用的不变的数据。
-- 采样器:代表顶点着色器使用纹理的特殊统一变量类型。
-- 着色器程序:描述顶点上执行操作的顶点着色器的程序源代码或可执行文件。
-
-片段着色器的输出是一个或者多个片段颜色，传递到管线的逐片段操作部分。
-
-内建变量: gl_FragCoord:片段着色器中的一个只读变量。这个变量保存片段的窗口相对坐标。
-
-这里需要重点讲一下上面的版本:   OpenGL ES版本有自己的着色器语言，其中OpenGL ES的版本与GLSL的版本有对应的关联关系，如果没有在着色器文件中用#version标明使用版本的时候默认使用的是OpenGL ES 2.0版本（GLSL ES 100）:
-
-- OpenGL ES 2.0版本对应GLSL ES 100版本
-- OpenGL ES 3.0版本对应GLSL ES 300版本
-
-我们这里使用的都是GLSL ES 300版本。但是GLSL ES 100 和 300版本中间有一些差异，这就是为什么我们有时候网上的一些代码编译时却报错的原因:
-
-- GLSL ES 300版本中in和out代替了之前的属性和变化(attribute和varying)，
-
-    OpenGL ES 3.0中将2.0的attribute改成了in，顶点着色器的varying改成out，片段着色器的varying改成了in，也就是说顶点着色器的输出就是片段着色器的输入，另外uniform跟2.0用法一样。
-
-- OpenGL ES 3.0的shader中没有texture2D()和texture3D等了，全部使用texture()方法替换。
-
-- 300版本中布局限定符可以声明顶点着色器输入和片段着色器输出的问题，例如layout(location = 2) in vec3 values[4];
-
-- 舍弃了gl_FragColor和gl_FragData内置属性，变成我们需要自己使用out关键字定义的属性，例如out vec4 fragColor，这就是为什么你从网还是哪个找到的代码换成GLSL ES 300版本后报错的原因。
-
-- GL_OES_EGL_image_external被废弃
-
-    当使用samplerExternalOES是，如果在\#extension GL_OES_EGL_image_external : require会报错，需要变成#extension GL_OES_EGL_image_external_essl3 : require
-
-- #version 300 es这种声明版本的语句，必须放到第一行，并且shader中不能有Tab键，只能用空格替换。
-
-
 
 ### GLSL的特点
 
@@ -232,20 +188,25 @@ GLSL中的数据类型主要分为标量、向量、矩阵、采样器、结构
 
 - 标量 
 
-  标量表示的是只有大小没有方向的量，在GLSL中`标量只有bool、int和float三种`。对于int，和C一样，可以写为十进制（16）、八进制（020）或者十六进制（0x10）。对于标量的运算，我们最需要注意的是`精度`，防止溢出问题。
+标量表示的是只有大小没有方向的量，在GLSL中`标量只有bool、int和float三种`。对于int，和C一样，可以写为十进制（16）、八进制（020）或者十六进制（0x10）。对于标量的运算，我们最需要注意的是`精度`，防止溢出问题。
 
 - 向量
 
-  向量我们可以看做是数组，在GLSL通常用于储存颜色、坐标等数据，针对维数，可分为二维、三维和四维向量。针对存储的标量类型，可以分为bool、int和float。共有vec2、vec3、vec4，ivec2、ivec3、ivec4、bvec2、bvec3和bvec4九种类型，数组代表维数、i表示int类型、b表示bool类型。***需要注意的是，GLSL中的向量表示竖向量，所以与矩阵相乘进行变换时，矩阵在前，向量在后（与DirectX正好相反）***。向量在GPU中由硬件支持运算，比CPU快的多。
-  作为颜色向量时，用rgba表示分量，就如同取数组的中具体数据的索引值。三维颜色向量就用rgb表示分量。比如对于颜色向量vec4 color，color[0]和color.r都表示color向量的第一个值，也就是红色的分量。其他相同。
-  作为位置向量时，用xyzw表示分量，xyz分别表示xyz坐标，w表示向量的模。三维坐标向量为xyz表示分量，二维向量为xy表示分量。
-  作为纹理向量时，用stpq表示分量，三维用stp表示分量，二维用st表示分量。
+向量我们可以看做是数组，在GLSL通常用于储存颜色、坐标等数据，针对维数，可分为二维、三维和四维向量。    
+针对存储的标量类型，可以分为bool、int和float。共有vec2、vec3、vec4，ivec2、ivec3、ivec4、bvec2、bvec3和bvec4九种类型，数组代表维数、i表示int类型、b表示bool类型。***需要注意的是，GLSL中的向量表示竖向量，所以与矩阵相乘进行变换时，矩阵在前，向量在后（与DirectX正好相反）***。向量在GPU中由硬件支持运算，比CPU快的多。    
 
-  我们大部分时候使用vecn，因为float足够满足大多数要求了。
-  ```glsl
+作为颜色向量时，用rgba表示分量，就如同取数组的中具体数据的索引值。三维颜色向量就用rgb表示分量。比如对于颜色向量vec4 color，color[0]和color.r都表示color向量的第一个值，也就是红色的分量。其他相同。     
+
+作为位置向量时，用xyzw表示分量，xyz分别表示xyz坐标，w表示向量的模。三维坐标向量为xyz表示分量，二维向量为xy表示分量。    
+
+作为纹理向量时，用stpq表示分量，三维用stp表示分量，二维用st表示分量。
+
+我们大部分时候使用vecn，因为float足够满足大多数要求了。
+
+```glsl
 vec2 vect = vec2(0.5, 0.7);
 vec4 result = vec4(vect, 0.0, 0.0);
-  ```
+```
 
 - 矩阵
 
@@ -388,15 +349,16 @@ GLSL的类型转换与C不同。在GLSL中类型不可以自动提升，比如fl
 ### 更多
 
 在前面的教程中，我们了解了如何填充VBO、配置顶点属性指针以及如何把它们都储存到一个VAO里。这次，我们同样打算把颜色数据加进顶点数据中。我们将把颜色数据添加为3个float值至vertices数组。我们将把三角形的三个角分别指定为红色、绿色和蓝色：
-
+```java
 float vertices[] = {
     // 位置              // 颜色
      0.5f, -0.5f, 0.0f,  1.0f, 0.0f, 0.0f,   // 右下
     -0.5f, -0.5f, 0.0f,  0.0f, 1.0f, 0.0f,   // 左下
      0.0f,  0.5f, 0.0f,  0.0f, 0.0f, 1.0f    // 顶部
 };
+```
 由于现在有更多的数据要发送到顶点着色器，我们有必要去调整一下顶点着色器，使它能够接收颜色值作为一个顶点属性输入。需要注意的是我们用layout标识符来把aColor属性的位置值设置为1：
-
+```glsl
 #version 330 core
 layout (location = 0) in vec3 aPos;   // 位置变量的属性位置值为 0 
 layout (location = 1) in vec3 aColor; // 颜色变量的属性位置值为 1
@@ -408,8 +370,9 @@ void main()
     gl_Position = vec4(aPos, 1.0);
     ourColor = aColor; // 将ourColor设置为我们从顶点数据那里得到的输入颜色
 }
+```
 由于我们不再使用uniform来传递片段的颜色了，现在使用ourColor输出变量，我们必须再修改一下片段着色器：
-
+```glsl
 #version 330 core
 out vec4 FragColor;  
 in vec3 ourColor;
@@ -418,23 +381,25 @@ void main()
 {
     FragColor = vec4(ourColor, 1.0);
 }
+```
 因为我们添加了另一个顶点属性，并且更新了VBO的内存，我们就必须重新配置顶点属性指针。更新后的VBO内存中的数据现在看起来像这样：
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/vertex_attribute_pointer_interleaved.png?raw=true)
 
 知道了现在使用的布局，我们就可以使用glVertexAttribPointer函数更新顶点格式，
-```
+```java
 // 位置属性
-glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0);
-glEnableVertexAttribArray(0);
+GLES30.glVertexAttribPointer(0, 3, GLES30.GL_FLOAT, false, 6 * Float.BYTES, 0);
+GLES30.glEnableVertexAttribArray(0);
 // 颜色属性
-glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3* sizeof(float)));
+GLES30.glVertexAttribPointer(1, 3, GLES30.GL_FLOAT, false, 6 * Float.BYTES, 3* Float.BYTES);
 // 1是对应上面着色器代码中的位置： layout (location = 1) in vec3 aColor; 颜色变量的属性位置值为 1
-glEnableVertexAttribArray(1);
-glVertexAttribPointer函数的前几个参数比较明了。这次我们配置属性位置值为1的顶点属性。颜色值有3个float那么大，我们不去标准化这些值。
+GLES30.glEnableVertexAttribArray(1);
 ```
-由于我们现在有了两个顶点属性，我们不得不重新计算步长值。为获得数据队列中下一个属性值（比如位置向量的下个x分量）我们必须向右移动6个float，其中3个是位置值，另外3个是颜色值。这使我们的步长值为6乘以float的字节数（=24字节）。
-同样，这次我们必须指定一个偏移量。对于每个顶点来说，位置顶点属性在前，所以它的偏移量是0。颜色属性紧随位置数据之后，所以偏移量就是3 * sizeof(float)，用字节来计算就是12字节。
+glVertexAttribPointer函数的前几个参数比较明了。这次我们配置属性位置值为1的顶点属性。颜色值有3个float那么大，我们不去标准化这些值。     
+由于我们现在有了两个顶点属性，我们不得不重新计算步长值。为获得数据队列中下一个属性值（比如位置向量的下个x分量）我们必须向右移动6个float，其中3个是位置值，另外3个是颜色值。    
+这使我们的步长值为6乘以float的字节数（=24字节）。    
+同样，这次我们必须指定一个偏移量。对于每个顶点来说，位置顶点属性在前，所以它的偏移量是0。颜色属性紧随位置数据之后，所以偏移量就是Float.BYTES，用字节来计算就是12字节。
 
 
 

From e37c170cbe5c539f096d2c8a05ab89ee22531800 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 10 May 2023 22:04:02 +0800
Subject: [PATCH 111/213] update opengl part

---
 ...55\346\224\276\350\247\206\351\242\221.md" |   4 +-
 ...\261\273\345\217\212Matrix\347\261\273.md" |  58 ++--
 .../9.OpenGL ES\347\272\271\347\220\206.md"   | 307 +++++++++---------
 3 files changed, 187 insertions(+), 182 deletions(-)

diff --git "a/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md" "b/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
index 995b49c2..c1c347da 100644
--- "a/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
+++ "b/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
@@ -317,11 +317,11 @@ public class VideoPlayerRender extends BaseGLSurfaceViewRenderer {
 
 下面是具体的效果分别是填充宽和填充高的效果:   
 
-<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_video_player1.jpeg" style="zoom:40%" />
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_video_player1.jpeg" width="40%" height="40%" />
 
 
 
-<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_video_player_2.jpeg" style="zoom:33%" />
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_video_player_2.jpeg" width="40%" height="40%" />
 
 
 
diff --git "a/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md" "b/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
index 67fb2790..2de853ff 100644
--- "a/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
+++ "b/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
@@ -96,14 +96,16 @@ GLES作为我们与着色器连接的工具类提供了丰富的api。了解一
 
 ### 获取着色器程序内成员变量的id(句柄、指针)
 
-- mPostionHandler = GLES30.glGetAttribLocation(mProgram, "aPosition"):获取着色器程序中，指定为attribute类型的变量id。
-- mMatrixHnadler = GLES30.glGetUniformLocation(mProgram, "uMVPMatrix"):获取着色器程序中，指定为uniform类型的变量id。
+```java
+mPostionHandler = GLES30.glGetAttribLocation(mProgram, "aPosition"):获取着色器程序中，指定为attribute类型的变量id。
+mMatrixHnadler = GLES30.glGetUniformLocation(mProgram, "uMVPMatrix"):获取着色器程序中，指定为uniform类型的变量id。
+```
 
 ### 向着色器传递数据
 
 上面获取到指向着色器中相应数据成员的各个id后，就能将我们要设置的顶点数据、颜色数据等传递到着色器中了。
 
-```
+```java
 // 将最终变换矩阵传入shader程序
 GLES30.glUniformMatrix4fv(muMVPMatrixHandle, 1, false, MatrixState.getFinalMatrix(), 0);
 // 顶点位置数据传入着色器
@@ -117,18 +119,18 @@ GLES30.glVertexAttribPointer(maTextureHandle, 2, GLES20.GL_FLOAT, false, 20, mRe
 ### 定义顶点属性数组
 
 
-
-        /**
-         * glVertexAttribPointer()方法的参数分别为: 
-         * index：顶点属性的索引.（这里我们的顶点位置和颜色向量在着色器中分别为0和1）layout (location = 0) in vec4 vPosition; layout (location = 1) in vec4 aColor;
-         * size: 指定每个通用顶点属性的元素个数。必须是1、2、3、4。此外，glvertexattribpointer接受符号常量gl_bgra。初始值为4（也就是涉及颜色的时候必为4）。
-         * type：属性的元素类型。（上面都是Float所以使用GLES30.GL_FLOAT）；
-         * normalized：转换的时候是否要经过规范化，true：是；false：直接转化；
-         * stride：跨距，默认是0。（由于我们将顶点位置和颜色数据分别存放没写在一个数组中，所以使用默认值0）
-         * ptr： 本地数据缓存（这里我们的是顶点的位置和颜色数据）。
-         */
-        GLES30.glVertexAttribPointer(1, 4, GLES30.GL_FLOAT, false, 0, colorBuffer);
-
+```java
+/**
+ * glVertexAttribPointer()方法的参数分别为: 
+ * index：顶点属性的索引.（这里我们的顶点位置和颜色向量在着色器中分别为0和1）layout (location = 0) in vec4 vPosition; layout (location = 1) in vec4 aColor;
+ * size: 指定每个通用顶点属性的元素个数。必须是1、2、3、4。此外，glvertexattribpointer接受符号常量gl_bgra。初始值为4（也就是涉及颜色的时候必为4）。
+ * type：属性的元素类型。（上面都是Float所以使用GLES30.GL_FLOAT）；
+ * normalized：转换的时候是否要经过规范化，true：是；false：直接转化；
+ * stride：跨距，默认是0。（由于我们将顶点位置和颜色数据分别存放没写在一个数组中，所以使用默认值0）
+ * ptr： 本地数据缓存（这里我们的是顶点的位置和颜色数据）。
+ */
+GLES30.glVertexAttribPointer(1, 4, GLES30.GL_FLOAT, false, 0, colorBuffer);
+```
 
 ### 启用或禁用顶点属性数组
 
@@ -138,13 +140,15 @@ GLES30.glVertexAttribPointer(maTextureHandle, 2, GLES20.GL_FLOAT, false, 20, mRe
 
 Matrix就是专门设计出来帮助我们简化矩阵和向量运算操作的，里面所有的实现原理都是线性代数中的运算。
 
-我们知道OpenGl中实现图形的操作大量使用了矩阵，在OpenGL中使用的向量为列向量，我们通过利用矩阵与列向量（颜色、坐标都可看做列向量）相乘，得到一个新的列向量。利用这点，我们构建一个的矩阵，与图形所有的顶点坐标坐标相乘，得到新的顶点坐标集合，当这个矩阵构造恰当的话，新得到的顶点坐标集合形成的图形相对原图形就会出现平移、旋转、缩放或拉伸、抑或扭曲的效果。Matrix是专门为处理4*4矩阵和4元素向量设计的，其中的方法都是static的，不需要初始化Matrix实例。
+我们知道OpenGl中实现图形的操作大量使用了矩阵，在OpenGL中使用的向量为列向量，我们通过利用矩阵与列向量（颜色、坐标都可看做列向量）相乘，得到一个新的列向量。    
+利用这点，我们构建一个的矩阵，与图形所有的顶点坐标坐标相乘，得到新的顶点坐标集合，当这个矩阵构造恰当的话，新得到的顶点坐标集合形成的图形相对原图形就会出现平移、旋转、缩放或拉伸、抑或扭曲的效果。    
+Matrix是专门为处理4*4矩阵和4元素向量设计的，其中的方法都是static的，不需要初始化Matrix实例。
 
 - multiplyMM
 
   两个4x4矩阵相乘，并将结果存储到第三个4x4矩阵中。
 
-  ```
+  ```java
   public static native void multiplyMM(float[] result, int resultOffset,
               float[] lhs, int lhsOffset, float[] rhs, int rhsOffset);
   ```
@@ -153,7 +157,7 @@ Matrix就是专门设计出来帮助我们简化矩阵和向量运算操作的
 
   将一个4x4矩阵和一个四元素向量相乘，得到一个新的四元素向量
 
-  ```
+  ```java
   public static native void multiplyMV(float[] resultVec,int resultVecOffset,
   			 float[] lhsMat, int lhsMatOffset,
               float[] rhsVec, int rhsVecOffset);
@@ -164,21 +168,29 @@ Matrix就是专门设计出来帮助我们简化矩阵和向量运算操作的
   获取逆矩阵
 
 
+### 相机
 
 顶点着色器可赋予程序员一次操作一个顶点（“按顶点”处理）的能力，片段着色器（稍后会看到）可赋予程序员一次操作一个像素（“按片段”处理）的能力，几何着色器可赋予程序员一次操作一个图元（“按图元”处理）的能力。
 
 到目前为止，我们所接触的变换矩阵全都可以在3D空间中操作。但是，我们最终需要将3D空间或它的一部分展示在2D显示器上。为了达成这个目标，我们需要找到一个有利点。正如我们在现实世界通过眼睛从一点观察一样，我们也必须找到一点并确立观察方向作为我们观察虚拟世界的窗口。这个点叫作视图或视觉空间，或“合成相机”（简称相机）。
 
-观察3D世界需要：(a)将相机放入世界的某个位置；(b)调整相机的角度，通常需要一套它自己的直角坐标轴u、v、n（由向量U，V，N构成）；(c)定义一个视体(view volume)；(d)将视体内的对象投影到投影平面(projection plane)上。
+观察3D世界需要：
+- 将相机放入世界的某个位置；
+- 调整相机的角度，通常需要一套它自己的直角坐标轴u、v、n（由向量U，V，N构成）；
+- 定义一个视体(view volume)；(d)将视体内的对象投影到投影平面(projection plane)上。
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_eye.jpg?raw=true)
 
-OpenGL有一个固定在原点(0,0,0)并朝向z轴负方向的相机，如下图所示。
+OpenGL有一个固定在原点(0,0,0)并朝向z轴负方向的相机，如下图所示： 
+
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_eye_00.jpg?raw=true)
-为了应用OpenGL相机，我们需要将它移动到适合的位置和方向。我们需要先找出在世界中的物体与我们期望的相机位置的相对位置（如物体应该在由图3.12所示相机U、V、N向量定义的“相机空间”中的位置）。给定世界空间中的点PW，我们需要通过变换将它转换成相应相机空间中的点，从而让它看起来好像是从我们期望的相机位置CW看到的样子。我们通过计算它在相机空间中的位置PC实现。已知OpenGL相机位置永远固定在点(0,0,0)，那么我们如何变换来实现上述功能？
-![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_eye_01.jpg?raw=true)
 
-当我们设置好相机之后，就可以学习投影矩阵了。我们需要学习的两个重要的投影矩阵：透视投影矩阵和正射投影矩阵。透视投影通过使用透视概念模仿我们看真实世界的方式，尝试让2D图像看起来像是3D的。物体近大远小，3D空间中有的平行线用透视法画出来就不再平行。我们可以通过使用变换矩阵将平行线变为恰当的不平行线来实现这个效果，这个矩阵叫作透视矩阵或者透视变换。
+为了应用OpenGL相机，我们需要将它移动到适合的位置和方向。我们需要先找出在世界中的物体与我们期望的相机位置的相对位置。     
+给定世界空间中的点PW，我们需要通过变换将它转换成相应相机空间中的点，从而让它看起来好像是从我们期望的相机位置CW看到的样子。    
+
+
+当我们设置好相机之后，就可以学习投影矩阵了。我们需要学习的两个重要的投影矩阵：透视投影矩阵和正射投影矩阵。    
+透视投影通过使用透视概念模仿我们看真实世界的方式，尝试让2D图像看起来像是3D的。物体近大远小，3D空间中有的平行线用透视法画出来就不再平行。我们可以通过使用变换矩阵将平行线变为恰当的不平行线来实现这个效果，这个矩阵叫作透视矩阵或者透视变换。
 
 在正射投影中，平行线仍然是平行的，即不使用透视，如下图所示。正射与透视相反，在视体中的物体不因其与相机的距离而改变，可以直接投影。正射投影是一种平行投影，其中所有的投影过程都沿与投影平面垂直的方向进行。
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_zheng.jpg?raw=true)
diff --git "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md" "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"
index 6be99fb8..f23fbef6 100644
--- "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
+++ "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
@@ -197,7 +197,7 @@ public class TextureUtil {
 
   将之前颜色向量`vec4 aColor`变为了纹理向量`vec2 aTextureCoord`；
 
-  ```
+  ```glsl
   #version 300 es
   layout (location = 0) in vec4 vPosition;
   layout (location = 1) in vec2 aTextureCoord;
@@ -220,40 +220,40 @@ public class TextureUtil {
 我们使用GLSL内建的texture函数来采样纹理的颜色，它第一个参数是纹理采样器，第二个参数是对应的纹理坐标。texture函数会使用之前设置的纹理参数对相应的颜色值进行采样。这个片段着色器的输出就是纹理的（插值）纹理坐标上的(过滤后的)颜色。
 
 
-  之前直接输出顶点着色器来的颜色，现在变为经过纹理处理最终成为输出颜色。
+之前直接输出顶点着色器来的颜色，现在变为经过纹理处理最终成为输出颜色。
 
-  ```
-  #version 300 es
-  precision mediump float;
-  // 采样器(sampler)是用于从纹理贴图读取的特殊统一变量。采样器统一变量将加载一个指定纹理绑定的纹理单元额数据，java代码里面需要把它设置为纹理单元对应的index值。
-  uniform sampler2D uTextureUnit;
-  //接收刚才顶点着色器传入的纹理坐标(s,t)
-  in vec2 vTexCoord;
-  out vec4 vFragColor;
-  void main() {
-      // 100 es版本中是texture2D，texture函数会将传进来的纹理和坐标进行差值采样，输出到颜色缓冲区。
-      vFragColor = texture(uTextureUnit,vTexCoord);
-  }
-  ```
+```glsl
+#version 300 es
+precision mediump float;
+// 采样器(sampler)是用于从纹理贴图读取的特殊统一变量。采样器统一变量将加载一个指定纹理绑定的纹理单元额数据，java代码里面需要把它设置为纹理单元对应的index值。
+uniform sampler2D uTextureUnit;
+//接收刚才顶点着色器传入的纹理坐标(s,t)
+in vec2 vTexCoord;
+out vec4 vFragColor;
+void main() {
+    // 100 es版本中是texture2D，texture函数会将传进来的纹理和坐标进行差值采样，输出到颜色缓冲区。
+    vFragColor = texture(uTextureUnit,vTexCoord);
+}
+```
 
   
 
 - render实现类
 
-  区别就是把前面绘制矩形时的color部分换成了纹理，其他都是一样的。
+区别就是把前面绘制矩形时的color部分换成了纹理，其他都是一样的。
 
-  纹理的绘制:  
+纹理的绘制:  
 
-  ```
-  //激活纹理，设置当前活动的纹理单元为单元0
-  GLES30.glActiveTexture(GLES30.GL_TEXTURE0);
-  //绑定纹理，将纹理id绑定到当前活动的纹理单元上
-  GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, textureId);
-  // 将纹理单元传递片段着色器的采样器u_TextureUnit，0就代表GL_TEXTURE0， 1代表GL_TEXTURE1，以此类推
-  GLES20.glUniform1i(aTextureLocation, 0);
-  ```
+```java
+//激活纹理，设置当前活动的纹理单元为单元0
+GLES30.glActiveTexture(GLES30.GL_TEXTURE0);
+//绑定纹理，将纹理id绑定到当前活动的纹理单元上
+GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, textureId);
+// 将纹理单元传递片段着色器的采样器u_TextureUnit，0就代表GL_TEXTURE0， 1代表GL_TEXTURE1，以此类推
+GLES20.glUniform1i(aTextureLocation, 0);
+```
 
-  这里有没有很奇怪，sampler2D的变量是uniform的，但是我们并不是用glUniform()方法给他赋值，而是使用glUniform1i()。这是因为可以给纹理采样器分配一个位置值，这样我们就能够在一个片段着色器中设置多个纹理单元。一个纹理的话，纹理单元是默认为0，它是默认激活的，纹理单元的主要目的就是给着色器多一个使用的纹理。通过纹理单元赋值给采样器，我们可以一次绑定多个纹理，只要我们在使用的时候激活纹理。
+这里有没有很奇怪，sampler2D的变量是uniform的，但是我们并不是用glUniform()方法给他赋值，而是使用glUniform1i()。这是因为可以给纹理采样器分配一个位置值，这样我们就能够在一个片段着色器中设置多个纹理单元。一个纹理的话，纹理单元是默认为0，它是默认激活的，纹理单元的主要目的就是给着色器多一个使用的纹理。通过纹理单元赋值给采样器，我们可以一次绑定多个纹理，只要我们在使用的时候激活纹理。
 
   
 
@@ -345,143 +345,136 @@ public class TextureUtil {
 
 - 单纹理单元，多次绘制
 
-  多次调用glDrawArrays绘制纹理顶点的方式来实现，这样就是一张一张的按先后顺序，一层一层的绘制到当前的一帧画面。着色器与上面的完全一致，唯一不同的是要提供两个顶点位置的坐标，然后分别设置这两个坐标，并绑定两次纹理，然后调用两次glDrawArrays进行绘制。
+多次调用glDrawArrays绘制纹理顶点的方式来实现，这样就是一张一张的按先后顺序，一层一层的绘制到当前的一帧画面。着色器与上面的完全一致，唯一不同的是要提供两个顶点位置的坐标，然后分别设置这两个坐标，并绑定两次纹理，然后调用两次glDrawArrays进行绘制。
 
-  ```java
-  public class MultiTextureRender extends BaseGLSurfaceViewRenderer {
-      private final FloatBuffer vertextBuffer;
-      private final FloatBuffer vertextBuffer2;
-      private final FloatBuffer textureBuffer;
-  
-      private int textureId;
-      private int textureId2;
-      private int aPositionLocation;
-      private int aTextureLocation;
-      private int uSamplerTextureLocation;
-  
-      /**
-       * 坐标占用的向量个数
-       */
-      private static final int POSITION_COMPONENT_COUNT = 2;
-      // 逆时针顺序排列
-      private static final float[] POINT_DATA = {
-              -1f, -1f,
-              -1f, 1f,
-              1f, 1f,
-              1f, -1f,
-      };
-  
-      private static final float[] POINT_DATA2 = {
-              -0.5f, -0.5f,
-              -0.5f, 0.5f,
-              0.5f, 0.5f,
-              0.5f, -0.5f,
-      };
-      /**
-       * 颜色占用的向量个数
-       */
-      private static final int TEXTURE_COMPONENT_COUNT = 2;
-      // 纹理坐标(s, t)，t坐标方向和顶点y坐标反着
-      private static final float[] TEXTURE_DATA = {
-              0.0f, 1.0f,
-              0.0f, 0.0f,
-              1.0f, 0.0f,
-              1.0f, 1.0f
-      };
-  
-      public MultiTextureRender() {
-          vertextBuffer = BufferUtil.getFloatBuffer(POINT_DATA);
-          vertextBuffer2 = BufferUtil.getFloatBuffer(POINT_DATA2);
-          textureBuffer = BufferUtil.getFloatBuffer(TEXTURE_DATA);
-      }
-  
-      @Override
-      public void onSurfaceCreated(GL10 gl, EGLConfig config) {
-          glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
-          handleProgram(MyApplication.getInstance(), R.raw.texture_vertex_shader, R.raw.texture_fragment_shader);
-          aPositionLocation = glGetAttribLocation("vPosition");
-          aTextureLocation = glGetAttribLocation("aTextureCoord");
-          uSamplerTextureLocation = glGetUniformLocation("uTextureUnit");
-          textureId = TextureUtil.loadTexture(MyApplication.getInstance(), R.drawable.img).getTextureId();
-          textureId2 = TextureUtil.loadTexture(MyApplication.getInstance(), R.drawable.img).getTextureId();
-      }
-  
-      @Override
-      public void onSurfaceChanged(GL10 gl, int width, int height) {
-          glViewport(0, 0, width, height);
-          orthoM("u_Matrix", width, height);
-      }
-  
-      @Override
-      public void onDrawFrame(GL10 gl) {
-          glClear(GLES30.GL_COLOR_BUFFER_BIT);
-          glVertexAttribPointer(aPositionLocation, POSITION_COMPONENT_COUNT, GLES30.GL_FLOAT, false, 0, vertextBuffer);
-          glVertexAttribPointer(aTextureLocation, TEXTURE_COMPONENT_COUNT, GLES30.GL_FLOAT, false, 0, textureBuffer);
-          /****************/
-          // 中间这一部分代码的意思: 采样器统一变量将加载一个指定纹理绑定的纹理单元的数值，
-          // 例如，用数值0指定采样器表示从单元GL_TEXTURE0读取，指定数值1表示从GL_TEXTURE1读取，以此类推。
-          // 激活纹理单元后需要把它和纹理Id绑定，然后再通过GLES30.glUniform1i()方法传递给着色器中。
-  
-  
-          // 下面这两句表示纹理如何绑定到纹理单元。设置当前活动的纹理单元为纹理单元0，并将纹理ID绑定到当前活动的纹理单元上
-          glActiveTexture(GLES30.GL_TEXTURE0);
-          glBindTexture(GLES30.GL_TEXTURE_2D, textureId);
-          // 将采样器绑定到纹理单元，0就表示GLES30.GL_TEXTURE0
-          glUniform1i(uSamplerTextureLocation, 0);
-          /****************/
-          glEnableVertexAttribArray(aPositionLocation);
-          glEnableVertexAttribArray(aTextureLocation);
-          // 画第一次
-          glDrawArrays(GLES30.GL_TRIANGLE_FAN, 0, POINT_DATA.length / POSITION_COMPONENT_COUNT);
-  
-          //设置第二个纹理的坐标数据
-          GLES30.glVertexAttribPointer(aPositionLocation, POSITION_COMPONENT_COUNT, GLES30.GL_FLOAT,
-                  false, 0, vertextBuffer2);
-          //绑定纹理，前面已经激活了，就不用再调了
-          GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, textureId2);
-          // 画第二次
-          glDrawArrays(GLES30.GL_TRIANGLE_FAN, 0, POINT_DATA2.length / POSITION_COMPONENT_COUNT);
-          glDisableVertexAttribArray(aPositionLocation);
-          glDisableVertexAttribArray(aTextureLocation);
-      }
-  ```
-  
-  
-  
-- 多纹理单元，单次绘制
+```java
+public class MultiTextureRender extends BaseGLSurfaceViewRenderer {
+    private final FloatBuffer vertextBuffer;
+    private final FloatBuffer vertextBuffer2;
+    private final FloatBuffer textureBuffer;
 
-  OpenGL可以同时操作的纹理单元是16个，那么我们可以利用多个纹理单元来进行绘制同一个图层，从而达到目的。多纹理单元需要修改片段着色器的代码，顶点着色器不用改变，这种方式的优点是可以控制多个纹理的关系，做出复杂的效果。缺点是多个纹理单元的顶点坐标必须是一样的。
-  
-  片段着色器代码增加一个纹理采样器(multi2_texture_fragment_shader.glsl):
-  
-  ```glsl
-  #version 300 es
-  precision mediump float;
-  // 采样器(sampler)是用于从纹理贴图读取的特殊统一变量。采样器统一变量将加载一个指定纹理绑定的纹理单元额数据，java代码里面需要把它设置为0
-  uniform sampler2D uTextureUnit;
-  uniform sampler2D uTextureUnit2;
-  // 接收刚才顶点着色器传入的纹理坐标(s, t)
-  in vec2 vTexCoord;
-  out vec4 vFragColor;
-  
-  void main() {
-      // 100 es版本中是texture2D，texture函数会将传进来的纹理和坐标进行差值采样，输出到颜色缓冲区。
-      vec4 texture1 = texture(uTextureUnit, vTexCoord);
-      vec4 texture2 = texture(uTextureUnit2, vTexCoord);
-      if (texture1.a != 0.0) {
-          vFragColor = texture1;
-      } else {
-          vFragColor = texture2;
-      }
-  }
-  ```
-  
+    private int textureId;
+    private int textureId2;
+    private int aPositionLocation;
+    private int aTextureLocation;
+    private int uSamplerTextureLocation;
+
+    /**
+     * 坐标占用的向量个数
+     */
+    private static final int POSITION_COMPONENT_COUNT = 2;
+    // 逆时针顺序排列
+    private static final float[] POINT_DATA = {
+            -1f, -1f,
+            -1f, 1f,
+            1f, 1f,
+            1f, -1f,
+    };
+
+    private static final float[] POINT_DATA2 = {
+            -0.5f, -0.5f,
+            -0.5f, 0.5f,
+            0.5f, 0.5f,
+            0.5f, -0.5f,
+    };
+    /**
+     * 颜色占用的向量个数
+     */
+    private static final int TEXTURE_COMPONENT_COUNT = 2;
+    // 纹理坐标(s, t)，t坐标方向和顶点y坐标反着
+    private static final float[] TEXTURE_DATA = {
+            0.0f, 1.0f,
+            0.0f, 0.0f,
+            1.0f, 0.0f,
+            1.0f, 1.0f
+    };
+
+    public MultiTextureRender() {
+        vertextBuffer = BufferUtil.getFloatBuffer(POINT_DATA);
+        vertextBuffer2 = BufferUtil.getFloatBuffer(POINT_DATA2);
+        textureBuffer = BufferUtil.getFloatBuffer(TEXTURE_DATA);
+    }
+
+    @Override
+    public void onSurfaceCreated(GL10 gl, EGLConfig config) {
+        glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
+        handleProgram(MyApplication.getInstance(), R.raw.texture_vertex_shader, R.raw.texture_fragment_shader);
+        aPositionLocation = glGetAttribLocation("vPosition");
+        aTextureLocation = glGetAttribLocation("aTextureCoord");
+        uSamplerTextureLocation = glGetUniformLocation("uTextureUnit");
+        textureId = TextureUtil.loadTexture(MyApplication.getInstance(), R.drawable.img).getTextureId();
+        textureId2 = TextureUtil.loadTexture(MyApplication.getInstance(), R.drawable.img).getTextureId();
+    }
+
+    @Override
+    public void onSurfaceChanged(GL10 gl, int width, int height) {
+        glViewport(0, 0, width, height);
+        orthoM("u_Matrix", width, height);
+    }
+
+    @Override
+    public void onDrawFrame(GL10 gl) {
+        glClear(GLES30.GL_COLOR_BUFFER_BIT);
+        glVertexAttribPointer(aPositionLocation, POSITION_COMPONENT_COUNT, GLES30.GL_FLOAT, false, 0, vertextBuffer);
+        glVertexAttribPointer(aTextureLocation, TEXTURE_COMPONENT_COUNT, GLES30.GL_FLOAT, false, 0, textureBuffer);
+        /****************/
+        // 中间这一部分代码的意思: 采样器统一变量将加载一个指定纹理绑定的纹理单元的数值，
+        // 例如，用数值0指定采样器表示从单元GL_TEXTURE0读取，指定数值1表示从GL_TEXTURE1读取，以此类推。
+        // 激活纹理单元后需要把它和纹理Id绑定，然后再通过GLES30.glUniform1i()方法传递给着色器中。
+
+
+        // 下面这两句表示纹理如何绑定到纹理单元。设置当前活动的纹理单元为纹理单元0，并将纹理ID绑定到当前活动的纹理单元上
+        glActiveTexture(GLES30.GL_TEXTURE0);
+        glBindTexture(GLES30.GL_TEXTURE_2D, textureId);
+        // 将采样器绑定到纹理单元，0就表示GLES30.GL_TEXTURE0
+        glUniform1i(uSamplerTextureLocation, 0);
+        /****************/
+        glEnableVertexAttribArray(aPositionLocation);
+        glEnableVertexAttribArray(aTextureLocation);
+        // 画第一次
+        glDrawArrays(GLES30.GL_TRIANGLE_FAN, 0, POINT_DATA.length / POSITION_COMPONENT_COUNT);
+
+        //设置第二个纹理的坐标数据
+        GLES30.glVertexAttribPointer(aPositionLocation, POSITION_COMPONENT_COUNT, GLES30.GL_FLOAT,
+                false, 0, vertextBuffer2);
+        //绑定纹理，前面已经激活了，就不用再调了
+        GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, textureId2);
+        // 画第二次
+        glDrawArrays(GLES30.GL_TRIANGLE_FAN, 0, POINT_DATA2.length / POSITION_COMPONENT_COUNT);
+        glDisableVertexAttribArray(aPositionLocation);
+        glDisableVertexAttribArray(aTextureLocation);
+    }
+```
   
   
   
+- 多纹理单元，单次绘制
 
-
-
+OpenGL可以同时操作的纹理单元是16个，那么我们可以利用多个纹理单元来进行绘制同一个图层，从而达到目的。多纹理单元需要修改片段着色器的代码，顶点着色器不用改变，这种方式的优点是可以控制多个纹理的关系，做出复杂的效果。缺点是多个纹理单元的顶点坐标必须是一样的。
+
+片段着色器代码增加一个纹理采样器(multi2_texture_fragment_shader.glsl):
+
+```glsl
+#version 300 es
+precision mediump float;
+// 采样器(sampler)是用于从纹理贴图读取的特殊统一变量。采样器统一变量将加载一个指定纹理绑定的纹理单元额数据，java代码里面需要把它设置为0
+uniform sampler2D uTextureUnit;
+uniform sampler2D uTextureUnit2;
+// 接收刚才顶点着色器传入的纹理坐标(s, t)
+in vec2 vTexCoord;
+out vec4 vFragColor;
+
+void main() {
+    // 100 es版本中是texture2D，texture函数会将传进来的纹理和坐标进行差值采样，输出到颜色缓冲区。
+    vec4 texture1 = texture(uTextureUnit, vTexCoord);
+    vec4 texture2 = texture(uTextureUnit2, vTexCoord);
+    if (texture1.a != 0.0) {
+        vFragColor = texture1;
+    } else {
+        vFragColor = texture2;
+    }
+}
+```
 
 [上一篇: 8.GLES类及Matrix类](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/8.GLES%E7%B1%BB%E5%8F%8AMatrix%E7%B1%BB.md)  
 [下一篇: 10.GLSurfaceView+MediaPlayer播放视频](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md)

From 29db8a2dd7fc95dae9f3f945bf4e92192869c3db Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 10 May 2023 22:06:08 +0800
Subject: [PATCH 112/213] update opengl part

---
 .../OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"             | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git "a/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md" "b/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"
index 27d255aa..675f4d24 100644
--- "a/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"	
+++ "b/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"	
@@ -10,7 +10,7 @@
 
 和前一篇文章基本一样，只是修改一下片段着色器的代码，原理就是在片段着色器中去处理颜色，让RGB三个通道的颜色取均值:
 
-```
+```glsl
 #version 300 es
 #extension GL_OES_EGL_image_external_essl3 : require
 precision mediump float;

From df6b256dd243f148426ab1ac4ad72db5659844fd Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Tue, 16 May 2023 15:15:42 +0800
Subject: [PATCH 113/213] update OpenGL part

---
 ...273\230\345\210\266\344\270\211\350\247\222\345\275\242.md" | 3 ++-
 .../OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"             | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md" "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"
index f8c2d583..36391f49 100644
--- "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
@@ -579,7 +579,8 @@ public class TriangleRender implements GLSurfaceView.Renderer {
 
 
 
-我们设置的是数据来看，应该是等腰三角形，但是实际效果并不是，这是因为前面说到的OpenGL ES使用的是虚拟坐标导致的。如果想让绘制一个等腰三角形该怎么做呢？ 
+我们设置的是数据来看，应该是等腰三角形，但是实际效果并不是，这是因为OpenGL假设屏幕采用均匀的方形坐标系，所以在把标准坐标系下的坐标绘制到非方形的屏幕上时，就会出现拉伸。
+如果想让绘制一个等腰三角形该怎么做呢？ 
 
 ### 变成等腰三角形的原理
 
diff --git "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md" "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"
index f23fbef6..f780c5cc 100644
--- "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
+++ "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
@@ -23,7 +23,8 @@
 
 ### 纹理坐标
 
-OpenGL中，2D纹理也有自己的坐标体系，取值范围在(0,0)到(1,1)内，两个维度分别为S、T，所以一般称为ST纹理坐标。有些时候也叫UV坐标。纹理左边的方向性和Android上的canvas移植，都是顶点在左上角。
+OpenGL中，2D纹理也有自己的坐标体系，取值范围在(0,0)到(1,1)内，两个维度分别为S、T，所以一般称为ST纹理坐标。有些时候也叫UV坐标。纹理左边的方向性和Android上的视图坐标系一致，都是顶点在左上角，范围为0到1之间。
+
 
 纹理上的每个顶点与定点坐标上的顶点一一对应。如下图，左边是顶点坐标，右边是纹理坐标，只要两个坐标的ABCD定义顺序一致，就可以正常地映射出对应的图形。顶点坐标内光栅化后的每个片段，都会在纹理坐标内取得对应的颜色值。
 

From 6825cb1843eaee0640709df3dce5d6933d8753c8 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Fri, 19 May 2023 22:39:18 +0800
Subject: [PATCH 114/213] update OpenGL

---
 VideoDevelopment/.DS_Store                    | Bin 0 -> 6148 bytes
 ...72\347\241\200\347\237\245\350\257\206.md" |  13 ++++
 .../1.OpenGL\347\256\200\344\273\213.md"      |  28 ++++++++
 VideoDevelopment/OpenGL/12.FBO.md             |  61 ++++++++++++++++++
 .../9.OpenGL ES\347\272\271\347\220\206.md"   |  31 +++++++++
 5 files changed, 133 insertions(+)
 create mode 100644 VideoDevelopment/.DS_Store
 create mode 100644 VideoDevelopment/OpenGL/12.FBO.md

diff --git a/VideoDevelopment/.DS_Store b/VideoDevelopment/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..2b7b4ca390d8c420538b442b2cba749a3acc071f
GIT binary patch
literal 6148
zcmeHKOH0E*5T4aqQy<uag2#Z@g7uB)Ay&nUAQ;huN^D5cV9b_2?4cBL^l|c}KgB<w
zcQ5`C|9~^QTj)ctB4q|<zuDcHg!#zsWB@=E>cIj)762?%!qgZJKM3uU_Q{Z0Nh1pN
z3<)6w&tLcNFHe2myub`F1OJTyI=d6F1u+CrfsXU*f&1Y%s%1ZtKKi`+<tVJy^7&6O
zG@Keqk6NSFxOMJc$%b1i*6P(lv2seYBPk=lZ5RFHu+;Ff)7vtx6~nkxQ2}94LYK3X
zFb-s+AnS2ZRk5z#urgN0%g#2NEBSoRUS3;i<?QDABH2r;tyadGnVa7@^sb|uSUzY%
z1>QeOCJnaX5shE-yLBsZB;!l;q4+c$Kp9HN#UAVrNbX%Z_2x_W^qIJOyV~@o1|{Fl
zoO<$Ye-n(F0dr=oaVCTrU<R0h9tP-suu%yegNa6Ub>N^{0K^n7D?yuj35u}|ItCMs
zxPu~eD54G(ro|9C9M^5*=NL>h>TnRI`4HyK!gMG?y&a!#D|Zl%Mjn{~W}usaVLi=K
z{onn)|L+ds88g5P3={(*wd3v-FeOu4`;wztYolJEl8|4bQH9`O%CR!26wjh6!9AM{
WM8{yF5m!+7M?lfQ12gca415E6(b%&9

literal 0
HcmV?d00001

diff --git "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
index 1d617b21..54520ce4 100644
--- "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
+++ "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
@@ -266,6 +266,19 @@ U和V不是基础信号，他俩都是被正交调制的。早期的电视都是
 
 YUV和RGB视频信号相比，最大的优点在于只需要占用极少的带宽，YUV只需要占用RGB一般的带宽。
 
+
+YUV 色彩编码模型，其设计初衷为了解决彩色电视机与黑白电视的兼容问题，利用了人类眼睛的生理特性（对亮度敏感，对色度不敏感），允许降低色度的带宽，降低了传输带宽。
+
+在计算机系统中应用尤为广泛，利用 YUV 色彩编码模型可以降低图片数据的内存占用，YUV只需要占用RGB一般的带宽，从而提高数据处理效率。
+
+另外，YUV 编码模型的图像数据一般不能直接用于显示，还需要将其转换为 RGB（RGBA） 编码模型，才能够正常显示图像。
+
+
+————————————————
+版权声明：本文为CSDN博主「字节流动」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
+原文链接：https://blog.csdn.net/Kennethdroid/article/details/94031821
+
+
 YUV码流的存储格式其实与其采样的方式密切相关，主流的采样方式有四种，
 - YUV 4:4:4
 YUV三个信道的抽样率相同，因此在生成的图像里，每个象素的三个分量信息完整（每个分量通常8比特），经过8比特量化之后，未经压缩的每个像素占用3个字节。
diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
index effb8b0d..eeb9c5dc 100644
--- "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -88,6 +88,13 @@ OpenGL ES 3.0实现了具有可编程着色功能的图形管线，有两个规
     顶点着色器会在GPU上创建内存用于存储我们的顶点数据，还要配置OpenGL如何解释这些内存，并且指定其如何发送给显卡。顶点着色器接着会处理我们在内存中指定数量的顶点。
     我们通过顶点缓冲对象(Vertex Buffer Object, VBO)管理这个内存，它会在GPU内存(通常被称为显存)中储存大量顶点。使用这些缓冲对象的好处是我们可以一次性的发送一大批数据到显卡上，而不是每个顶点发送一次。从CPU把数据发送到显卡相对较慢，所以只要可能我们都尝试尽量一次性发送尽可能多的数据。当数据发送至显卡的内存中后，顶点着色器几乎能立即访问顶点，这个是非常快的过程。
 
+    OpenGLES2.0 编程中，用于绘制的顶点数组数据首先保存在 CPU 内存，在调用 glDrawArrays 或者 glDrawElements 等进行绘制时，需要将顶点数组数据从 CPU 内存拷贝到显存。
+
+    但是很多时候我们没必要每次绘制的时候都去进行内存拷贝，如果可以在显存中缓存这些数据，就可以在很大程度上降低内存拷贝带来的开销。
+
+    OpenGLES3.0 VBO 和 EBO 的出现就是为了解决这个问题。 VBO 和 EBO 的作用是在显存中提前开辟好一块内存，用于缓存顶点数据或者图元索引数据，从而避免每次绘制时的 CPU 与 GPU 之间的内存拷贝，可以提升渲染性能，降低内存带宽和功耗。
+
+
     顶点缓冲对象是OpenGL中的一个对象，就像OpenGL中的其它对象一样，这个缓冲有一个独一无二的ID，所以我们可以使用glGenBuffers()函数和一个缓冲ID生成一个VBO对象: 
     ```java
     // 下面只生成一个vbo对象，所以vbo的容量设置为1即可
@@ -256,6 +263,27 @@ EGL提供了OpenGL ES和运行于计算机上的原生窗口系统(如Windows、
 在EGL能够确定可用的绘制表面类型(或者底层系统的其他特性)之前，它必须打开和窗口系统的通信渠道。注意。Apple提供自己的EGL API的iOS实现，成为EAGL。     
 因为每个窗口系统都有不同的语言，所以EGL提供基本的不透明类型--EGLDisplay，该类型封装了所有系统相关性，用于和原生窗口系统接口。任何使用EGL的应用程序必须执行的第一个操作就是创建和初始化与本地EGL显示的连接。
 
+EGL 是 OpenGL ES 和本地窗口系统（Native Window System）之间的通信接口，它的主要作用：
+
+- 与设备的原生窗口系统通信；
+- 查询绘图表面的可用类型和配置；
+- 创建绘图表面；
+- 在OpenGL ES 和其他图形渲染API之间同步渲染；
+- 管理纹理贴图等渲染资源。
+OpenGL ES 的平台无关性正是借助 EGL 实现的，EGL 屏蔽了不同平台的差异（Apple 提供了自己的 EGL API 的 iOS 实现，自称 EAGL）。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/egl_interface_1.png?raw=true)
+上图中: 
+- Display(EGLDisplay) 是对实际显示设备的抽象；
+- Surface（EGLSurface）是对用来存储图像的内存区域 FrameBuffer 的抽象，包括 Color Buffer（颜色缓冲区）， Stencil Buffer（模板缓冲区） ，Depth Buffer（深度缓冲区）；
+- Context (EGLContext) 存储 OpenGL ES 绘图的一些状态信息；
+在 Android 平台上开发 OpenGL ES 应用时，类 GLSurfaceView 已经为我们提供了对 Display , Surface , Context 的管理，即 GLSurfaceView 内部实现了对 EGL 的封装，可以很方便地利用接口 GLSurfaceView.Renderer 的实现，使用 OpenGL ES API 进行渲染绘制，很大程度上提升了 OpenGLES 开发的便利性。
+
+
+
+
+本地窗口相关的 API 提供了访问本地窗口系统的接口，而 EGL 可以创建渲染表面 EGLSurface ，同时提供了图形渲染上下文 EGLContext，用来进行状态管理，接下来 OpenGL ES 就可以在这个渲染表面上绘制。
+
 
 EGL为双缓冲工作模式(Double Buffer)，既有一个Back Frame Buffer和一个Front Frame Buffer，正常绘制的目标都是Back Frame Buffer，绘制完成后再调用eglSwapBuffer API，将绘制完毕的FrameBuffer交换到Front Frame Buffer并显示出来。   
 
diff --git a/VideoDevelopment/OpenGL/12.FBO.md b/VideoDevelopment/OpenGL/12.FBO.md
new file mode 100644
index 00000000..728b6430
--- /dev/null
+++ b/VideoDevelopment/OpenGL/12.FBO.md
@@ -0,0 +1,61 @@
+## 12.FBO
+
+FBO（Frame Buffer Object）即帧缓冲区对象，实际上是一个可添加缓冲区的容器，可以为其添加纹理或渲染缓冲区对象（RBO）。
+
+FBO 本身不能用于渲染，只有添加了纹理或者渲染缓冲区之后才能作为渲染目标，它仅且提供了 3 种附着（Attachment），分别是颜色附着、深度附着和模板附着。
+
+RBO（Render Buffer Object）即渲染缓冲区对象，是一个由应用程序分配的 2D 图像缓冲区。渲染缓冲区可以用于分配和存储颜色、深度或者模板值，可以用作 FBO 中的颜色、深度或者模板附着。
+
+使用 FBO 作为渲染目标时，首先需要为 FBO 的附着添加连接对象，如颜色附着需要连接纹理或者渲染缓冲区对象的颜色缓冲区。
+
+
+#### 为什么用 FBO
+
+默认情况下，OpenGL ES 通过绘制到窗口系统提供的帧缓冲区，然后将帧缓冲区的对应区域复制到纹理来实现渲染到纹理，但是此方法只有在纹理尺寸小于或等于帧缓冲区尺寸才有效。
+
+另一种方式是通过使用连接到纹理的 pbuffer 来实现渲染到纹理，但是与上下文和窗口系统提供的可绘制表面切换开销也很大。因此，引入了帧缓冲区对象 FBO 来解决这个问题。
+
+Android OpenGL ES 开发中，一般使用 GLSurfaceView 将绘制结果显示到屏幕上，然而在实际应用中，也有许多场景不需要渲染到屏幕上，如利用 GPU 在后台完成一些图像转换、缩放等耗时操作，这个时候利用 FBO 可以方便实现类似需求。
+
+使用 FBO 可以让渲染操作不用再渲染到屏幕上，而是渲染到离屏 Buffer 中，然后可以使用 glReadPixels 或者 HardwareBuffer 将渲染后的图像数据读出来，从而实现在后台利用 GPU 完成对图像的处理。
+
+
+
+
+[上一篇: 10.GLSurfaceView+MediaPlayer播放视频](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md" "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"
index f780c5cc..c82c89d4 100644
--- "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
+++ "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
@@ -30,6 +30,37 @@ OpenGL中，2D纹理也有自己的坐标体系，取值范围在(0,0)到(1,1)
 
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_texture_position.jpg)
 
+
+在 OpenGL 中，纹理实际上是一个可以被采样的复杂数据集合，是 GPU 使用的图像数据结构，纹理分为 2D 纹理、 立方图纹理和 3D 纹理。
+
+2D 纹理是 OpenGLES 中最常用和最常见的纹理形式，是一个图像数据的二维数组。纹理中的一个单独数据元素称为纹素或纹理像素。
+
+立方图纹理是一个由 6 个单独的纹理面组成的纹理。立方图纹理像素的读取通过使用一个三维坐标（s,t,r）作为纹理坐标。
+
+3D 纹理可以看作 2D 纹理作为切面的一个数组，类似于立方图纹理，使用三维坐标对其进行访问。
+
+
+在 OpenGLES 中，纹理映射就是通过为图元的顶点坐标指定恰当的纹理坐标，通过纹理坐标在纹理图中选定特定的纹理区域，最后通过纹理坐标与顶点的映射关系，将选定的纹理区域映射到指定图元上。
+
+纹理映射也称为纹理贴图，简单地说就是将纹理坐标（纹理坐标系）所指定的纹理区域，映射到顶点坐标（渲染坐标系或OpenGLES 坐标系）对应的区域。
+
+纹理坐标系:  
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/texture_st_1.png)
+渲染坐标系或OpenGLES 坐标系:
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/texture_st_2.png)
+4 个纹理坐标分别为
+T0（0，0），T1（0，1），T2（1，1），T3（1，0）。
+4 个纹理坐标对于的顶点坐标分别为
+V0（-1，0.5），V1（-1， -0.5），V2（1，-0.5），V3（1，0.5）
+由于 OpenGLES 绘制是以三角形为单位的，设置绘制的 2 个三角形为 V0V1V2 和 V0V2V3 。
+当我们调整纹理坐标的顺序顶点坐标顺序不变，如 T0T1T2T3 -> T1T2T3T0 ，绘制后将得到一个顺时针旋转 90 度的纹理贴图。所以调整纹理坐标和顶点坐标的对应关系可以实现纹理图简单的旋转。
+
+
+
+
+
+
+
 ### 文件读取
 
 OpenGL不能直接加载jpg或者png这类被编码的压缩格式，需要加载原始数据，也就是bitmap。我们在内置图片到工程中，应该将图片放到drawable-nodpi中，避免读取时被压缩，通过BitmapFactory解码读取图片时，要设置为非缩放的方式，即options.isScaled=false。

From 55b4f4fe6c80cf18e44fd1ad2590c51be6f0ea9b Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Sat, 20 May 2023 21:30:25 +0800
Subject: [PATCH 115/213] =?UTF-8?q?update=E2=80=9C?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...44\350\241\214\345\244\247\345\205\250.md" | 40 ++++++++++++++++++-
 1 file changed, 39 insertions(+), 1 deletion(-)

diff --git "a/JavaKnowledge/\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214\345\244\247\345\205\250.md" "b/JavaKnowledge/\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214\345\244\247\345\205\250.md"
index 77830f45..8b25dcf3 100644
--- "a/JavaKnowledge/\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214\345\244\247\345\205\250.md"
+++ "b/JavaKnowledge/\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214\345\244\247\345\205\250.md"
@@ -87,7 +87,7 @@
 
 - `rmdir`
 
-     该命令的功能是删除空目录，一个目录被删除之前必须是空的。删除某目录时也必须具有对父目录的写权限。
+     该命令的功能是删除空目录，一个目录被删除之前必须是空的。删除某目录时也必须具有对父目录的写权限。由于只能删除空目录，一般都是使用rm -f
 
 - `mv`
 
@@ -467,6 +467,7 @@ chmod ［who］ ［+ | - | =］ ［mode］ 文件名
 ```
 chmod 751 file
 ```
+如果是当前root用户执行，前面需要加 sudo chmod 751 file
 
 
 性能监控和优化命令
@@ -523,6 +524,43 @@ $ file .bashrc
 警告　以root身份使用pkill命令时要格外小心。命令中的通配符很容易意外地将系统的重要进程终止。这可能会导致文件系统损坏。
     
 
+### Shell脚本
+
+```shell
+#!/bin/bash
+# This line is a comment
+echo "Hello World"
+```
+一个shell脚本永远以#!开头，这个是一个脚本开始的标记，它是告诉系统执行这个文件需要使用某个解释器，后面的/bin/bash指明了解释器的具体位置。 
+第二行 # 这里表示是一个注解
+第三行是输出Hello World
+
+#### 运行脚本
+脚本的运行有好几种方式： 
+- 在该脚本所在的目录中直接bash这个脚本，直接bash一个文件就是指定了使用Bash Shell来解释脚本内容。
+- 给该脚本加上可执行权限，然后使用./来运行，它代表运行的是当前目录下的Hello World.sh脚本， 如果采用这种方式而脚本没有可执行权限则会报错。
+    ```shell
+    sudu chmod 777 HelloWorld.sh
+    ./HelloWorld.sh
+    ```
+- 如果不想修改权限可以使用.来运行脚本
+    ```shell
+    . ./HelloWorld.sh
+    ```            
+###### 声明变量： declare、typeset
+这两个命令都是用来声明变量的，作用完全相同。
+很多语法严谨的语言对变量的声明都是有严格要求的，变量的使用原则是必须在使用前声明、声明时必须说明变量类型，而shell脚本中对变量声明的要求并不高，因为shell弱化了变量的类概念，所有shell又称为弱类型编程语言，声明变量时并不需要指明类型。 
+
+
+###### 函数
+```shell
+function NAME() {
+    .....
+    return x;
+}
+```
+function关键字可以省略。
+
         
 ----
 - 邮箱 ：charon.chui@gmail.com  

From ede2581df0dd2b4af4f6d5e38fce9d135648ae42 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Tue, 23 May 2023 22:31:53 +0800
Subject: [PATCH 116/213] update FFmpeg

---
 ...77\347\224\250\346\225\231\347\250\213.md" |  14 ++++++-
 VideoDevelopment/.DS_Store                    | Bin 6148 -> 8196 bytes
 ...72\347\241\200\347\237\245\350\257\206.md" |  18 +++++++--
 VideoDevelopment/FFmpeg/AAC.md                |  22 +++++++++++
 ...26\347\240\201\346\240\274\345\274\217.md" |  36 ++++++++++++++++++
 5 files changed, 85 insertions(+), 5 deletions(-)
 create mode 100644 VideoDevelopment/FFmpeg/AAC.md
 create mode 100644 "VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/\351\237\263\351\242\221\347\274\226\347\240\201\346\240\274\345\274\217.md"

diff --git "a/JavaKnowledge/Vim\344\275\277\347\224\250\346\225\231\347\250\213.md" "b/JavaKnowledge/Vim\344\275\277\347\224\250\346\225\231\347\250\213.md"
index 1ade6bd3..3c2cffc6 100644
--- "a/JavaKnowledge/Vim\344\275\277\347\224\250\346\225\231\347\250\213.md"
+++ "b/JavaKnowledge/Vim\344\275\277\347\224\250\346\225\231\347\250\213.md"
@@ -18,8 +18,11 @@ Vim使用教程
 - `i` 进入`insert`模式
 - `a(append)` 在光标后进行插入，直接进入`insert`模式
 - `o(open a line below)` 在当前行后插入一个新行，直接进入`insert`模式
+- `O` 大写的O是在光标所在的行下面插入一个新航，直接进入编译模式
 - `I` 从该行的最前面开始编辑
 - `A` 从该行的最后面开始编辑
+- `s` 删除光标后的字符，从光标当前位置插入
+- `S` 删除光标所在当前行，从行首插入
 - `cw` 替换从光标位置开始到该单词结束位置的所有字符，直接进入`Insert`模式
 
 在VIM中，有相当一部分命令可以扩展为3部分：
@@ -70,6 +73,7 @@ Vim使用教程
 - `#X` 删除光标所在位置前的#个字符
 - `dd` 删除当前行，并把删除的行存到剪贴板中
 - `#dd` 从光标所在行开始删除#行。如`5dd`就是删除5行
+- `v/ctrl+v`: 使用h、j、k、l移动选择内容，然后按d删除。其中v是非列模式，ctrl+v是列模式
 
 复制粘贴
 ---
@@ -81,7 +85,9 @@ Vim使用教程
 - `y$` 拷贝光标至本行结束位置
 - `y` 拷贝选中部分，在`Normal`模式下按`v`会进入到可视化模式，这时候可以上下移动进行选中某一部分，然后按`y`就可以复制了。
 
-- `p` 粘贴
+- `p` 在光标所在的位置向下开辟一行，粘贴
+- `P` 在光标所在的位置向上开辟一行，粘贴
+- 剪切： 按dd或者ndd删除，将删除的行保存到剪贴板中，然后按p/P就可以粘贴了。
 
 
 替换
@@ -90,6 +96,9 @@ Vim使用教程
 - `r` 替换光标所在处的字符
 - `R` 替换光标所到之处的字符，直到按下`esc`键为止
 - `:%s/old/new/g` 用`new`替换文件中所有的`old`
+- `:%s/old/new/gc`，同上，但是每次替换需要用户确认
+- `:s/old/new/g` 光标所在行的所有old替换为new
+- `:s/old/new/` 光标所在行的第一个old替换为new
 
 撤销
 ---
@@ -118,7 +127,8 @@ Vim使用教程
 - `:q!` 退出不保存
 - `:saveas <pat>` 另存为
 - `:e filename` 打开文件
-- `:sav filename` 保存为某文件名
+- `:sav filename 保存为某文件名
+- ZZ: 命令模式使用大写ZZ直接保存并退出
 
 
 
diff --git a/VideoDevelopment/.DS_Store b/VideoDevelopment/.DS_Store
index 2b7b4ca390d8c420538b442b2cba749a3acc071f..d444bf3996b5031376c5e5d08fc3074f41cdbc46 100644
GIT binary patch
literal 8196
zcmeHMO^?z*7=CA$WlPo%OkCyI#4Cxg%f}Ku0HR(@NUYIB*HpSC(AaheA7Vm?99{RM
zm-Sb8)p%d;Ui>5b2YhFyG~FT%F=j!XAv4b~^S&+5Gwr;63jmPnz{~=q06@XYFu8@z
zFAAGyb*8L&Bio1s{Q)RgU>=_ye*5@-###<Y1*8H}0jYpgKq{~b3Si7;MVS-##jI?l
z0#bqhQUSI<s8|`6J)8*STL(5g1wf49FfZ80Jb?SC9+o|v2;{DKOp!eh&y{#71`+N!
zuQGGQvWF9a!X1ck2jZQXco_=eXGcGkn*%8el&w@iDln@6%iS+P1za$p8_eHz(7qeP
zUdOPhfi_=^j&1e&namHewjSGvZz`M0mhxO{)1lUH^as6aqx+0~dqk;iO#2PvvDF;v
z$*Xs$+izHIv&$VUvxz4APb}A@!zvxPW{>-7VnRtM2|bw_jdG<zTFsV<<Fq;|?PStw
zZnrQVCzS0QH*Y=EU)qjK-w8^@+ZNzrh~iNczgJq<wW-@e8|EK}d-!pn15IcJxPLx(
z?$<}7{9ZAw?v)~_9}22-sWWNLP@17z=Tu#|4-W!#m$KCP3|rn}K7#KeOC5&*rx4!_
zr}FeeUDN7Ep8{-`vbee3w7QcmM37x%aRY=xRO9Ro+&+1G(!Q-<4v<~S(*B{l_zWkr
zcVHX1)9~9iNH!!yjLp5d_L}@7BKUlQ0{DYr^2et$<d<@}=XY~>y+>{1i(KxpDV-^I
zw*UEqb}OqLP^Tj{Mc(>z4z1O^IHr8nuT;mEPAWlPhnkV|o%Z}=hcpkIe&xIC;uoe^
z{(pD=`~Q{aA%CD$Kq~P23XoV$t5wl|`VbvH6w9?$tS_*#!t5pjxeGQt9Y^HpIHLcD
wA@)@?Wj<vOCjxN<%lW?u_?sVs{7^rQflNeyFcgdY_!oHik?~)~e}3Qn1gOZh@Bjb+

delta 130
zcmZp1XfcprU|?W$DortDU=RQ@Ie-{Mvv5r;6q~50$jG)aU^g=(+hiVrIg=*~xlevC
zpf#C8=-uRp!o5Jg$K>-O(vzdb*Gz0kS<KGCA;=8W3j_k(K*AMd%*Mj+%#-<LJVAys
QFhMK;*~zduo@Wj-0BFM-lK=n!

diff --git "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
index 54520ce4..dc4465f8 100644
--- "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
+++ "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
@@ -87,6 +87,9 @@
 
     LCD液晶显示器和传统的CRT显示器，分辨率都是重要的参数之一。传统CRT显示器所支持的分辨率较有弹性，而LCD的像素间距已经固定，所以支持的显示模式不像CRT那么多。LCD的最佳分辨率，也叫最大分辨率，在该分辨率下，液晶显示器才能显现最佳影像。
 
+每个像素有RGB三种颜色组成，每色有8bit，取值范围为(0 ~ 255)也就是2的8次方。这种方式表达出来的颜色，也被称为24位色(占用24bit)。
+
+1080P的P是指Progressive scan(逐行扫描)，即垂直方向像素点，也就是高。所以1920*1080叫1080P，不叫1920P。
 
 
 - DTS
@@ -168,6 +171,9 @@ AAC+ > MP3PRO > AAC> RealAudio > WMA > MP3
 
 PCM是英文Pulse-code modulation的缩写，中文译名是脉冲编码调制。我们知道在现实生活中，人耳听到的声音是模拟信号，PCM就是要把声音从模拟转换成数字信号的一种技术，它的原理简单地说就是利用一个固定的频率对模拟信号进行采样，采样后的信号在波形上看就像一串连续的幅值不一的脉冲，把这些脉冲的幅值按一定的精度进行量化，这些量化后的数值被连续地输出、传输、处理或记录到存储介质中，所有这些组成了数字音频的产生过程。
 
+
+PCM的采集步骤分为： 
+模拟信号 -> 采样 -> 量化 -> 编码  -> 数字信号
 ---
 
 
@@ -229,7 +235,10 @@ PCM是英文Pulse-code modulation的缩写，中文译名是脉冲编码调制
 
 8位代表2的8次方—256，16位则代表2的16次方—64K。比较一下，一段相同的音乐信息，16位声卡能把它分为64K个精度单位进行处理，而8位声卡只能处理256个精度单位，造成了较大的信号损失，最终的采样效果自然是无法相提并论的。
 
+#### 采样率
 
+音频的采样率要大于原声波频率的2倍，人耳能听到的最高频率为20kHz，所以为了满人耳的听觉要求，采样率至少为40kHz以上，通常为44.1kHz。 
+44.1kHz就是代表1秒会采样44100次。
 采样频率：是指录音设备在一秒钟内对声音信号的采样次数，采样频率越高声音的还原就越真实越自然。在当今的主流采集卡上，采样频率一般共分为22.05KHz、44.1KHz、48KHz三个等级，22.05KHz只能达到FM广播的声音品质，44.1KHz则是理论上的CD音质界限，48KHz则更加精确一些。对于高于48KHz的采样频率人耳已无法辨别出来了，所以在电脑上没有多少使用价值。
 
 
@@ -252,14 +261,17 @@ PCM是英文Pulse-code modulation的缩写，中文译名是脉冲编码调制
 - 5.1声道:5.1声道已广泛运用于各类传统影院和家庭影院中，一些比较知名的声音录制压缩格式，譬如杜比`AC-3`（`Dolby Digital`）、`DTS`等都是以5.1声音系统为技术蓝本的。其实5.1声音系统来源于4.1环绕，不同之处在于它增加了一个中置单元。这个中置单元负责传送低于`80Hz`的声音信号，在欣赏影片时有利于加强人声，把对话集中在整个声场的中部，以增加整体效果。相信每一个真正体验过`DolbyAC-3`音效的朋友都会为5.1声道所折服。千万不要以为5.1已经是环绕立体声的顶峰了，更强大的7.1系统已经出现了。
 它在5.1的基础上又增加了中左和中右两个发音点，以求达到更加完美的境界。由于成本比较高，没有广泛普及。
 
+##### 音频的码率
+码率是指一个数据流中每秒钟能通过的信息量，单位是bps(bit per second)。 
+码率 = 采样率 * 采样位数 * 声道数。 
 
 YUV
 ---
 
 YUV(也成YCbCr)是电视系统所采用的一种颜色编码方法，他是一种亮度与色度分离的色彩格式。
 - 其中Y表示明亮度(Luminance或Luma)也就是灰阶值，它是基础信号。
-- U表示色度
-- V表示浓度
+- U表示蓝色通道与亮度的差值
+- V表示红色通道与亮度的差值(为什么只有蓝色红色，没有绿色，这是因为红蓝绿加起来为1，所以1减去他俩就是绿)
 UV的作用是描述影像色彩及饱和度，它们用于指定像素的颜色。
 U和V不是基础信号，他俩都是被正交调制的。早期的电视都是黑白的，即只有亮度值(Y)，有了彩色电视之后，加入了UV两种色度，形成现在的YUV。
 人眼对亮度敏感，对色度不敏感，因此减少部分UV的数据量，人眼也无法感知出来，这样就可以通过压缩UV的分辨率，在不影响观感的前提下，减少视频的体积。
@@ -399,4 +411,4 @@ PAR DAR SAR
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git a/VideoDevelopment/FFmpeg/AAC.md b/VideoDevelopment/FFmpeg/AAC.md
new file mode 100644
index 00000000..635c4ab9
--- /dev/null
+++ b/VideoDevelopment/FFmpeg/AAC.md
@@ -0,0 +1,22 @@
+### AAC
+
+### 音频编码
+
+原始的PCM音频数据也是非常大的数据量，因此也需要对其进行压缩编码。
+和视频编码一样，音频也有许多的编码格式，如：WAV、MP3、WMA、APE、FLAC等等，音乐发烧友应该对这些格式非常熟悉，特别是后两种无损压缩格式。
+
+AAC是新一代的音频有损压缩技术，一种高压缩比的音频压缩算法。
+在MP4视频中的音频数据，大多数时候都是采用的AAC压缩格式。
+
+AAC格式主要分为两种： ADIF、ADTS。
+
+- ADIF：Audio Data Interchange Format。 音频数据交换格式
+    这种格式的特征是可以确定的找到这个音频数据的开始，不需进行在音频数据流中间开始的解码，即它的解码必须在明确定义的开始处进行。这种格式常用在磁盘文件中。
+    ADIF只有一个统一的头，所以必须得到所有的数据后解码。
+- ADTS: Audio Data Transport Stream。音频数据传输流
+    这种格式的特征是它是一个由同步字的比特流，解码可以在这个流中任何位置开始。
+    它的特征类似于mp3数据流格式。
+
+    ADTS可以在任意帧解码，它每一帧都有头信息。
+    ADIF只有一个统一的头，所以必须得到所有的数据后解码。
+且这两种的header的格式也是不同的，目前一般编码后的都是ADTS格式的音频流。 
diff --git "a/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/\351\237\263\351\242\221\347\274\226\347\240\201\346\240\274\345\274\217.md" "b/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/\351\237\263\351\242\221\347\274\226\347\240\201\346\240\274\345\274\217.md"
new file mode 100644
index 00000000..63e77d09
--- /dev/null
+++ "b/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/\351\237\263\351\242\221\347\274\226\347\240\201\346\240\274\345\274\217.md"
@@ -0,0 +1,36 @@
+## 音频编码格式
+
+音频压缩的本质： 消除冗余数据。
+
+人耳能察觉到的声音信号频率范围为20Hz ~ 20KHz，在这个频率范围以外的音频信号属于冗余信号。
+- 去除人耳听觉频率范围临界附近的值
+- 大声音附近如果有小的声音可以去除
+- 时域屏蔽效应
+- 高声附近50ms内如果声音比较小可以去掉
+- 无损压缩
+
+
+
+### WAV
+
+WAV编码是在PCM数据格式的前面加上44字节，分别用来描述PCM的采样率、声道数、数据根式等信息。
+特点： 音质非常好、大量软件都支持。
+使用场景：多媒体开发的中间文件、保存音乐和音效素材等。 
+
+### MP3
+MP3具有不错的压缩比，使用LAME编码的中高码率的MP3文件，听感上非常接近源WAV文件。
+特点：音质在128Kbps以上表现还不错，压缩比比较高，兼容性好。
+使用场景：高比特率下对兼容性有要求的音乐欣赏。
+
+### AAC
+AAC是新一代的有损压缩技术，它通过一些附加编码技术(如PS、SBR)等，衍生出LC-AAC、HE-AAC、HE-AAC V2三种主要编码格式。
+
+特点：在小于128kbps码率下表现优异，且多用于视频中的音频编码。
+使用场景：128Kbps码率下的音频编码，多用于视频中音频轨的编码。
+
+### Ogg
+
+Ogg编码音质好、完全免费。
+可以用更小的码率达到更好的音质，128Kbps的Ogg比192Kbps甚至更高的MP3还要出色。但是目前媒体软件支持上还不够友好。 
+特点：高中低码率下都有良好的表现，兼容性不够好，流媒体特性不支持。
+使用场景：语音聊天的音频消息场景。 

From 032bed128b75dca4863ef2f6f652aef0d8849630 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 25 May 2023 11:53:15 +0800
Subject: [PATCH 117/213] update

---
 ...73\347\273\237\347\256\200\344\273\213.md" |  76 +++++---------
 ...13\344\270\216\347\272\277\347\250\213.md" |   1 -
 VideoDevelopment/.DS_Store                    | Bin 8196 -> 8196 bytes
 ...72\347\241\200\347\237\245\350\257\206.md" |   1 +
 ...50\345\221\275\344\273\244\350\241\214.md" |  35 ++++++-
 VideoDevelopment/WebRTC.md                    |  63 ++++++++++++
 .../FLV.md"                                   |   3 +-
 .../H264.md"                                  |  97 ++++++++++++++++++
 ...26\347\240\201\345\216\237\347\220\206.md" |  54 ++++++++++
 .../AAC.md"                                   |  48 +++++++++
 10 files changed, 320 insertions(+), 58 deletions(-)
 create mode 100644 VideoDevelopment/WebRTC.md
 create mode 100644 "VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/\350\247\206\351\242\221\347\274\226\347\240\201\345\216\237\347\220\206.md"
 create mode 100644 "VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/AAC.md"

diff --git "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md" "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
index fa3aa962..52f42ab2 100644
--- "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
+++ "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
@@ -44,10 +44,9 @@
     - 进程，它是虚拟化的CPU；
     - 地址空间，它是虚拟化的内存。
 
-- 并发（concurrency）
-- 持久性（persistence）
-
-操作系统实际上做了什么：它取得CPU、内存或磁盘等物理资源（resources），并对它们进行虚拟化（virtualize）。它处理与并发（concurrency）有关的麻烦且棘手的问题。它持久地（persistently）存储文件，从而使它们长期安全
+- 并发（concurrency）     
+- 持久性（persistence）    
+    操作系统实际上做了什么：它取得CPU、内存或磁盘等物理资源（resources），并对它们进行虚拟化（virtualize）。它处理与并发（concurrency）有关的麻烦且棘手的问题。它持久地（persistently）存储文件，从而使它们长期安全
 
 操作系统也是一种软件，但是操作系统是一种非常复杂的软件。操作系统提供了几种抽象模型:    
 
@@ -57,20 +56,12 @@
 - 虚拟机：对整个操作系统的抽象
 
 
-
-
-
-
 ### 以现代标准而言，一个标准PC的操作系统应该提供以下功能
 
-
-
 ### 用户界面(User interface)
 
-
-
-普通用户操作电脑是需要用户界面的，没有用户界面的电脑对于普通用户来说就是灾难。你能想象家里的老人或者上了年纪的人用电脑却没有鼠标的场景吗？你能想象使用黑框框来做 PPT 吗？你能想象使用黑框框来浏览网页吗？
-专业的 IT 工作者有时候会使用黑框框纯粹是工作需要，在有些场景下，黑框框比用户界面更有效率一些。而类似于服务器场景的开发工作基本上是没有用户界面的，当然一直强调的是专业场景，这个世界上能流畅使用黑框框的人占总人口的比例太少太少。
+普通用户操作电脑是需要用户界面的，没有用户界面的电脑对于普通用户来说就是灾难。你能想象家里的老人或者上了年纪的人用电脑却没有鼠标的场景吗？你能想象使用黑框框来做 PPT 吗？你能想象使用黑框框来浏览网页吗？     
+专业的 IT 工作者有时候会使用黑框框纯粹是工作需要，在有些场景下，黑框框比用户界面更有效率一些。而类似于服务器场景的开发工作基本上是没有用户界面的，当然一直强调的是专业场景，这个世界上能流畅使用黑框框的人占总人口的比例太少太少。    
 用户界面这项伟大的发明诞生于施乐公司，经乔布斯和比尔盖茨商业化运作后得以让世人发现它的伟大之处。用户界面的发明就相当于简体汉字的出现一般，简体汉字的推行让中国的文盲率大幅降低，而用户界面的发明则大幅降低了计算机的使用难度，所以你很难想象现代的操作系统没有用户界面。
 
 
@@ -79,59 +70,50 @@
 
 
 
-先来解释一下什么是进程。进程是计算机进行资源管理以及调度的基本单位，是程序的执行实体。这种说法比较正统，或者你可以将一个进程看成是计算机正在进行的一项任务。计算机里面有很多各式各样功能的进程，那么多进程如何比较好的运行是个深奥的学问。
+先来解释一下什么是进程。进程是计算机进行资源管理以及调度的基本单位，是程序的执行实体。这种说法比较正统，或者你可以将一个进程看成是计算机正在进行的一项任务。计算机里面有很多各式各样功能的进程，那么多进程如何比较好的运行是个深奥的学问。    
 你可以想象一下：你打开了微信、word 文档、音乐软件，你想一边跟同事进行交流文档的内容应该如何写，一边在 word  文档敲下你的构思，然后在这个过程中你还听着音乐。在这个过程中，计算机需要将微信的网络保持连接，持续收发微信的信息，随时保存你的 word  文档到磁盘上，解码音乐流并播放出来。这一系列程序运转如何能让你产生一个假象：你以为它们是在同时运行的，但其实它们在同一时刻只有一个在运行。这就是进程管理和调度。
 
 
 
 #### 内存管理(Memory management)
 
-内存是计算机很重要的一个资源，因为程序只有被加载到内存中才可以运行，此外 CPU  所需要的指令与数据也都是来自内存的。内存的并不是无限制的，它受限于硬件和寻址位数。但是现代操作系统会让每一个进程都觉得自己在独占整个内存，这就是虚拟内存技术。值得注意的是，这里的虚拟内存与 swap 这种虚拟内存是不一样的，虽然两个都是称为虚拟内存，但是完全是两个不同方向的技术。
-进程的运行需要分配内存，内存分配的快慢都与内存管理方式有着巨大的影响。两个不同进程对应的内存区域是不能相互访问的，操作系统必须得提供这样的保证，否则很容易出问题，比如：运行着的 dota  游戏如果可以被另外一个进程访问它的内存区域的话，那就可以直接将内存区域中的某个数值进行修改，比如将游戏中的玩家生命值变为无限，这样对手怎么打都打不死自己的英雄。例如前段时间火热的吃鸡游戏，外挂软件可以让角色在决赛圈外进行锁血，这个就是游戏内存被修改的最好示例。当然这是通过比较专业的手段来绕过操作系统的限制，这也从另外一个方面来说明，其实现在的操作系统安全性也是有很大提升空间的。
+内存是计算机很重要的一个资源，因为程序只有被加载到内存中才可以运行，此外 CPU  所需要的指令与数据也都是来自内存的。内存的并不是无限制的，它受限于硬件和寻址位数。    
+但是现代操作系统会让每一个进程都觉得自己在独占整个内存，这就是虚拟内存技术。值得注意的是，这里的虚拟内存与 swap 这种虚拟内存是不一样的，虽然两个都是称为虚拟内存，但是完全是两个不同方向的技术。    
+进程的运行需要分配内存，内存分配的快慢都与内存管理方式有着巨大的影响。两个不同进程对应的内存区域是不能相互访问的，操作系统必须得提供这样的保证，否则很容易出问题，比如：运行着的 dota  游戏如果可以被另外一个进程访问它的内存区域的话，那就可以直接将内存区域中的某个数值进行修改，比如将游戏中的玩家生命值变为无限，这样对手怎么打都打不死自己的英雄。例如前段时间火热的吃鸡游戏，外挂软件可以让角色在决赛圈外进行锁血，这个就是游戏内存被修改的最好示例。当然这是通过比较专业的手段来绕过操作系统的限制，这也从另外一个方面来说明，其实现在的操作系统安全性也是有很大提升空间的。    
 进程退出销毁时，内存的回收也是很重要的，否则很容易就会产生内存溢出，占着茅坑不拉屎，导致其他的进程都憋死。
 
-
-
 #### 文件系统(File system)
 
-
-
-文件系统与用户的距离很近，每个人平常在使用计算机的时候或多或少都会留下一些数据，而这些数据通常会保留在磁盘里面。磁盘如果不进行格式化的话，普通人是没法使用的。磁盘里面其实就是一些布满磁性物质的盘片，在计算机的世界里数据是 0 和 1 组成的，那对应的在磁盘里面就是磁性的正负极，也就是说计算机的一个文本数据要保存到磁盘中，那就需要将文本数据的电气化信号 0 和 1 通过磁盘翻译为磁性正负极并保存起来。
+文件系统与用户的距离很近，每个人平常在使用计算机的时候或多或少都会留下一些数据，而这些数据通常会保留在磁盘里面。磁盘如果不进行格式化的话，普通人是没法使用的。磁盘里面其实就是一些布满磁性物质的盘片，在计算机的世界里数据是 0 和 1 组成的，那对应的在磁盘里面就是磁性的正负极，也就是说计算机的一个文本数据要保存到磁盘中，那就需要将文本数据的电气化信号 0 和 1 通过磁盘翻译为磁性正负极并保存起来。    
 磁盘格式化的过程就是将文件系统架设到磁盘上，这样可以更好的管理磁盘的数据。你可以将磁盘未格式化之前的数据看做是一堆杂乱无章散落在地上的书，而文件系统就是一个有编排顺序的书架，格式化的过程就是将这堆书一本本按编排顺序放到书架上。这个比喻不太恰当，因为格化式操作通常来说会清掉数据，就相当于将书里面的字都清掉了，放到书架上的书里面都是空白页，所以格式化的时候请谨慎。
 
-
-
 #### 网络通信(Networking)
 
-
-
-我们常见的网络通信场景有：微信聊天、浏览网页、玩网络游戏等，可以说现在的操作系统如果不能上网感觉就没了灵魂。网络通信是个很复杂的过程，连很多专业的程序猿都说不清楚当他上网时网页是如何显示出来的，更别说整个网络的拓扑结构了。
+我们常见的网络通信场景有：微信聊天、浏览网页、玩网络游戏等，可以说现在的操作系统如果不能上网感觉就没了灵魂。网络通信是个很复杂的过程，连很多专业的程序猿都说不清楚当他上网时网页是如何显示出来的，更别说整个网络的拓扑结构了。    
 整个网络通信其实是一套约定好的通信协议，很多人第一次听说协议时觉得很高级，其实没什么高级的，简单的说，类似于我们军训时当教官喊立正我们必须得做出相应动作一样，一个指令对应一个动作。由于网络太复杂了，某位哲人说过如果某样东西太复杂可以通过分层来解决，于是网络分了 5 层。有人也许会说是 7 层，那是 OSI 标准，在实际应用中一般都是 5 层。
 
 
 
 #### 设备管理
 
-
-
-计算机上有很多设备，比如CPU、内存、网卡、声卡、显卡、硬盘等。那什么是设备管理？
+计算机上有很多设备，比如CPU、内存、网卡、声卡、显卡、硬盘等。那什么是设备管理？    
 在计算机中除了 CPU 和内存，对于其他一切输入输出设备的管理统称为设备管理。
-计算机中的设备分为输入和输出设备。以 CPU 为中心，凡是向 CPU 输送数据的设备统称为输入设备，例如鼠标、键盘、摄像头等；同样以 CPU 为中心，凡是从 CPU 获取数据的设备统称为输出设备，如显示器等。有些设备既是输入设备也是输入设备，比如网卡等。 
+计算机中的设备分为输入和输出设备。以 CPU 为中心，凡是向 CPU 输送数据的设备统称为输入设备，例如鼠标、键盘、摄像头等；同样以 CPU 为中心，凡是从 CPU 获取数据的设备统称为输出设备，如显示器等。有些设备既是输入设备也是输入设备，比如网卡等。     
 一个比较常见的场景是当我们将 U盘插进电脑的 USB 插孔时，电脑能实时识别出 U 盘设备，那计算机为啥能实时识别出这些设备呢？之后会有章节讨论一下这个话题。
 
 ## 操作系统的基本特征
 
 并发和共享是操作系统的两个最基本的特征，它们又互为存在条件。一方面，资源共享是以程序（进程）的并发执行为条件的，若系统部允许程序并发执行，自然不存在资源共享问题。另一方面，若系统部能对资源共享实施有效管理，也必将影响程序的并发执行，甚至根本无法并发执行。
 
-
-
 ## 计算机的组成
 
 ### 计算机硬件
 
 计算机的硬件由大量的IC （Integrated Circuit，集成电路）组成。每块IC上都带有许多引脚。这些引脚有的用于输入，有的用于输出。
 
-从概念上讲，计算机的结构非常简单：首先布置一根总线，然后将各种硬件设备挂在总线上。所有的这些设备都有一个控制设备，外部设备都由这些控制器与CPU通信。而所有设备之间的通信均需通过总线，如果对总线做一个简单的概括，可以认为总线就是数字信号的集合，而这些信号被提供给计算机上的每块电路板： 
+从概念上讲，计算机的结构非常简单：    
+首先布置一根总线，然后将各种硬件设备挂在总线上。所有的这些设备都有一个控制设备，外部设备都由这些控制器与CPU通信。    
+而所有设备之间的通信均需通过总线，如果对总线做一个简单的概括，可以认为总线就是数字信号的集合，而这些信号被提供给计算机上的每块电路板： 
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/computer_hardware.jpg?raw=true)        
 
@@ -163,7 +145,11 @@
 
 ### 计算机打开电源后的执行
 
-在每台计算机上有一块双亲板（在政治因素影响到计算机产业之前，它们曾称为“母版”）。在双亲板上有一个称为基本输入输出系统（Basic Input Output System， BIOS）的程序。在BIOS内有底层I/O软件，包括读键盘、写屏幕、进行磁盘I/O以及其他过程。在计算机启动时，BIOS开始运行。它首先检查所安装的RAM数量、键盘和其他基本设备是否已安装并正常响应。接着，它开始扫描PCIe和PCI总线并找出连在上面的所有设备。即插即用设备也被记录下来。如果现有的设备和系统上一次启动时的设备不同，则新的设备将被配置。然后BIOS通过尝试存储在CMOS存储器中的设备清单决定启动设备。用户可以在系统刚启动之后进入一个BIOS配置程序，对设备清单进行修改。典型的，如果存在CD-ROM（有时是USB），则系统试图从中启动（之前重装系统就是这么操作的）。如果失败，系统将从硬盘启动。启动设备上的第一个扇区被读入内存并执行。这个扇区中包含一个对保存在启动扇区末尾的分区表检查的程序，以确定哪个分区是活动的。然后，从该分区读入第二个启动装载模块。来自活动分区的这个装载模块被读入操作系统，并启动之。 
+在每台计算机上有一块双亲板（在政治因素影响到计算机产业之前，它们曾称为“母版”）。    
+在双亲板上有一个称为基本输入输出系统（Basic Input Output System， BIOS）的程序。在BIOS内有底层I/O软件，包括读键盘、写屏幕、进行磁盘I/O以及其他过程。    
+在计算机启动时，BIOS开始运行。它首先检查所安装的RAM数量、键盘和其他基本设备是否已安装并正常响应。    
+接着，它开始扫描PCIe和PCI总线并找出连在上面的所有设备。即插即用设备也被记录下来。如果现有的设备和系统上一次启动时的设备不同，则新的设备将被配置。然后BIOS通过尝试存储在CMOS存储器中的设备清单决定启动设备。用户可以在系统刚启动之后进入一个BIOS配置程序，对设备清单进行修改。    
+典型的，如果存在CD-ROM（有时是USB），则系统试图从中启动（之前重装系统就是这么操作的）。如果失败，系统将从硬盘启动。启动设备上的第一个扇区被读入内存并执行。这个扇区中包含一个对保存在启动扇区末尾的分区表检查的程序，以确定哪个分区是活动的。然后，从该分区读入第二个启动装载模块。来自活动分区的这个装载模块被读入操作系统，并启动之。 
 
 然后，操作系统询问BIOS，以获得配置信息。对于每种设备，系统检查对应的设备驱动程序是否存在。如果没有，系统要求用户插入含有该驱动程序的CD-ROM（由设备供应商提供）或者从网络上下载驱动程序。一旦有了全部的设备驱动程序，操作系统就将它们调入内核。然后初始化有关表格，创建需要的任何背景进程，并在每个终端上启动登陆程序或GUI。
 
@@ -181,28 +167,12 @@
     - 用户程序的长度是多少？
     - 装载完用户程序后，应该跳转到哪里，即用户程序的执行入口在哪里？
 
-    理器在上电时自动把程序计数器设置为处理器厂商设计的某个固定值，对于ARM64处理器，这个固定值是0。处理器的内存管理单元（Memory Management Unit, MMU）负责把虚拟地址转换为物理地址，ARM64处理器刚上电的时候没有开启内存管理单元，物理地址和虚拟地址相同，所以ARM64处理器到物理地址0取第一条指令。嵌入式设备通常使用NOR闪存作为只读存储器来存放引导程序。NOR闪存的容量比较小，最小读写单位是字节，程序可以直接在芯片内执行。从物理地址0开始的一段物理地址空间被分配给NOR闪存。综上所述，ARM64处理器到虚拟地址0取指令，就是到物理地址0取指令，也就是到NOR闪存的起始位置取指令。
+    机器在上电时自动把程序计数器设置为处理器厂商设计的某个固定值，对于ARM64处理器，这个固定值是0。处理器的内存管理单元（Memory Management Unit, MMU）负责把虚拟地址转换为物理地址，ARM64处理器刚上电的时候没有开启内存管理单元，物理地址和虚拟地址相同，所以ARM64处理器到物理地址0取第一条指令。嵌入式设备通常使用NOR闪存作为只读存储器来存放引导程序。NOR闪存的容量比较小，最小读写单位是字节，程序可以直接在芯片内执行。从物理地址0开始的一段物理地址空间被分配给NOR闪存。综上所述，ARM64处理器到虚拟地址0取指令，就是到物理地址0取指令，也就是到NOR闪存的起始位置取指令。
     嵌入式设备通常使用U-Boot作为引导程序。U-Boot（Universal Boot Loader）是德国DENX软件工程中心开发的引导程序，是遵循GPL条款的开源项目。
     U-Boot分为SPL和正常的U-Boot程序两个部分，如果想要编译为SPL，需要开启配置宏CONFIG_SPL_BUILD。SPL是“Secondary Program Loader”的简称，即第二阶段程序加载器，第二阶段是相对于处理器里面的只读存储器中的固化程序来说的，处理器启动时最先执行的是只读存储器中的固化程序。固化程序通过检测启动方式来加载第二阶段程序加载器。为什么需要第二阶段程序加载器？原因是：一些处理器内部集成的静态随机访问存储器比较小，无法装载一个完整的U-Boot镜像，此时需要第二阶段程序加载器，它主要负责初始化内存和存储设备驱动，然后把正常的U-Boot镜像从存储设备读到内存中执行。
 
 
-- 操作系统内核初始化
-
-    执行内核程序，这一步所说的内核程序在上一步中指的就是”用户程序“。因为从CPU的角度来看，除了Bootloader之外的所有程序都是用户程序，只是从软件的角度来看，用户程序被分为”内核程序“和”应用程序“，而本步执行的是内核程序。
-
-    内核程序初始化时执行的操作包括，初始化各种硬件，包括内存、网络接口、显示器、输入设备、然后建立各种内部数据结构，这些数据结构将用于多线程调度及内存的管理等。当内核初始化完毕后就开始运行具体的应用程序了。在一般情况下，习惯于将第一个应用程序称为”Home程序“。
-
-- 执行第一个应用程序
-
-    运行Home程序，比如Windows系统的桌面。之所以称为Home程序，是因为通过该程序可以方便的启动其他应用程序。而传统的Linux系统启动后第一个运行的程序一般是一个Terminal。
-
-
-
-### Android系统启动过程
-
-目前的Android系统大多运行在ARM处理器之上。ARM本身是一个公司的名称，从技术的角度来看，它又是一种微处理器内核的架构。
-
-对于ARM处理器，当复位完毕后，处理器首先执行芯片上ROM中的一小块程序。这块ROM的大小一般只有几KB，该段程序就是Bootloader程序，这段程序执行时会根据处理器上一些特定引脚的高低电平状态，选择从何种物理接口上装载用户程序，比如USB口、SD卡、并口Flash等。
+- 操作系统内核初始化 执行内核程序，这一步所说的内核程序在上一步中指的就是”用户程序“。因为从CPU的角度来看，除了Bootloader之外的所有程序都是用户程序，只是从软件的角度来看，用户程序被分为”内核程序“和”应用程序“，而本步执行的是内核程序。 内核程序初始化时执行的操作包括，初始化各种硬件，包括内存、网络接口、显示器、输入设备、然后建立各种内部数据结构，这些数据结构将用于多线程调度及内存的管理等。当内核初始化完毕后就开始运行具体的应用程序了。在一般情况下，习惯于将第一个应用程序称为”Home程序“。 - 执行第一个应用程序 运行Home程序，比如Windows系统的桌面。之所以称为Home程序，是因为通过该程序可以方便的启动其他应用程序。而传统的Linux系统启动后第一个运行的程序一般是一个Terminal。 ### Android系统启动过程 目前的Android系统大多运行在ARM处理器之上。ARM本身是一个公司的名称，从技术的角度来看，它又是一种微处理器内核的架构。 对于ARM处理器，当复位完毕后，处理器首先执行芯片上ROM中的一小块程序。这块ROM的大小一般只有几KB，该段程序就是Bootloader程序，这段程序执行时会根据处理器上一些特定引脚的高低电平状态，选择从何种物理接口上装载用户程序，比如USB口、SD卡、并口Flash等。
 
 多数基于ARM的实际硬件系统，会从并口NAND Flash芯片上的0x00000000地址处装载程序。对于一些小型嵌入式系统而言，该地址中的程序就是最终要执行的用户程序；而对于Android而言，该地址中的程序还不是Android程序，而是一个叫做uboot或者fastboot的程序，其作用是初始化硬件设备，比如网口、SDRAM、RS232等，并提供一些调试功能，比如向NAND Flash中写入新的数据，这可用于开发过程中的内核烧写、升级等。
 
diff --git "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md" "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
index 6a10819b..99e31602 100644
--- "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
+++ "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
@@ -115,7 +115,6 @@
 ### 进程由哪几部分组成？
 
 进程是程序的一次运行过程，它是由程序段、数据段和进程控制块PCB组成的一个实体，其中：
-
 - 程序段：对应程序的操作代码部分，用于描述进程所需要完成的功能。
 - 数据段：对应程序执行时所需要的数据部分，包括数据，堆栈和工作区。
 - 进程控制块(Process Control Block, PCB) ：描述进程的基本信息和运行状态，记录了进程运行时所需要的全部信息，它是进程存在的唯一标识，与进程一一对应。所谓的创建进程和撤销进程，都是指对PCB的操作。
diff --git a/VideoDevelopment/.DS_Store b/VideoDevelopment/.DS_Store
index d444bf3996b5031376c5e5d08fc3074f41cdbc46..632c9571c556ec4c8a1e2ff3037bdc226591462c 100644
GIT binary patch
delta 244
zcmZp1XmOa}&nU4mU^hRb#AF_Ux$GuJItoTc7Lzv!L~y1QC+8&P=jSj^ek0&K`KNFx
zhnbN9P}<N4C~Yss#^45oxeNsisSN1|wa*3DvYQ&}C>R?WfRs(XC1ix5SA;d!F=~>3
zaIk;(I+#v|%}0dU7#SHRpB7ocVQOvyw8#W((d1pCj+6h1l%fi56Z^TDUE({-<mDpD
IBxw2u04X_5zW@LL

delta 220
zcmZp1XmOa}&nUVvU^hRb=wv}bnaLUgjgyawxJ`a9AURoAP@Qr6<Uo-^F7fJWQwwt)
z1q;i`7X_smJ14&rm1pdltR}RU-M~Oc!NlAYDDF5}TG#-g!Ngcc!N|}IS;J;&5jI9f
w#>q;eD<&Tmai1(G=7>;lYHR}3V2-SQGPn4ji475(*(JWSOb!t&B|%dt02X>g{{R30

diff --git "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
index dc4465f8..4dfbb7c1 100644
--- "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
+++ "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
@@ -100,6 +100,7 @@
 
     Presentation Time Stamp，主要用于度量解码后的视频帧什么时候被显示出来。
 
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/gop_dts_pts.jpg)
 
 
 音视频压缩编码标准
diff --git "a/VideoDevelopment/FFmpeg/2.FFmpeg\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214.md" "b/VideoDevelopment/FFmpeg/2.FFmpeg\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214.md"
index 4b0fe7aa..a00c00c4 100644
--- "a/VideoDevelopment/FFmpeg/2.FFmpeg\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214.md"
+++ "b/VideoDevelopment/FFmpeg/2.FFmpeg\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214.md"
@@ -490,9 +490,38 @@ stream字段说明：
 
 
 
-
-
-
+##### overlay 技术简介
+overlay 技术又称视频叠加技术。overlay 视频技术使用非常广泛，常见的例子有，电视
+屏幕右上角显示的电视台台标，以及画中画功能。
+画中画是指在一个大的视频播放窗口中还存在一个小播放窗口，两个窗口不同的视频内
+容同时播放。
+overlay 技术中涉及两个窗口，通常把较大的窗口称作背景窗口，较小的窗口称作前景
+窗口，背景窗口或前景窗口里都可以播放视频或显示图片。
+FFmpeg 中使用overlay 滤镜可实现视频叠加效果。
+overlay 滤镜说明如下：
+描述：前景窗口(第二输入)覆盖在背景窗口(第一输入)的指定位置。
+
+
+
+语法：overlay[=x:y[[:rgb={0, 1}]]
+参数x 和y 是可选的，默认为0。
+参数rgb 参数也是可选的，其值为0 或1，默认为0。
+参数说明：
+x 从左上角的水平坐标，默认值为0
+y 从左上角的垂直坐标，默认值为0
+rgb 值为0 表示输入颜色空间不改变，默认为0；值为1 表示将输
+入的颜色空间设置为RGB
+变量说明：如下变量可用在x 和y 的表达式中
+main_w 或W 主输入(背景窗口)宽度
+main_h 或H 主输入(背景窗口)高度
+overlay_w 或w overlay 输入(前景窗口)宽度
+overlay_h 或h overlay 输入(前景窗口)高度
+//中间
+ffmpeg -i ande_302.mp4 -vf "movie=logo.png[logo]; [in][logo]overlay=W/2-w/2:H/2-h/2[out]"
+-vcodec libx264 -acodec aac zzoutput8.mp4
+//右下角
+ffmpeg -i ande_302.mp4 -vf "movie=logo.png[logo]; [in][logo]overlay=W-w:H-h[out]" -vcodec
+libx264 -acodec aac zzoutput7.mp4
 
 
 ---
diff --git a/VideoDevelopment/WebRTC.md b/VideoDevelopment/WebRTC.md
new file mode 100644
index 00000000..12487397
--- /dev/null
+++ b/VideoDevelopment/WebRTC.md
@@ -0,0 +1,63 @@
+WebRTC
+===
+
+WebRTC，名称源自网页实时通信（Web Real-Time Communication）的缩写，是一个支
+持网页浏览器进行实时语音通话或视频聊天的技术，是谷歌2010 年以6820 万美元收购
+Global IP Solutions 公司而获得的一项技术。
+WebRTC 提供了实时音视频的核心技术，包括音视频的采集、编解码、网络传输、显示
+等功能，并且还支持跨平台：windows，linux，mac，android。
+虽然WebRTC 的目标是实现跨平台的Web 端实时音视频通讯，但因为核心层代码的
+Native、高品质和内聚性，开发者很容易进行除Web 平台外的移殖和应用。很长一段时间内
+WebRTC 是业界能免费得到的唯一高品质实时音视频通讯技术。
+
+WebRTC 是一项在浏览器内部进行实时视频和音频通信的技术，是谷歌于2010 年以
+wwwwww..hheelllloottoonnggttoonngg..ccoom ©®
+6820 万美元收购VoIP 软件开发商Global IT Solutions 公司而获得一项技术，谷歌于2011 年
+6 月3 日开源该项目。
+谷歌在官方博客中称：“我们希望让浏览器成为实时通信的创新地所在，到目前为止，
+实时通信需要使用受版权保护的信号处理技术，并通过插件或下载客户端才能实现，而
+WebRTC 则允许开发人员使用HTML 和JavaScript API 来创建实时应用。”
+
+
+1.webrtc 是什么
+浏览器为音视频获取传输提供的接口
+2.webrtc 可以做什么
+浏览器端到端的进行音视频聊天、直播、内容传输
+3.数据传输需要些什么
+IP、端口、协议
+客户端、服务端
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/webrtc_artic_1.png?raw=true)
+1.绿色部分是WebRTC 核心部分（核心库）
+2.紫色部分是JS 提供的API（应用层）
+整体是应用层调用核心层。
+核心层，第一层C++ API
+提供给外面的接口。最主要的是(PeerConnedtion 对等连接）。
+核心层，第二层Session
+
+上下文管理层（音视频）。
+核心层，第三层[最重要的部分]
+音视频引擎：编解码;音频缓冲BUFFER 防止音频网络抖动NetEQ;回音消除;降噪；静音检
+测；
+视频引擎：编解码；jitter buffer 防止视频网络抖动；图像处理增强；
+传输：SRTP 加密后的RTP；多路复用；P2P（STUN+TURN+ICE)
+核心层，第四层,硬件相关层
+音视频采集; 网络IO
+
+
+WebRTC 实现了基于网页的视频会议，标准是WHATWG 协议，目的是通过浏览器提供
+简单的javascript 就可以达到实时通讯（Real-Time Communications (RTC)）能力。
+WebRTC（Web Real-Time Communication）项目的最终目的主要是让Web 开发者能够基
+于浏览器（Chrome/FireFox/...）轻易快捷开发出丰富的实时多媒体应用，而无需下载安装任
+何插件，Web 开发者也无需关注多媒体的数字信号处理过程，只需编写简单的Javascript 程
+序即可实现，W3C 等组织正在制定Javascript 标准API，目前是WebRTC 1.0 版本，Draft 状
+态；另外WebRTC 还希望能够建立一个多互联网浏览器间健壮的实时通信的平台，形成开发
+者与浏览器厂商良好的生态环境。同时，Google 也希望和致力于让WebRTC 的技术成为
+HTML5 标准之一，可见Google 布局之深远。
+WebRTC 提供了视频会议的核心技术，包括音视频的采集、编解码、网络传输、显示等
+功能，并且还支持跨平台：windows，linux，mac，android。
+
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/FLV.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/FLV.md"
index 0eae8fdf..507a0aad 100644
--- "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/FLV.md"
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/FLV.md"
@@ -3,7 +3,7 @@ FLV
 
 在网络的直播与点播场景中，FLV也是一种常见的格式，FLV是Adobe发布的一种可以作为直播也可以作为点播的封装格式，其封装格式非常简单，均以FLVTAG的形式存在，并且每一个TAG都是独立存在的.
 
-FLV封装格式是由一个文件头（FLV header）和很多tag组成的（FLV body）二进制文件。
+FLV封装格式是由一个文件头（FLV header， 9字节）和很多tag组成的（FLV body）二进制文件。
 Tag中包含了音频数据以及视频数据，每个Tag又有一个preTagSize字段，标记着前面一个Tag的大小，FLV的结构如下图所示。
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/flv_tag.jpg?raw=true)
@@ -91,6 +91,7 @@ Script Tag通常被称为Metadata Tag，会放一些关于FLV视频和音频的
 可以使用FFmpeg中的ffprobe来解析FLV文件，并且其还能够将关键帧索引的相关信息打印出来： 
 `ffprobe -v trace -i output.flv`
 
+[FLV分析工具: FlV Analyzer](http://flv-viewer.softwar.io/)
 
 参考: 
 
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/H264.md" "b/VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/H264.md"
index 45aa49ec..66c7f6b6 100644
--- "a/VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/H264.md"
+++ "b/VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/H264.md"
@@ -94,6 +94,103 @@ H.264是一种高性能的视频编解码技术。目前国际上制定视频编
  目前，H.264已被广泛应用于实时视频应用中，相比以往的方案使得在同等速率下，H.264能够比H.263减小50%的码率。也就是说，用户即使是只利用 384kbit/s的带宽，就可以享受H.263下高达 768kbit/s的高质量视频服务。H.264  不但有助于节省庞大开支，还可以提高资源的使用效率，同时令达到商业质量的实时视频服务拥有更多的潜在客户。
 
 
+H264 结构中，一个视频图像编码后的数据叫做一帧，一帧由一个片（slice）或多个片组成，一个片由一个或多个宏块（MB）组成，一个宏块由16x16 的yuv数据组成。宏块作为H264 编码的基本单位。
+
+
+在H264 协议内定义了三种帧，分别是I 帧、B 帧与P 帧: 
+- I 帧就是之前所说的一个完整的图像帧，而B、帧与P 帧所对应的就是之前说
+的不编码全部图像的帧。
+- P 帧与B 帧的差别就是P 帧是参考之前的I 帧而生成的，而B 帧是参考前后图
+像帧编码生成的。
+
+#### GOP(画面组，图像组)
+GOP 我个人也理解为跟序列差不多意思，就是一段时间内变化不大的图像集。
+GOP 结构一般有两个数字，如M=3，N=12。
+M 指定I 帧和P 帧之间的距离，N 指定两个I 帧之间的距离。上面的M=3，N=12，GOP 结构为：IBBPBBPBBPBBI。在一个GOP 内I frame 解码不依赖任何的其它帧，p frame 解码则依赖前面的I frame 或P frame，B frame 解码依赖前最近的一个I frame 或P frame 及其后最近的一个P frame。
+#### IDR 帧(关键帧)
+在编码解码中为了方便，将GOP 中首个I 帧要和其他I 帧区别开，把第一个I 帧叫IDR，这样方便控制编码和解码流程，所以IDR 帧一定是I 帧，但I 帧不一定是IDR 帧；IDR 帧的作用是立刻刷新,使错误不致传播,从IDR 帧开始算新的序列开始编码。I 帧有被跨帧参考的可能,IDR 不会。I 帧不用参考任何帧，但是之后的P 帧和B 帧是有可能参考这个I 帧之前的帧的。
+IDR 就不允许这样，例如：
+IDR1 P4 B2 B3 P7 B5 B6 I10 B8 B9 P13 B11 B12 P16 B14 B15
+这里的B8 可以跨过I10 去参考P7
+------------------------------------------------------------------------
+IDR1 P4 B2 B3 P7 B5 B6 IDR8 P11 B9 B10 P14 B11 B12
+这里的B9 就只能参照IDR8 和P11，不可以参考IDR8 前面的帧
+
+
+H.264 引入IDR 图像是为了解码的重同步，当解码器解码到IDR 图像时，立即将参考帧队列清空，将已解码的数据全部输出或抛弃，重新查找参数集，开始一个新的序列。这样，如果前一个序列出现重大错误，在这里可以获得重新同步的机会。IDR 图像之后的图像永远不会使用IDR 之前的图像的数据来解码。
+
+
+###### 压缩方式说明
+
+- Step1：分组，也就是将一系列变换不大的图像归为一个组，也就是一个序列，也可以叫GOP（画面组）；
+- Step2：定义帧，将每组的图像帧归分为I 帧、P 帧和B 帧三种类型；
+- Step3：预测帧， 以I 帧做为基础帧,以I 帧预测P 帧,再由I 帧和P 帧预测B 帧;
+- Step4：数据传输， 最后将I 帧数据与预测的差值信息进行存储和传输。
+
+
+H264 的主要目标是为了有高的视频压缩比和良好的网络亲和性，为了达成这两个目标，H264的解决方案是将系统框架分为两个层面，分别是视频编码层面（VCL）和网络抽象层面（NAL），
+
+
+
+### VCL NAL
+视频编码中采用的如预测编码、变化量化、熵编码等编码工具主要工作在slice层或以下，这一层通常被称为视频编码层(Video Coding Layer, VCL)。
+
+VCL层是对核心算法引擎、块、宏块及片的语法级别的定义，负责有效展示视频数据的内容，最终输出编码完的数据SODB。
+
+相对的，在slice以上所进行的数据和算法通常称之为网络抽象层(Network Abstraction Layer, NAL)。
+NAL层定义了片级以上的语法级别(如序列参数集和图像参数集，针对网络传输)，负责以网络所要求的恰当方式去格式化数据并提供头信息，以保证数据适合各种信道和存储介质熵的传输。NAL层将SODB打包成RBSP，然后加上NAL头组成一个NALU单元。
+
+
+SODB：数据比特串，是编码后的原始数据。
+RBSP：原始字节序列载荷，是在原始编码数据后面添加了结尾比特，一个bit 1和若干个比特 0,用于字节对齐. 
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/sodb_rbsp.jpg?raw=true)
+设计定义NAL层的主要意义在于提升H.264格式的视频对网络传输和数据存储的亲和性。
+
+
+
+##### SODB RBSP EBSP 的区别
+- SODB（String of Data Bits，数据比特串）：最原始，未经过处理的编码数据
+- RBSP（Raw Byte Sequence Payload，原始字节序列载荷）：在SODB 的后面填加了结尾bit（RBSP trailing bits 一个bit ‘1’）若干bit ‘0’，以便字节对齐。
+- EBSP（Encapsulated Byte Sequence Payload, 扩展字节序列载荷）：NALU 的起始码为0x000001 或0x00000001（起始码包括两种：3 字节(0x000001)和4 字节(0x00000001)，在SPS、PPS 和Access Unit 的第一个NALU 使用4 字节起始码，其余情况均使用3 字节起始码。）
+
+#### h264码流结构
+
+在经过编码后的H264码流是由一个个的NAL单元组成，其中SPS、PPS、IDR和SLICE是NAL单元某一类型的数据，如下：  
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/h264_stream_struc_1.jpg?raw=true)
+
+#### H264 的NAL 结构
+
+在实际的网络数据传输过程中H264 的数据结构是以NALU（NAL 单元）进行传输的，
+传输数据结构组成为[NALU Header]+[RBSP]，如下图所示：
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/nalu_1.jpg?raw=true)
+
+VCL 层编码后的视频帧数据，帧有可能是I/B/P 帧，这些帧也可能是属于不同的序列之中；
+同一序列也还有相应的序列参数集与图片参数集；
+综上所述，想要完成准确无误视频的解码，除了需要VCL 层编码出来的视频帧数据，同时还需要传输序列参数集和图像参数集等等，所以RBSP不单纯只保存I/B/P 帧的数据编码信息，还有其他信息也可能出现在里面。
+上面知道NAL 单元是作为实际视频数据传输的基本单元，NALU 头是用来标识后面RBSP 是什么类型的数据，同时记录RBSP 数据是否会被其他帧参考以及网络传输是否有错误，
+
+
+###### NAL 头
+NAL 单元的头部是由forbidden_bit(1bit)，nal_reference_bit(2bits)（优先级），
+nal_unit_type(5bits)（类型）三个部分组成的，组成如图6 所示：
+1、F(forbiden):禁止位，占用NAL 头的第一个位，当禁止位值为1 时表示语法错误；
+2、NRI:参考级别，占用NAL 头的第二到第三个位；值越大，该NAL 越重要。
+3、Type:Nal 单元数据类型，也就是标识该NAL 单元的数据类型是哪种，占用NAL 头的第
+四到第8 个位；
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/nal_tou_1.jpg?raw=true)
+
+
+
+##### h264的结构图
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/h264_stream_stru_2.jpg?raw=true)
+
+码流分析工具： elecard streameye
+
+
+
+
 
 ---
 
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/\350\247\206\351\242\221\347\274\226\347\240\201\345\216\237\347\220\206.md" "b/VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/\350\247\206\351\242\221\347\274\226\347\240\201\345\216\237\347\220\206.md"
new file mode 100644
index 00000000..94a27e30
--- /dev/null
+++ "b/VideoDevelopment/\350\247\206\351\242\221\347\274\226\347\240\201/\350\247\206\351\242\221\347\274\226\347\240\201\345\216\237\347\220\206.md"
@@ -0,0 +1,54 @@
+## 视频编码原理
+
+
+为什么巨大的原始视频可以编码成很小的视频呢？这其中的技术是什么呢？
+核心思想就是去除冗余信息： 
+- 空间冗余： 图像相邻像素之间有较强的相关性
+- 时间冗余：视频序列的相邻图像之间内容相似
+- 编码冗余：不同像素值出现的概率不同
+- 视觉冗余：人的视觉系统对某些细节不敏感
+- 知识冗余：规律性的结构可由先验知识和背景知识得到
+
+视频本质上讲是一系列图片连续快速的播放，最简单的压缩方式就是对每一帧图片进行压缩，例如比较古老的MJPEG编码就是这种编码方式，这种编码方式只是帧内编码，利用空间上的取样预测来编码。
+但是帧与帧之间因为时间的相关性，后续开发出了一些比较高级的编码器可以采用帧间编码，简单点说就是通过搜索算法选定了帧上的某些区域，然后通过计算当前帧和前后参考帧的向量差进行编码的一种形式，例如一个人滑雪，前后两帧画面的差异就是人的位置移动了。 
+### 编码器中的关键技术
+- 预测: 预测编码可以用于处理视频中的时间和空间域的冗余，主要分为两大类：帧内预测和帧间预测。
+    - 帧内预测： 预测值与实际值位于同一帧内，用于消除图像的空间冗余。帧内预测的特点是压缩率相对较低，然而可以独立解码，不依赖其他帧的数据。通常视频中的关键帧都采用帧内预测。
+    - 帧间预测： 帧间预测的实际值位于当前帧，预测值位于参考帧，用于消除图像的时间冗余。帧间预测的压缩率高于帧内预测，然而不能独立解码，必须在获取参考帧数据之后才能重建当前帧。
+    通常在视频码流中，I帧全部使用帧内编码，P帧、B帧中的数据可能使用帧内或帧间编码。
+- 变换: 变化编码是指将给定的图像变换到另一个数据域如频域上，使得大量的信息能用较少的数据来表示，从而达到压缩的目的。目前主流的视频编码算法均属于有损编码，通过对视频造成有限而可以容忍的损失，获取相对更高的编码效率。而造成信息损失的部分即在于变换量化这一部分。在进行量化之前，首先需要将图像信息从空间域通过变换编码变换至频域，并计算其变换系数供后续的编码。
+- 量化
+- 熵编码: 视频编码中的熵编码方法主要用于消除视频信息中的统计冗余。由于信源中每一个符号的出现概率并不一致，这就导致使用同样长度的码字表示所有的符号会造成浪费。通过熵编码，针对不同的语法元素分配不同长度的码元，可以有效消除视频信息中由于符号概率导致的冗余。 
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/encode_decode_1.jpg?raw=true)
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/frame_inter_1.jpg?raw=true)
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/rongyu_kongjian_shijian_1.jpg?raw=true)
+
+- 对I帧的处理，是采用帧内编码方式，只利用本帧图像内的空间相关性。
+    帧内编码虽然只有空间相关性，但整个编码过程并不简单，主要如下： 
+    ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/frame_inter_2.jpg?raw=true)
+    - RGB转YUV:固定公式
+    - 图片宏块切割：宏块16*16
+    - DCT：离散余弦变换
+    - 量化：取样
+    - ZigZag：扫描
+    - DPCM：差值脉冲编码调制
+    - RLE：游程编码
+    - 霍夫曼编码
+    - 算数编码
+- 对P帧的处理，采用帧间编码(前向运动估计)，同时利用空间和时间上的相关性。
+简单来说，采用运动补偿(motion compensation)算法来去掉冗余信息。
+
+##### 编解码中的关键流程
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/encode_decode_1.jpg?raw=true)
+
+
+
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/AAC.md" "b/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/AAC.md"
new file mode 100644
index 00000000..58f79f82
--- /dev/null
+++ "b/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/AAC.md"
@@ -0,0 +1,48 @@
+## AAC
+
+AAC 是高级音频编码（Advanced Audio Coding）的缩写，出现于1997 年，最
+初是基于MPEG-2 的音频编码技术，目的是取代MP3 格式。2000 年，MPEG-4
+标准出台，AAC 重新集成了其它技术（PS,SBR），为区别于传统的MPEG-2 AAC，
+故含有SBR 或PS 特性的AAC 又称为MPEG-4 AAC。
+AAC 是新一代的音频有损压缩技术，它通过一些附加的编码技术（比如PS,SBR
+等），衍生出了LC-AAC,HE-AAC,HE-AACv2 三种主要的编码。其中LC-AAC 就是比
+较传统的AAC，相对而言，主要用于中高码率(>=80Kbps)，HE-AAC(相当于AAC+SBR)
+主要用于中低码(<=80Kbps)，而新近推出的HE-AACv2(相当于AAC+SBR+PS)主要用
+于低码率(<=48Kbps）。事实上大部分编码器设成<=48Kbps 自动启用PS 技术，
+而>48Kbps 就不加PS，就相当于普通的HE-AAC。
+
+#### AAC编码特点
+(1). AAC 是一种高压缩比的音频压缩算法，但它的压缩比要远超过较老的音频压
+缩算法，如AC-3、MP3 等。并且其质量可以同未压缩的CD 音质相媲美。
+(2). 同其他类似的音频编码算法一样，AAC 也是采用了变换编码算法，但AAC
+使用了分辨率更高的滤波器组，因此它可以达到更高的压缩比。
+(3). AAC 使用了临时噪声重整、后向自适应线性预测、联合立体声技术和量化哈
+夫曼编码等最新技术，这些新技术的使用都使压缩比得到进一步的提高。
+(4). AAC 支持更多种采样率和比特率、支持1 个到48 个音轨、支持多达15 个低
+频音轨、具有多种语言的兼容能力、还有多达15 个内嵌数据流。
+(5). AAC 支持更宽的声音频率范围，最高可达到96kHz，最低可达8KHz，远宽于
+MP3 的16KHz-48kHz 的范围。
+(6). 不同于MP3 及WMA，AAC 几乎不损失声音频率中的甚高、甚低频率成分，
+并且比WMA 在频谱结构上更接近于原始音频，因而声音的保真度更好。专业评
+测中表明，AAC 比WMA 声音更清晰，而且更接近原音。
+(7). AAC 采用优化的算法达到了更高的解码效率，解码时只需较少的处理能力。
+
+
+#### AAC 音频文件格式
+
+AAC 的音频文件格式有：ADIF， ADTS
+- ADIF：Audio Data Interchange Format 音频数据交换格式。这种格式的特征是
+可以确定的找到这个音频数据的开始，不需进行在音频数据流中间开始的解码，
+即它的解码必须在明确定义的开始处进行。故这种格式常用在磁盘文件中。
+- ADTS：Audio Data Transport Stream 音频数据传输流。这种格式的特征是它是
+一个有同步字的比特流，解码可以在这个流中任何位置开始。它的特征类似于
+mp3 数据流格式。
+
+
+简单说，ADTS 可以在任意帧解码，也就是说它每一帧都有头信息。ADIF 只有一个统一的头，所以必须得到所有的数据后解码。这两种的header 的格式也是
+不同的，一般编码后的和抽取出的都是ADTS 格式的音频流。
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/AAC_ADIF_ADTS_1.jpg?raw=true)
+
+

From 3770c74c57db6d9c91dade79e670f9c0f3dfb99e Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 25 May 2023 11:59:52 +0800
Subject: [PATCH 118/213] update

---
 ...42\221\345\237\272\347\241\200\347\237\245\350\257\206.md" | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
index 4dfbb7c1..b6a15a82 100644
--- "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
+++ "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
@@ -370,8 +370,10 @@ PAR DAR SAR
 
 [常见流媒体协议](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E6%B5%81%E5%AA%92%E4%BD%93%E5%8D%8F%E8%AE%AE/%E6%B5%81%E5%AA%92%E4%BD%93%E9%80%9A%E4%BF%A1%E5%8D%8F%E8%AE%AE.md)
 
+##### 硬件加速
 
-
+硬件加速(Hardware acceleration)就是利用硬件模块来替代软件算法以充分利用硬件固有的快速特性。硬件加速通常比软件算法的效率要高。
+将2D、3D图形计算相关工作交给GPU处理，从而释放CPU的压力，也是属于硬件加速的一种。
 
 
 

From e97ed7b4a6f9454d8b1fdcc43ab4e5c535904d36 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 25 May 2023 12:52:24 +0800
Subject: [PATCH 119/213] update OS part

---
 ...13\344\270\216\347\272\277\347\250\213.md" | 20 +++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md" "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
index 99e31602..355f1329 100644
--- "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
+++ "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
@@ -228,7 +228,8 @@
 
     人们最常使用的通信手段就是对白。对白的特点就是一方发出声音，另一方接收声音。而声音的传递则通过空气（当面或无线交谈）、线缆（有线电话）进行传递。类似，进程对白就是一个进程发出某种数据信息，另外一方接收数据信息，而这些数据信息通过一片共享的存储空间进行传递。在这种方式下，一个进程向这片存储空间的一端写入信息，另一个进程从存储空间的另外一端读取信息。这看上去像什么？管道。管道所占的空间既可以是内存，也可以是磁盘。就像两人对白的媒介可以是空气，也可以是线缆一样。要创建一个管道，一个进程只需调用管道创建的系统调用即可。该系统调用所做的事情就是在某种存储介质上划出一片空间，赋给其中一个进程写的权利，另一个进程读的权利即可。
 
-    从根本上说，管道是一个线性字节数组，类似文件，可以使用文件读写的方式进行访问。但却不是文件。因为通过文件系统看不到管道的存在。另外，我们前面说了，管道可以设在内存里，而文件很少设在内存里
+    从根本上说，管道是一个线性字节数组(实为内核缓冲区)，是一种伪文件的方式，类似文件，可以使用文件读写的方式进行访问。但却不是文件。因为通过文件系统看不到管道的存在。另外，我们前面说了，管道可以设在内存里，而文件很少设在内存里。
+管道的原理：管道实为内核使用环形队列机制，借助内核缓冲区(4k)实现。
 
     在两个进程之间，可以建立一个通道，一个进程向这个通道里写入字节流，另一个进程从这个管道中读取字节流。管道是同步的，当进程尝试从空管道读取数据时，该进程会被阻塞，直到有可用数据为止。发送进程以字符流形式将大量数据送入管道，接收进程可从管道接收数据，二者利用管道进行通信，管道是单向的、先进先出的，它把一个进程的输出和另一个进程的输入连接在一起。一个进程（写进程）在管道的尾部写入数据，另一个进程（读进程）从管道的头部读出数据。每次只有一个进程能够真正地进入管道，其他的只能等待。
 
@@ -238,7 +239,22 @@
 
     入先出队列 FIFO 通常被称为 `命名管道(Named Pipes)`，命名管道的工作方式与常规管道非常相似，但是确实有一些明显的区别。未命名的管道没有备份文件：操作系统负责维护内存中的缓冲区，用来将字节从写入器传输到读取器。一旦写入或者输出终止的话，缓冲区将被回收，传输的数据会丢失。相比之下，命名管道具有支持文件和独特 API ，命名管道在文件系统中作为设备的专用文件存在。当所有的进程通信完成后，命名管道将保留在文件系统中以备后用。命名管道具有严格的 FIFO 行为，写入的第一个字节是读取的第一个字节，写入的第二个字节是读取的第二个字节，依此类推。
 
-    
+   管道的局限性： 
+    - 数据自己读不能自己写
+    - 数据一旦被读走，便不在管道中存在，不可反复读取。
+    - 由于管道采用半双工通信(数据只能一个方向写，另一个方向读)方式。因此，数据只能在一个方向上流动。
+    - 只能在有公共祖先的进程间使用管道。
+
+linux创建管道: 
+```c
+int fd[2];
+int ret = pipe(fd);
+if (ret == -1) {
+    perror("pip error");
+    exit(1);
+}
+
+```
 
 - Socket套接字
 

From 836247beccf934d48d9f1be1eb807534d1817661 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 25 May 2023 13:09:25 +0800
Subject: [PATCH 120/213] update OS part

---
 ...13\344\270\216\347\272\277\347\250\213.md" | 84 ++++++++++++++++++-
 1 file changed, 80 insertions(+), 4 deletions(-)

diff --git "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md" "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
index 355f1329..c4ebb267 100644
--- "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
+++ "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
@@ -245,17 +245,68 @@
     - 由于管道采用半双工通信(数据只能一个方向写，另一个方向读)方式。因此，数据只能在一个方向上流动。
     - 只能在有公共祖先的进程间使用管道。
 
+
+创建管道: 
+```c: 
+    int pipe(int pipefd[2]);           成功：0；失败：-1，设置errno
+```
+
+函数调用成功返回r/w两个文件描述符。无需open，但需手动close。规定：fd[0] → r； fd[1] → w，就像0对应标准输入，1对应标准输出一样。向管道文件读写数据其实是在读写内核缓冲区。
+管道创建成功以后，创建该管道的进程（父进程）同时掌握着管道的读端和写端。 
+1. 父进程调用pipe函数创建管道，得到两个文件描述符fd[0]、fd[1]指向管道的读端和写端。
+2. 父进程调用fork创建子进程，那么子进程也有两个文件描述符指向同一管道。
+3. 父进程关闭管道读端，子进程关闭管道写端。父进程可以向管道中写入数据，子进程将管道中的数据读出。由于管道是利用环形队列实现的，数据从写端流入管道，从读端流出，这样就实现了进程间通信。
+
 linux创建管道: 
 ```c
-int fd[2];
-int ret = pipe(fd);
-if (ret == -1) {
-    perror("pip error");
+#include <unistd.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/wait.h>
+
+void sys_err(const char *str)
+{
+    perror(str);
     exit(1);
 }
 
+int main(void)
+{
+    pid_t pid;
+    char buf[1024];
+    int fd[2];
+    char *p = "test for pipe\n";
+    
+   if (pipe(fd) == -1) 
+       sys_err("pipe");
+
+   pid = fork();
+   if (pid < 0) {
+       sys_err("fork err");
+   } else if (pid == 0) {
+        close(fd[1]);
+        int len = read(fd[0], buf, sizeof(buf));
+        write(STDOUT_FILENO, buf, len);
+        close(fd[0]);
+   } else {
+       close(fd[0]);
+       write(fd[1], p, strlen(p));
+       wait(NULL);
+       close(fd[1]);
+   }
+    
+    return 0;
+}
 ```
 
+
+管道的优劣
+       优点：简单，相比信号，套接字实现进程间通信，简单很多。
+       缺点：1. 只能单向通信，双向通信需建立两个管道。
+             2. 只能用于父子、兄弟进程(有共同祖先)间通信。该问题后来使用fifo有名管道解决。
+
+
 - Socket套接字
 
     套接字的功能非常强大，可以支持不同层面、不同应用、跨网络的通信。使用套接字进行通信需要双方均创建一个套接字，其中一方作为服务器方，另外一方作为客户方。服务器方必须先创建一个服务区套接字，然后在该套接字上进行监听，等待远方的连接请求。欲与服务器通信的客户则创建一个客户套接字，然后向服务区套接字发送连接请求。服务器套接字在收到连接请求后，将在服务器方机器上创建一个客户套接字，与远方的客户机上的客户套接字形成点到点的通信通道。之后，客户方和服务器方就可以通过send和recv命令在这个创建的套接字通道上进行交流了。
@@ -288,6 +339,31 @@ if (ret == -1) {
 
     共享内存是进程通信中最快的一种方法，因为数据不需要在进程间复制，而可以直接映射到各个进程的地址空间中。在共享内存中要注意的一个问题是：当多个进程对共享内存区域进行访问时，要注意这些进程之间的同步问题。例如，如果server正在向共享内存区域中写数据，那么client进程就不能访问这些数据，直到server全部写完之后，client才可以访问。为了实现进程间的同步问题，通常使用前面介绍过的信号量来实现这一目标。一个共享内存段可以由一个进程创建，然后由任意共享这一内存段的进程对它进行读写。当进程间需要通信时，一个进程可以创建一个共享内存段，然后需要通信的各个进程就可以在信号量的控制下保持同步，在这里交换数据，完成通信。
 
+
+- FIFO
+
+FIFO 
+FIFO常被称为命名管道，以区分管道(pipe)。管道(pipe)只能用于“有血缘关系”的进程间。但通过FIFO，不相关的进程也能交换数据。
+       FIFO是Linux基础文件类型中的一种。但，FIFO文件在磁盘上没有数据块，仅仅用来标识内核中一条通道。各进程可以打开这个文件进行read/write，实际上是在读写内核通道，这样就实现了进程间通信。
+创建方式：
+1. 命令：mkfifo 管道名
+       2. 库函数：int mkfifo(const char *pathname,  mode_t mode);  成功：0； 失败：-1
+       一旦使用mkfifo创建了一个FIFO，就可以使用open打开它，常见的文件I/O函数都可用于fifo。如：close、read、write、unlink等。
+
+
+- 存储映射I/O 
+       存储映射I/O (Memory-mapped I/O) 使一个磁盘文件与存储空间中的一个缓冲区相映射。于是当从缓冲区中取数据，就相当于读文件中的相应字节。于此类似，将数据存入缓冲区，则相应的字节就自动写入文件。这样，就可在不适用read和write函数的情况下，使用地址（指针）完成I/O操作。
+       使用这种方法，首先应通知内核，将一个指定文件映射到存储区域中。这个映射工作可以通过mmap函数来实现。
+总结：使用mmap时务必注意以下事项：
+1.     创建映射区的过程中，隐含着一次对映射文件的读操作。
+2.     当MAP_SHARED时，要求：映射区的权限应 <=文件打开的权限(出于对映射区的保护)。而MAP_PRIVATE则无所谓，因为mmap中的权限是对内存的限制。
+3.     映射区的释放与文件关闭无关。只要映射建立成功，文件可以立即关闭。
+4.     特别注意，当映射文件大小为0时，不能创建映射区。所以：用于映射的文件必须要有实际大小！！   mmap使用时常常会出现总线错误，通常是由于共享文件存储空间大小引起的。
+5.     munmap传入的地址一定是mmap的返回地址。坚决杜绝指针++操作。
+6.     如果文件偏移量必须为4K的整数倍
+7.     mmap创建映射区出错概率非常高，一定要检查返回值，确保映射区建立成功再进行后续操作。
+
+
 - Message Queue消息传递系统/消息队列
 
     消息队列是一列具有头和尾的消息排列。新来的消息放在队列尾部，而读取消息则从队列头部开始，消息队列乍一看，这不是管道吗？一头读、一头写？没错。这的确看上去像管道，但它不是管道。首先，它无需固定的读写进程，任何进程都可以读写（当然是有权限的进程）。其次，它可以同时支持多个进程，多个进程可以读写消息队列。即所谓的多对多，而不是管道的点对点。另外，消息队列只在内存中实现。最后，它并不是只在UNIX和类UNIX操作系统中实现。几乎所有主流操作系统都支持消息队列。

From ad0a42339b44d8dddd0079ac4ba9134f475508da Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 25 May 2023 14:36:26 +0800
Subject: [PATCH 121/213] update OS

---
 ...3\347\250\213\344\270\216\347\272\277\347\250\213.md" | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md" "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
index c4ebb267..4fea41c6 100644
--- "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
+++ "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
@@ -315,7 +315,14 @@ int main(void)
 
 - Signals信号
 
-    管道和套接字虽然提供了丰富的通信语义，并且也得到了广泛应用，但它们也存在某些缺点，并且在某些时候，这两种通信机制会显得很不好用。首先，如果使用管道和套接字方式来通信，必须事先在通信的进程间建立连接（创建管道或套接字），这需要消耗系统资源。其次，通信是自愿的。即一方虽然可以随意向管道或套接字发送信息，但对方却可以选择接收的时机。即使对方对此充耳不闻，你也奈何不得。再次，由于建立连接消耗时间，一旦建立，我们就想进行尽可能多的通信。而如果通信的信息量微小，如我们只是想通知一个进程某件事情的发生，则用管道和套接字就有点“杀鸡用牛刀”的味道，效率十分低下。因此，我们需要一种不同的机制来处理如下通信需求：想迫使一方对我们的通信立即做出回应。我们不想事先建立任何连接，而是临时突然觉得需要与某个进程通信。传输的信息量微小，使用管道或套接字不划算。应付上述需求，我们使用的是信号（signal）。那么信号是什么呢？在计算机里，信号就是一个内核对象，或者说是一个内核数据结构。发送方将该数据结构的内容填好，并指明该信号的目标进程后，发出特定的软件中断。操作系统接收到特定的中断请求后，知道是有进程要发送信号，于是到特定的内核数据结构里查找信号接收方，并进行通知。接到通知的进程则对信号进行相应处理。信号非常类似我们生活当中的电报。如果你想给某人发一封电报，就拟好电文，将报文和收报人的信息都交给电报公司。电报公司则将电报发送到收报人所在地的邮局（中断），并通知收报人来取电报。发报时无需收报人事先知道，更无需进行任何协调。如果对方选择不对信号做出响应，则将被操作系统终止运行。
+    管道和套接字虽然提供了丰富的通信语义，并且也得到了广泛应用，但它们也存在某些缺点，并且在某些时候，这两种通信机制会显得很不好用。首先，如果使用管道和套接字方式来通信，必须事先在通信的进程间建立连接（创建管道或套接字），这需要消耗系统资源。其次，通信是自愿的。即一方虽然可以随意向管道或套接字发送信息，但对方却可以选择接收的时机。即使对方对此充耳不闻，你也奈何不得。再次，由于建立连接消耗时间，一旦建立，我们就想进行尽可能多的通信。而如果通信的信息量微小，如我们只是想通知一个进程某件事情的发生，则用管道和套接字就有点“杀鸡用牛刀”的味道，效率十分低下。因此，我们需要一种不同的机制来处理如下通信需求：想迫使一方对我们的通信立即做出回应。我们不想事先建立任何连接，而是临时突然觉得需要与某个进程通信。传输的信息量微小，使用管道或套接字不划算。应付上述需求，我们使用的是信号（signal）。
+
+那么信号是什么呢？在计算机里，信号就是一个内核对象，或者说是一个内核数据结构。发送方将该数据结构的内容填好，并指明该信号的目标进程后，发出特定的软件中断。操作系统接收到特定的中断请求后，知道是有进程要发送信号，于是到特定的内核数据结构里查找信号接收方，并进行通知。接到通知的进程则对信号进行相应处理。信号非常类似我们生活当中的电报。如果你想给某人发一封电报，就拟好电文，将报文和收报人的信息都交给电报公司。电报公司则将电报发送到收报人所在地的邮局（中断），并通知收报人来取电报。发报时无需收报人事先知道，更无需进行任何协调。如果对方选择不对信号做出响应，则将被操作系统终止运行。
+
+A给B发送信号，B收到信号之前执行自己的代码，收到信号后，不管执行到程序的什么位置，都要暂停运行，去处理信号，处理完毕再继续执行。与硬件中断类似——异步模式。但信号是软件层面上实现的中断，早期常被称为“软中断”。
+
+信号的特质：由于信号是通过软件方法实现，其实现手段导致信号有很强的延时性。但对于用户来说，这个延迟时间非常短，不易察觉。
+每个进程收到的所有信号，都是由内核负责发送的，内核处理。
 
     
 

From 0488ccc390b6018a15272f0ce396c8c3d838d868 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 25 May 2023 21:54:14 +0800
Subject: [PATCH 122/213] update OS part

---
 ...44\350\241\214\345\244\247\345\205\250.md" |   4 +++
 ...13\344\270\216\347\272\277\347\250\213.md" |  12 +++++++-
 ...05\345\255\230\347\256\241\347\220\206.md" |   2 +-
 VideoDevelopment/.DS_Store                    | Bin 8196 -> 6148 bytes
 ...47\220\206_NAT\347\251\277\351\200\217.md" |  27 +++++++++++-------
 5 files changed, 33 insertions(+), 12 deletions(-)

diff --git "a/JavaKnowledge/\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214\345\244\247\345\205\250.md" "b/JavaKnowledge/\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214\345\244\247\345\205\250.md"
index 8b25dcf3..05a700fc 100644
--- "a/JavaKnowledge/\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214\345\244\247\345\205\250.md"
+++ "b/JavaKnowledge/\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214\345\244\247\345\205\250.md"
@@ -526,6 +526,10 @@ $ file .bashrc
 
 ### Shell脚本
 
+Shell的作用就是解释执行用户的命令，用户输入一条命令，Shell就解释执行一条，这种方式称为交互式，Shell还有一种执行命令的方式称为批处理，用户事先写一个Shell脚本，其中有很多条命令，让Shell一次把这些命令执行完，而不是一条一条的敲命令。
+Shell脚本和编程语言很类似，也有变量和流程控制语句，但Shell脚本是解释执行的，不需要编译，Shell程序从脚本中一行一行读取并执行这些命令，相当于一个用户把脚本中的命令一行一行敲到Shell提示符下执行。
+
+
 ```shell
 #!/bin/bash
 # This line is a comment
diff --git "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md" "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
index 4fea41c6..71260d02 100644
--- "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
+++ "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
@@ -336,6 +336,7 @@ A给B发送信号，B收到信号之前执行自己的代码，收到信号后
 
     操作系统会中断目标程序的进程来向其发送信号、在任何非原子指令中，执行都可以中断，如果进程已经注册了新号处理程序，那么就执行进程，如果没有注册，将采用默认处理的方式。
 
+   信号效率非常高，但是可携带的数据有限，只能写到一个标志位，无法携带其他数据。
 - 信号量
 
     信号量（semaphore）是由荷兰人E.W.Dijkstra在20世纪60年代所构思出的一种程序设计构造。其原型来源于铁路的运行：在一条单轨铁路上，任何时候只能有一列列车行驶在上面。而管理这条铁路的系统就是信号量。任何一列火车必须等到表明铁路可以行驶的信号后才能进入轨道。当一列列车进入单轨运行后，需要将信号改为禁止进入，从而防止别的火车同时进入轨道。而当列车驶出单轨后，则需要将信号变回允许进入状态。这很像以前的旗语，在计算机里，信号量实际上就是一个简单整数。一个进程在信号变为0或者1的情况下推进，并且将信号变为1或0来防止别的进程推进。当进程完成任务后，则将信号再改变为0或1，从而允许其他进程执行。需要注意的是，信号量不只是一种通信机制，更是一种同步机制。
@@ -358,7 +359,7 @@ FIFO常被称为命名管道，以区分管道(pipe)。管道(pipe)只能用于
        一旦使用mkfifo创建了一个FIFO，就可以使用open打开它，常见的文件I/O函数都可用于fifo。如：close、read、write、unlink等。
 
 
-- 存储映射I/O 
+- 存储映射
        存储映射I/O (Memory-mapped I/O) 使一个磁盘文件与存储空间中的一个缓冲区相映射。于是当从缓冲区中取数据，就相当于读文件中的相应字节。于此类似，将数据存入缓冲区，则相应的字节就自动写入文件。这样，就可在不适用read和write函数的情况下，使用地址（指针）完成I/O操作。
        使用这种方法，首先应通知内核，将一个指定文件映射到存储区域中。这个映射工作可以通过mmap函数来实现。
 总结：使用mmap时务必注意以下事项：
@@ -370,6 +371,15 @@ FIFO常被称为命名管道，以区分管道(pipe)。管道(pipe)只能用于
 6.     如果文件偏移量必须为4K的整数倍
 7.     mmap创建映射区出错概率非常高，一定要检查返回值，确保映射区建立成功再进行后续操作。
 
+- 匿名映射
+
+    使用映射区完成文件读写操作十分方便，父子进程间通信比较容易。但缺陷是，每次创建映射区一定要依赖一个文件才能实现。通常为了建立映射区要open一个temp文件，创建好了再unlink、close掉，比较麻烦。可以直接使用匿名映射来代替。其实linux系统给我们提供了创建匿名映射区的方法，无需依赖一个文件即可创建映射区。
+需要借助标志位参数来指定: 
+使用MAP_ANONYMOUS或MAP_ANON，例如:  
+```c
+int *p = mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0);
+// 4是随意举例，该位置表示大小，可依据实际需要填写
+```
 
 - Message Queue消息传递系统/消息队列
 
diff --git "a/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md" "b/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
index 9caa1e04..0f00ea4f 100644
--- "a/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
+++ "b/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
@@ -402,7 +402,7 @@ TLB通常由CPU制造商提供，但TLB的更换算法则有可能由操作系
 
 
 
-## 内存映射
+## 内存映射(共享内存)
 
 进程通过一个系统调用(mmap)将一个文件（或部分）映射到其虚拟地址空间的一部分，访问这个文件就像访问内存中的一个大数组，而不是对文件进行读写。
 
diff --git a/VideoDevelopment/.DS_Store b/VideoDevelopment/.DS_Store
index 632c9571c556ec4c8a1e2ff3037bdc226591462c..21e4004cc82413cdd66fa1c136dac602a5f414d2 100644
GIT binary patch
delta 221
zcmZp1XfcprU|?W$DortDU=RQ@Ie-{Mvv5r;6q~50$jGrVU^g=($7Df4naLUg4IHKh
z2098R=BAS`3ffP8FCaNtS5R=WyHF21Lfmn(w6HW6LjZ#jLqJkPy8dJb;RX&vLt~IW
zLy$ghRwPMHkvYhQI!xvj<>4s{F3QWv&r1h6ZepSOVs;J=L1rKa2n4u+ge%B}8w<ZP
YPv)2L1i6=i3F3B;cNjLu^UPre0H8Z9wEzGB

literal 8196
zcmeHM&2JJx6o1oFx}<(!qK4xpUP%N>sYDNes239w*Jz?O$aV=3mtDe#m=GdIwI{vQ
zzrwTeUhiJ~NBR%=-puS~SxPUEY*S~*%x`%gGy8r6^LPsYu*%5F0;B*y!%mpo!QqTX
zdg=>pLrTb*p+A5N9k7m1KmY#zb-`K*6a$I@#eiZ!F`yW@2n=A(rlu{)`$DTm#eibq
zzhr>U2OT?MN#aZ(KRR&WB>-X!#k}D))&bl{mspZG6Ube0PEkED>B?k@!Gt^NbuvdR
zNt_83?!bgQFu5|56$<04qo2;rft3WRQ8AzxSY&`|_bX5a2Q26Z>-Rbsf6VcqXWFib
zHb2dt-5CrsnZImfGqx4q*0!}B?TyiP$HuTR91SXs{%d;o+;wf!yKa~-I?ZuCdGn#`
z3>zJ%+2;-&tBEEDFFTIqjw|lSu?F1N5DG1!CF;r4WRlP4(t0j;Z<^L8#at$>=XVR!
zX+pbo=kEPy^>=pHaleR=m^>EXYAD2`^Ww7xhqj6LOU_G4cyII_+jUxKLw0d^jIS>A
zpb4$02`UgNxomDlg63ihk}{`QAfm=eaNr3%jhcwPy=+?F&1P06A`nw3-mPx=)wh~q
z)Q)~c9qpR7JrI$%>G%PMfH*`!oF42QuumuL2leYwlaMbK(t5VIzv`9;V+ztR7i@@#
z7&(2s{eeYI!rp!!4}kot2Y?@sM*y94zAzm8@#*CX-iyZzp1uSzPiVKY#-ZEokx({Y
z*LAB^nIE-Z^&6GxwUaX11oYOq`d)ka+#%AvwbzN8VzLy~|BseG|6k{lYA(fqV&H-?
zz+zRSTEUy5Q~#_+wYHA^Ep}>THxtNRaNy-QA}_}g{XY!xT1QjzDM_3OL<zPi9|TZw
kFqh_o8DLHkI*t9*sPcb=<>9)1{CKH8xchz%zpVNHAL3)@wEzGB

diff --git "a/VideoDevelopment/P2P\346\212\200\346\234\257/P2P\345\216\237\347\220\206_NAT\347\251\277\351\200\217.md" "b/VideoDevelopment/P2P\346\212\200\346\234\257/P2P\345\216\237\347\220\206_NAT\347\251\277\351\200\217.md"
index 43bcfc89..0b3bd000 100644
--- "a/VideoDevelopment/P2P\346\212\200\346\234\257/P2P\345\216\237\347\220\206_NAT\347\251\277\351\200\217.md"
+++ "b/VideoDevelopment/P2P\346\212\200\346\234\257/P2P\345\216\237\347\220\206_NAT\347\251\277\351\200\217.md"
@@ -1,14 +1,11 @@
 P2P原理_NAT穿透
 ===
 
-
-
 ### NAT
 
 NAT（Network Address Translation，网络地址转换），也叫做网络掩蔽或者IP掩蔽。NAT是一种网络地址翻译技术，主要是将内部的私有IP地址（private IP）转换成可以在公网使用的公网IP（public IP）。
 
 
-
 网络地址转换，就是替换IP报文头部的地址信息。NAT通常部署在一个组织的网络出口位置，通过将内部网络IP地址替换为出口的IP地址提供公网可达性和上层协议的连接能力。那么，什么是内部网络IP地址？
 
  [RFC1918](https://datatracker.ietf.org/doc/rfc1918/)规定了三个保留地址段落：10.0.0.0-10.255.255.255；172.16.0.0-172.31.255.255；192.168.0.0-192.168.255.255。这三个范围分别处于A,B,C类的地址段，不向特定的用户分配，被IANA作为私有地址保留。这些地址可以在任何组织或企业内部使用，和其他Internet地址的区别就是，仅能在内部使用，不能作为全球路由地址。这就是说，出了组织的管理范围这些地址就不再有意义，无论是作为源地址，还是目的地址。对于一个封闭的组织，如果其网络不连接到Internet，就可以使用这些地址而不用向IANA提出申请，而在内部的路由管理和报文传递方式与其他网络没有差异。
@@ -33,18 +30,28 @@ NAT（Network Address Translation，网络地址转换），也叫做网络掩
 
  简单的背景了解过后，下面介绍下NAT实现的主要方式，以及NAT都有哪些类型。
 
-
-
 ### NAT的实现方式
-
-
-
 - 静态NAT: 就是静态地址转换。是指一个公网IP对应一个私有IP，是一对一的转换，同时注意，这里只进行了IP转换，而没有进行端口的转换。
 
 - NAPT： 端口多路复用技术。与静态NAT的差别是，NAPT不但要转换IP地址，还要进行传输层的端口转换。具体的表现形式就是，对外只有一个公网IP，通过端口来区别不同私有IP主机的数据。
 
-    
+### NAT映射
+
+表内记录了私有ip和公有ip的对应关系，例如： 
+```
+192.168.1.35:8000 <--> 123.24.56.78:10000
+....
+```
+
+### NAT打洞
 
+正常两个人发送数据，例如通过QQ聊天，目前的步骤是： 
+- A使用私有ip经过NAT映射转换为公有IP后将数据发送给腾讯
+- 腾讯将数据转发给B用户
+那后续能不能直接A和B进行链接，这样可以提高效率： 
+- 直接通讯存在一个问题，路由器内部有一个保护支持，对于陌生的IP第一次发的数据包，路由器会丢弃或屏蔽掉，以此来防止陌生网络进行攻击。
+- 所以要想能够让B的路由器直接接受到A发送的数据，那就必须保证B的路由器要熟悉A的IP地址，这样B才能够进行接收。而A和B首次登录QQ的时候腾讯已经将自己的ip返回给A和B了，所以A和B的路由中都认识腾讯的IP了，这样A和B都能接受腾讯发送的数据包。
+- 那如何让A和B进行直接通信，这里就是腾讯所有的事情，腾讯就通过腾讯的公网IP对AB之间进行了打洞的操作，将对方的IP都下发给对应的AB用户，这样就把他俩形成了一个私有的通路，这个操作就是打洞。 
 
 
 
@@ -68,4 +75,4 @@ NAT（Network Address Translation，网络地址转换），也叫做网络掩
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 

From 4bdc2a2d941697ea0e78bf24cbbf9f397fa25d3f Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Fri, 26 May 2023 10:31:04 +0800
Subject: [PATCH 123/213] update shell part

---
 ...44\350\241\214\345\244\247\345\205\250.md" | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git "a/JavaKnowledge/\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214\345\244\247\345\205\250.md" "b/JavaKnowledge/\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214\345\244\247\345\205\250.md"
index 05a700fc..8609744e 100644
--- "a/JavaKnowledge/\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214\345\244\247\345\205\250.md"
+++ "b/JavaKnowledge/\345\270\270\347\224\250\345\221\275\344\273\244\350\241\214\345\244\247\345\205\250.md"
@@ -565,6 +565,29 @@ function NAME() {
 ```
 function关键字可以省略。
 
+###### 命令代换
+
+```shell
+DATE=`date`
+echo $DATE
+```
+由“`”反引号括起来的也是一条命令，Shell先执行该命令，然后将输出结果立刻代换到当前命令行中，也可以用$()表示: 
+```shell
+DATE = $(date)
+```
+
+
+####### 输入输出
+echo: 显示文本行或变量，或者把字符串输入到文件
+
+###### tee
+tee 命令把结果输出到标准输出，另一个副本输出到相应文件中。
+
+
+
+
+
+
         
 ----
 - 邮箱 ：charon.chui@gmail.com  

From 750893c06bc1446b0a2625ae83e965a811dc6bd8 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 29 May 2023 21:55:17 +0800
Subject: [PATCH 124/213] update ffmpeg part

---
 VideoDevelopment/.DS_Store                    | Bin 6148 -> 0 bytes
 .../1.FFmpeg\347\256\200\344\273\213.md"      |   2 +-
 ...57\345\242\203\351\205\215\347\275\256.md" | 206 ++++++++++++++++++
 ...70\345\277\203\345\212\237\350\203\275.md" | 145 ++++++++++++
 VideoDevelopment/FFmpeg/AAC.md                |  22 --
 .../AAC.md"                                   |  25 ++-
 6 files changed, 369 insertions(+), 31 deletions(-)
 delete mode 100644 VideoDevelopment/.DS_Store
 create mode 100644 "VideoDevelopment/FFmpeg/4.\345\274\200\345\217\221\347\216\257\345\242\203\351\205\215\347\275\256.md"
 create mode 100644 "VideoDevelopment/FFmpeg/5. FFmpeg\346\240\270\345\277\203\345\212\237\350\203\275.md"
 delete mode 100644 VideoDevelopment/FFmpeg/AAC.md

diff --git a/VideoDevelopment/.DS_Store b/VideoDevelopment/.DS_Store
deleted file mode 100644
index 21e4004cc82413cdd66fa1c136dac602a5f414d2..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6148
zcmeHKOH0E*5T4aqQy<uag2#YYp{-9u53wp<1jUFRti*;C4aRKg!yZZ@M;|9o`cwP^
zdiUZV@eeq&yM;c~i(*B0VD_8r%p}a0>`oQ{ShnhA0FnS;pc2N0aCk?^PueAYYKELl
z+=GJ;-reif)BSB%w4TrmXa;^81GIKWU=>2}pad=J*8%(4t(A*zz+H@aaEpOouB6j1
ztgk;d5Fa!KjbY=+KIJvLlCM<D*?j4cuJ$+&+@_s(_x(c6Nsh1au#)$~LP;d}UI9aL
z2Y%@BT9#KsuPkzH=`a#T!bwin>+|XKv^lpp-<US*OEYB8E;JemV`3_`yz86==OMqA
zgfiTJgp4X|!VMZ9)^}l-!hnY-7(@AS*oGn$kc&;&`XjZs)zne%0PMgF?6}cMs@K(K
zGPCriGhckuEfsat8mFF=W0#MoE6!N2tNo_$x~-;;dYj+>XQ<YUG5lGO_Gtz*1OJi%
z+8<0*LQ7#JQEVMJh$8@E45x*lO=k(pF%?=0BZ=riVKNm_rZRQJU@{%&O%-P;j3ml*
zVCwL})RUPyp)m1uyuT^Jfmssus2R`<v@_5zFO$^&H$Fc9w<qZ<&46a$Pcgt^>-KsU
zOH#eHt2pYlCh9RN3B^ScMG6k89Seh6@g%Ac^qFKJS_&hHID?{p1OyFw&<y-218*R`
B73=^2

diff --git "a/VideoDevelopment/FFmpeg/1.FFmpeg\347\256\200\344\273\213.md" "b/VideoDevelopment/FFmpeg/1.FFmpeg\347\256\200\344\273\213.md"
index 86536a43..72414061 100644
--- "a/VideoDevelopment/FFmpeg/1.FFmpeg\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/FFmpeg/1.FFmpeg\347\256\200\344\273\213.md"
@@ -1,7 +1,7 @@
 1.FFmpeg简介
 ===
 
-FFmpeg是一个开源免费跨平台的视频和音频流方案，属于自由软件，采用LGPL或GPL许可证（依据你选择的组件）。它提供了录制、转换以及流化音视频的完整解决方案。它包含了非常先进的音频/视频编解码库libavcodec，为了保证高可移植性和编解码质量，libavcodec里很多codec都是从头开发的。
+[FFmpeg](https://ffmpeg.org/)是一个开源免费跨平台的视频和音频流方案，属于自由软件，采用LGPL或GPL许可证（依据你选择的组件）。它提供了录制、转换以及流化音视频的完整解决方案。它包含了非常先进的音频/视频编解码库libavcodec，为了保证高可移植性和编解码质量，libavcodec里很多codec都是从头开发的。
 
 FFmpeg框架的基本组成包含： 
 - AVFormat    
diff --git "a/VideoDevelopment/FFmpeg/4.\345\274\200\345\217\221\347\216\257\345\242\203\351\205\215\347\275\256.md" "b/VideoDevelopment/FFmpeg/4.\345\274\200\345\217\221\347\216\257\345\242\203\351\205\215\347\275\256.md"
new file mode 100644
index 00000000..a11b526f
--- /dev/null
+++ "b/VideoDevelopment/FFmpeg/4.\345\274\200\345\217\221\347\216\257\345\242\203\351\205\215\347\275\256.md"
@@ -0,0 +1,206 @@
+## 开发环境配置
+
+### Mac下安装FFmpeg
+
+FFmpeg的学习看其源代码时需要下载他的仓库，直接读源码，其他场景下的编译都是自己根据自己的需求进行编译的，但是在Mac 中不需要进行编译就可以学习FFmpeg的各个API: 
+```
+brew install ffmpeg
+```
+通过brew安装之后，ffmpeg需要的头文件和lib文件都会安装到/usr/local/X的位置,我的为: 
+```
+/usr/local/Cellar/ffmpeg/6.0
+```
+### xcode
+
+Xcode 创建一个Commond Line Tools 项目，选择C++/C都可
+#### 配置Header、Library路径
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/xcode_ffmpeg_1.png?raw=true)   
+#### 添加动态链接库
+ ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/xcode_ffmpeg_2.png?raw=true) 
+
+#### main.cpp测试代码
+```c++
+#if defined(__cplusplus)
+extern "C"
+{
+#endif
+#include "libavcodec/avcodec.h"
+#if defined(__cplusplus)
+}
+#endif
+
+#include <iostream>
+
+using namespace std;
+
+#include <iostream>
+
+
+int main(int argc, const char * argv[]) {
+    // insert code here...
+    std::cout << "Hello, World!\n";
+    cout << "avcodec_configuration : " << avcodec_configuration() << endl;
+    return 0;
+}
+```
+运行结果:  
+```
+Hello, World!
+avcodec_configuration : --prefix=/usr/local/Cellar/ffmpeg/6.0 --enable-shared --enable-pthreads --enable-version3 --cc=clang --host-cflags= --host-ldflags= --enable-ffplay --enable-gnutls --enable-gpl --enable-libaom --enable-libaribb24 --enable-libbluray --enable-libdav1d --enable-libmp3lame --enable-libopus --enable-librav1e --enable-librist --enable-librubberband --enable-libsnappy --enable-libsrt --enable-libsvtav1 --enable-libtesseract --enable-libtheora --enable-libvidstab --enable-libvmaf --enable-libvorbis --enable-libvpx --enable-libwebp --enable-libx264 --enable-libx265 --enable-libxml2 --enable-libxvid --enable-lzma --enable-libfontconfig --enable-libfreetype --enable-frei0r --enable-libass --enable-libopencore-amrnb --enable-libopencore-amrwb --enable-libopenjpeg --enable-libspeex --enable-libsoxr --enable-libzmq --enable-libzimg --disable-libjack --disable-indev=jack --enable-videotoolbox
+Program ended with exit code: 0
+```
+
+### Android Studio配置FFmpeg开发环境
+### 下载ffmpeg源码
+下载ffmpeg的源码
+官网地址：http://www.ffmpeg.org/download.html
+里面有Linux、macOS、Windows系统的版本，根据自己的需要下载对应的版本。下载完成后把源码放在你喜欢的路径，如：/Users/ccc/ffmpeg
+
+### 修改FFmpeg目录下的configuration配置文件: 
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/ffmpeg_source_code_1.png?raw=true)
+
+然后搜索Toolchain options部分，增加： 
+```
+--cross-prefix-clang=PREFIX    use PREFIX for compilation tools [$cross_prefix_clang]
+```
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/ffmpeg_source_code_2.png?raw=true)
+
+再搜索CMDLINE_SET，也增加上面的自定义参数配置: 
+
+ ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/ffmpeg_sourcecode_3.png?raw=true)
+
+最后再搜索set_default target_os，进行一下修改：
+```
+4436 set_default target_os
+4437 if test "$target_os" = android; then
+4438     cc_default="clang"
+4439     # 增长这一行
+4440     cxx_default="clang++"
+4441 fi
+4442
+4443 ar_default="${cross_prefix}${ar_default}"
+4444 # 修改这一行
+4445 cc_default="${cross_prefix_clang}${cc_default}"
+4446 # 修改这一行
+4447 cxx_default="${cross_prefix_clang}${cxx_default}"
+4448 nm_default="${cross_prefix}${nm_default}"
+```
+
+这样修改之后咱们在编译时就可使用咱们新增的cross_prefix_clang参数了，而后其余的如nm，ar，ranlib，strip则继续使用cross_prefix参数。
+
+为什么要这样改？
+首先，需要先了解编译库的流程。
+①编写自定义的编译脚本
+②脚本根据各个配置项，去寻找对应的库工具路径
+③生成动态链接库
+而上面的修改，目的就是为了第二步能正常找到对应的库工具。配置中的nm，ar，ranlib，strip这些的前缀，是arm-linux-androideabi-，而cc，cxx这两个是arm-linux-androideabi21-这样的前缀，而且他们放的位置也不一样。所以增加一个自定义的配置项，用于指向不同的目录。
+
+#### 编写编译脚本
+在ffmepg的文件夹中新建一个文件夹build-android，里面再新建一个build-android.sh文件。
+
+```shell
+#!/bin/bash
+#NDK路径
+export NDK=/Users/xxxx/Library/Android/sdk/ndk/21.0.6113669
+#CPU类型
+export CPU=armv8-a
+# 目标Android版本
+API=21
+#架构类型
+export ARCH=arm
+export SYSROOT=$NDK/toolchains/llvm/prebuilt/darwin-x86_64/sysroot
+#交叉编译工具链
+export TOOLCHAIN=$NDK/toolchains/llvm/prebuilt/darwin-x86_64
+#编译成功后，存放的路径
+export PREFIX=./build-android/dist
+
+cd .. #回到ffmpeg根目录
+
+echo "start configure"
+./configure \
+--prefix=$PREFIX \
+--enable-shared \
+--enable-cross-compile \
+--cross-prefix=$TOOLCHAIN/bin/arm-linux-androideabi- \
+--cross-prefix-clang=$TOOLCHAIN/bin/armv7a-linux-androideabi21- \
+--target-os=android --arch=$ARCH --cpu=$CPU \
+--enable-gpl --enable-version3 \
+--disable-programs --disable-ffmpeg --disable-ffplay --disable-ffprobe \
+--disable-doc --disable-htmlpages --disable-manpages --disable-podpages --disable-txtpages \
+--disable-postproc \
+--disable-debug  \
+--sysroot=$SYSROOT \
+--extra-cflags="-I$SYSROOT/usr/include" \
+--extra-ldflags="-L$SYSROOT/usr/lib" \
+--enable-small \
+--enable-jni \
+--enable-mediacodec 
+--disable-everything \
+--enable-decoder=hevc --enable-decoder=h264  --enable-decoder=aac \
+--enable-parser=h264 --enable-parser=hevc --enable-parser=aac \
+--enable-demuxer=flv --enable-demuxer=mov --enable-demuxer=avi --enable-demuxer=mpegts \
+--enable-protocol=file --enable-protocol=hls
+ 
+echo "make clean start"
+make clean
+echo "make start"
+make -j4
+echo "make finished"
+make install
+echo "make install finished"
+```
+
+cd到ffmpeg一级目录，然后执行以下的命令
+```
+chmod 777 build_android.sh //改变脚本权限，使其能够运行，然后
+
+./build_android.sh //运行脚本
+```
+
+等编译完成后，进入目录就能看到生成的库: 
+ ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/ffmpeg_sourcecode_5.png?raw=true)
+
+
+
+还有一个问题，就是能不能不修改configure文件？
+其实也是可以，只需要明确指定cc和cxx的路径就行。
+
+--cc=$TOOLCHAIN/bin/armv7a-linux-androideabi21-clang \
+--cxx=$TOOLCHAIN/bin/armv7a-linux-androideabi21-clang++ \
+--cross-prefix=$TOOLCHAIN/bin/arm-linux-androideabi- \
+脚本部分配置项解释
+1.—prefix：指定编译输出的文件路径
+2.—target-os：指定目标操作系统
+3.--disable-static：禁止生成静态库
+4.—disable-programs：禁止生成ffplay、ffmpeg等可执行文件
+5.—disable-doc：禁止生成文档
+6.—enable-shared：生成动态链接库
+7.enable-cross-compile：开启交叉编译（跨平台编译）
+8.make -j12：定义用几个CPU编译
+
+
+到这里为止，就已经编译出我们需要的so库了，之后就是怎么在android项目中使用了。
+
+### Android编译方式2
+
+[ffmpeg-android-maker](https://github.com/Javernaut/ffmpeg-android-maker)项目已经把下载、编译都给写好了，我们要做的就是下载下来后，
+环境变量中配置ANDROID_SDK_HOME和ANDROID_NDK_HOME：
+```
+ export ANDROID_SDK_HOME=/Users/xuchuanren/Library/Android/sdk
+ export ANDROID_NDK_HOME=/Users/xuchuanren/Library/Android/sdk/ndk/23.1.77796    20
+```
+然后运行进入目录执行: 
+```
+sh ffmpeg-android-maker.sh
+```
+它会自动下载并编译android上可用的so，结果为： 
+ ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/ffmpeg_source_generate_2.png?raw=true)
+
+#### 项目集成
+新建项目，增加C++支持。手动创建jniLibs文件夹
+然后将上一步生成的所有文件(库文件和头文件)复制到jniLibs文件夹下面
+最终目录结构：
+
+
diff --git "a/VideoDevelopment/FFmpeg/5. FFmpeg\346\240\270\345\277\203\345\212\237\350\203\275.md" "b/VideoDevelopment/FFmpeg/5. FFmpeg\346\240\270\345\277\203\345\212\237\350\203\275.md"
new file mode 100644
index 00000000..e7549020
--- /dev/null
+++ "b/VideoDevelopment/FFmpeg/5. FFmpeg\346\240\270\345\277\203\345\212\237\350\203\275.md"	
@@ -0,0 +1,145 @@
+## 5. FFmpeg核心功能
+
+FFmpeg共有8个可信开发库: 
+
+- avutil
+    包含一些公共的工具函数，主要有数学函数、字符串操作、内存管理相关、数据结构相关、错误码及错误处理、日志输出、其他复制信息比如密钥、哈希值、宏、库版本、常量等。
+
+- avformat
+    用于各种音视频封装格式的生成和解析，包括获取解码所需信息以生成解码上下文结构和读取音视频帧等功能，包含demuxers和muxer库
+- avcodec
+    用于各种类型声音/图像编解码
+- avfilter
+    在多媒体处理中，filter的意思是被编码到输出文件之前用来修改输入文件内容的一个软件工具
+- avdevice
+    FFmpeg中有一个和多媒体设备交互的类库:Libavdevice。使用这个库可以读取电脑(或其他设备) 的多媒体设备的数据，或者输出数据到指定的多媒体设备上
+- postproc
+    用于后期效果处理
+- swresample
+    libswresample库功能主要包括高度优化的音频重采样、rematrixing和样本格式转换操作
+- swscale
+    用于视频场景比例缩放、色彩映射转换
+
+
+### FFmpeg重要结构体
+
+ ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/ffmpeg_struct_import.png?raw=true)        
+
+
+FFmpeg中的结构体有非常多，其中重要的结构体大概可以分以下几类：
+
+###### 1.解协议（http，rtsp，rtmp，mms，file，tcp，udp ...）
+
+AVIOContext，URLProtocol，URLContext主要存储视音频使用的协议的类型以及状态。URLProtocol存储输入视音频使用的封装格式。每种协议都对应一个URLProtocol结构。（注意：FFMPEG中文件也被当做一种协议“file”）。
+
+###### 2.解封装（flv，rmvb，mp4）
+
+AVFormatContext主要存储视音频封装格式中包含的信息；AVInputFormat存储输入视音频使用的封装格式。每种视音频封装格式都对应一个AVInputFormat 结构。
+
+###### 3.解码（h264，mpeg2，aac，mp3）
+
+每个AVStream存储一个视频/音频流的相关数据；每个AVStream对应一个AVCodecContext，存储该视频/音频流使用解码方式的相关数据；每个AVCodecContext中对应一个AVCodec，包含该视频/音频对应的解码器。每种解码器都对应一个AVCodec结构。
+
+###### 4.存数据
+
+视频的话，每个结构一般是存一帧；音频可能有好几帧
+
+解码前数据：AVPacket
+
+解码后数据：AVFrame
+
+### FFmpeg 4.x解码流程
+ ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/ffmpeg_stream_11.png?raw=true)
+
+
+FFMpeg 中主要数据结构存在包含关系，如下标题显示的就是包含层级的关系。
+
+AVFormatContext ->AVStream-> AVCodecContext -> AVCodec，其中后者是前者的数据成员。
+AVFormatContext 是一个贯穿始终的数据结构，很多函数都用到它作为参数，是输入输
+出相关信息的一个容器。
+主要成员如下：
+1. AVInputFormat 和AVOutputFormat，同一时间只能存在一个。当播放视频时AVInputFormat
+生效，录制视频时则AVOutputFormat 生效。
+2. AVStream 是继AVFormatContext 之后第二个贯穿始终的数据结构，它保存于数据流相关
+的编解码器、数据段等信息，还包含“流”这个概念中的一些信息。
+
+- AVCodecContext 保存AVCodec 指针和与codec 相关的数据。
+
+在AVStream 初始化后，AVCodecContext 的初始化时Codec 使用中最重要的一环。
+AVCodecContext 中的codec_type，codec_id 二个变量对于encoder/decoder 的匹配来说，
+最为重要。
+AVCodecContext 中有两个成员：AVCodec，AVFrame。
+
+- AVCodec 记录了所要使用的Codec 的信息并有5 个函数：init,encoder,close,decode,flush
+来完成编解码工作。
+- AVFrame 中主要包饭了编码后的帧信息。
+```
+typedef struct AVFrame {
+FF_COMMON_FRAME
+} AVFrame;
+```
+其中FF_COMMON_FRAME 是以宏出现的，由于编码过程中AVFrame 中的数据是要经常存取
+的，为了加速，采取这样的代码手段。
+
+
+### API介绍
+
+FFmpeg中奖编码帧及未编码帧均称作frame，这里为了方便，将编码帧称为packet，未编码帧称为frame。
+原始图片(yuv、rgb)或声音(pcm流)都是未压缩的，未编码的。
+H264/H265, aac/ac3/mp3：都是压缩的，编码的。
+
+- avformat_open_input()
+这个函数会打开输入媒体文件，读取文件头，将文件格式信息存储在第一个参数AVFormatContext中。
+
+- avformat_find_stream_info()
+这个函数会读取一段视频文件数据并尝试解码，将取到的流信息填入AVFormatContext.streams中。
+AVFormatContext.streams是一个指针数组，熟读大小是AVFormatContext.nb_streams。
+
+- av_read_frame
+本函数用于解复用过程。
+本函数将存储在输入文件中的数据分割为多个packet，每次调用将得到一个packet。packet
+可能是视频帧、音频帧或其他数据，解码器只会解码视频帧或音频帧，非音视频数据并不会
+被扔掉、从而能向解码器提供尽可能多的信息。
+对于视频来说，一个packet 只包含一个视频帧；
+
+对于音频来说，若是帧长固定的格式则一个packet 可包含整数个音频帧，若是帧长可
+变的格式则一个packet 只包含一个音频帧。
+读取到的packet 每次使用完之后应调用av_packet_unref(AVPacket *pkt)清空packet。否则会
+造成内存泄露。
+
+- av_write_frame()
+本函数用于复用过程，将packet 写入输出媒体。
+packet 交织是指：不同流的packet 在输出媒体文件中应严格按照packet 中dts 递增的顺序交
+错存放。
+本函数直接将packet 写入复用器(muxer)，不会缓存或记录任何packet。本函数不负责不同
+流的packet 交织问题。由调用者负责。
+如果调用者不愿处理packet 交织问题，应调用av_interleaved_write_frame()替代本函数。
+- av_interleaved_write_frame()
+本函数用于复用过程，将packet 写入输出媒体。
+本函数将按需在内部缓存packet，从而确保输出媒体中不同流的packet 能按照dts 增长的顺
+序正确交织。
+- avio_open()
+创建并初始化一个AVIOContext，用于访问输出媒体文件。
+- avformat_write_header()
+向输出文件写入文件头信息。
+- av_write_trailer()
+向输出文件写入文件尾信息。
+
+
+### 解封装demuxer
+1.分配解复用器上下文avformat_alloc_context
+2.根据url 打开本地文件或网络流avformat_open_input
+3.读取媒体的部分数据包以获取码流信息avformat_find_stream_info
+4.读取码流信息：循环处理
+4.1 从文件中读取数据包av_read_frame
+4.2 定位文件avformat_seek_file 或av_seek_frame
+5.关闭解复用器avformat_close_input
+
+
+
+### 转封装
+从一种视频容器转成另一种视频容器
+所谓的封装格式转换， 就是在AVI ， FLV ， MKV ， MP4 这些格式之间转换（ 对
+应.avi，.flv，.mkv，.mp4 文件）。需要注意的是，本程序并不进行视音频的编码和解码工作。
+而是直接将视音频压缩码流从一种封装格式文件中获取出来然后打包成另外一种封装格式
+的文件。
diff --git a/VideoDevelopment/FFmpeg/AAC.md b/VideoDevelopment/FFmpeg/AAC.md
deleted file mode 100644
index 635c4ab9..00000000
--- a/VideoDevelopment/FFmpeg/AAC.md
+++ /dev/null
@@ -1,22 +0,0 @@
-### AAC
-
-### 音频编码
-
-原始的PCM音频数据也是非常大的数据量，因此也需要对其进行压缩编码。
-和视频编码一样，音频也有许多的编码格式，如：WAV、MP3、WMA、APE、FLAC等等，音乐发烧友应该对这些格式非常熟悉，特别是后两种无损压缩格式。
-
-AAC是新一代的音频有损压缩技术，一种高压缩比的音频压缩算法。
-在MP4视频中的音频数据，大多数时候都是采用的AAC压缩格式。
-
-AAC格式主要分为两种： ADIF、ADTS。
-
-- ADIF：Audio Data Interchange Format。 音频数据交换格式
-    这种格式的特征是可以确定的找到这个音频数据的开始，不需进行在音频数据流中间开始的解码，即它的解码必须在明确定义的开始处进行。这种格式常用在磁盘文件中。
-    ADIF只有一个统一的头，所以必须得到所有的数据后解码。
-- ADTS: Audio Data Transport Stream。音频数据传输流
-    这种格式的特征是它是一个由同步字的比特流，解码可以在这个流中任何位置开始。
-    它的特征类似于mp3数据流格式。
-
-    ADTS可以在任意帧解码，它每一帧都有头信息。
-    ADIF只有一个统一的头，所以必须得到所有的数据后解码。
-且这两种的header的格式也是不同的，目前一般编码后的都是ADTS格式的音频流。 
diff --git "a/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/AAC.md" "b/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/AAC.md"
index 58f79f82..e55d26c6 100644
--- "a/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/AAC.md"
+++ "b/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/AAC.md"
@@ -28,16 +28,25 @@ MP3 的16KHz-48kHz 的范围。
 (7). AAC 采用优化的算法达到了更高的解码效率，解码时只需较少的处理能力。
 
 
-#### AAC 音频文件格式
 
-AAC 的音频文件格式有：ADIF， ADTS
-- ADIF：Audio Data Interchange Format 音频数据交换格式。这种格式的特征是
-可以确定的找到这个音频数据的开始，不需进行在音频数据流中间开始的解码，
-即它的解码必须在明确定义的开始处进行。故这种格式常用在磁盘文件中。
-- ADTS：Audio Data Transport Stream 音频数据传输流。这种格式的特征是它是
-一个有同步字的比特流，解码可以在这个流中任何位置开始。它的特征类似于
-mp3 数据流格式。
+原始的PCM音频数据也是非常大的数据量，因此也需要对其进行压缩编码。
+和视频编码一样，音频也有许多的编码格式，如：WAV、MP3、WMA、APE、FLAC等等，音乐发烧友应该对这些格式非常熟悉，特别是后两种无损压缩格式。
 
+AAC是新一代的音频有损压缩技术，一种高压缩比的音频压缩算法。
+在MP4视频中的音频数据，大多数时候都是采用的AAC压缩格式。
+
+AAC格式主要分为两种： ADIF、ADTS。
+
+- ADIF：Audio Data Interchange Format。 音频数据交换格式
+    这种格式的特征是可以确定的找到这个音频数据的开始，不需进行在音频数据流中间开始的解码，即它的解码必须在明确定义的开始处进行。这种格式常用在磁盘文件中。
+    ADIF只有一个统一的头，所以必须得到所有的数据后解码。
+- ADTS: Audio Data Transport Stream。音频数据传输流
+    这种格式的特征是它是一个由同步字的比特流，解码可以在这个流中任何位置开始。
+    它的特征类似于mp3数据流格式。
+
+    ADTS可以在任意帧解码，它每一帧都有头信息。
+    ADIF只有一个统一的头，所以必须得到所有的数据后解码。
+且这两种的header的格式也是不同的，目前一般编码后的都是ADTS格式的音频流。 
 
 简单说，ADTS 可以在任意帧解码，也就是说它每一帧都有头信息。ADIF 只有一个统一的头，所以必须得到所有的数据后解码。这两种的header 的格式也是
 不同的，一般编码后的和抽取出的都是ADTS 格式的音频流。

From dbc9126da8c04f84a8d75b0a859209e8ac150bb5 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 1 Jun 2023 10:52:06 +0800
Subject: [PATCH 125/213] update FFmpeg part

---
 ...70\345\277\203\345\212\237\350\203\275.md" | 59 +++++++++++++++++++
 1 file changed, 59 insertions(+)

diff --git "a/VideoDevelopment/FFmpeg/5. FFmpeg\346\240\270\345\277\203\345\212\237\350\203\275.md" "b/VideoDevelopment/FFmpeg/5. FFmpeg\346\240\270\345\277\203\345\212\237\350\203\275.md"
index e7549020..7a942f32 100644
--- "a/VideoDevelopment/FFmpeg/5. FFmpeg\346\240\270\345\277\203\345\212\237\350\203\275.md"	
+++ "b/VideoDevelopment/FFmpeg/5. FFmpeg\346\240\270\345\277\203\345\212\237\350\203\275.md"	
@@ -143,3 +143,62 @@ packet 交织是指：不同流的packet 在输出媒体文件中应严格按照
 应.avi，.flv，.mkv，.mp4 文件）。需要注意的是，本程序并不进行视音频的编码和解码工作。
 而是直接将视音频压缩码流从一种封装格式文件中获取出来然后打包成另外一种封装格式
 的文件。
+
+### 读取视频MetaData信息
+```c++
+#if defined(__cplusplus)
+extern "C"
+{
+#endif
+#include "libavcodec/avcodec.h"
+#include "libavutil/avutil.h"
+#include "libavutil/file.h"
+#include "libavcodec/avcodec.h"
+#include "libavformat/avformat.h"
+#include "libavformat/avio.h"
+
+#if defined(__cplusplus)
+}
+#endif
+
+#include <iostream>
+using namespace std;
+
+
+int main(int argc, const char * argv[]) {
+    avformat_network_init();
+    AVFormatContext *avFmtCtx = NULL;
+    char *url = "http://vjs.zencdn.net/v/oceans.mp4";
+    int ret = avformat_open_input(&avFmtCtx, url, NULL, NULL);
+    if (ret < 0) {
+        cout << "error";
+        return 0;
+    }
+    avformat_find_stream_info(avFmtCtx, NULL);
+    av_dump_format(avFmtCtx, 0, url, 0);
+    avformat_close_input(&avFmtCtx);
+    return 0;
+}
+```
+运行结果:  
+```
+Input #0, mov,mp4,m4a,3gp,3g2,mj2, from 'http://vjs.zencdn.net/v/oceans.mp4':
+  Metadata:
+    major_brand     : isom
+    minor_version   : 1
+    compatible_brands: isomavc1
+    creation_time   : 2013-05-03T22:51:07.000000Z
+  Duration: 00:00:46.61, start: 0.000000, bitrate: 3949 kb/s
+  Stream #0:0[0x1](und): Video: h264 (Constrained Baseline) (avc1 / 0x31637661), yuv420p(progressive), 960x400 [SAR 1:1 DAR 12:5], 3859 kb/s, 23.98 fps, 23.98 tbr, 24k tbn (default)
+    Metadata:
+      creation_time   : 2013-05-03T22:50:47.000000Z
+      handler_name    : GPAC ISO Video Handler
+      vendor_id       : [0][0][0][0]
+  Stream #0:1[0x2](und): Audio: aac (LC) (mp4a / 0x6134706D), 48000 Hz, stereo, fltp, 92 kb/s (default)
+    Metadata:
+      creation_time   : 2013-05-03T22:51:07.000000Z
+      handler_name    : GPAC ISO Audio Handler
+      vendor_id       : [0][0][0][0]
+```
+
+

From 61993dbaf251d9226df125c6ef2db00b6cf93eff Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 7 Jun 2023 17:25:59 +0800
Subject: [PATCH 126/213] update Audio Encode

---
 ...47\273\237\347\256\200\344\273\213.md.swp" | Bin 49152 -> 0 bytes
 README.md                                     |  20 ++++++++++-
 .../9.OpenGL ES\347\272\271\347\220\206.md"   |   5 +++
 .../PCM.md"                                   |  32 ++++++++++++++++++
 .../WAV.md"                                   |  12 +++++++
 5 files changed, 68 insertions(+), 1 deletion(-)
 delete mode 100644 "OperatingSystem/.1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md.swp"
 create mode 100644 "VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/PCM.md"
 create mode 100644 "VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/WAV.md"

diff --git "a/OperatingSystem/.1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md.swp" "b/OperatingSystem/.1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md.swp"
deleted file mode 100644
index 60c2cbee68d88f536c7213cd55151f2b89666cdb..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 49152
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

diff --git a/README.md b/README.md
index 890fcd12..32c75424 100644
--- a/README.md
+++ b/README.md
@@ -80,9 +80,15 @@ Android学习笔记
         - [视频封装格式][256]
         - [M3U8][321]
     - [视频编码][257]
+        - [视频编码原理][331]
         - [AV1][258]
         - [H264][259]
         - [H265][260]
+    - [音频编码][335]    
+        - [音频编码格式][336]
+        - [AAC][337]
+        - [PCM][338]
+        - [WAV][339]
     - [关键帧][227]
     - [CDN及PCDN][228]
     - [P2P技术][229]
@@ -100,12 +106,15 @@ Android学习笔记
         - [9.OpenGL ES纹理][240]
         - [10.GLSurfaceView+MediaPlayer播放视频][241]
         - [11.OpenGL ES滤镜][242]
+        - [12.FBO][332]
     - [弹幕][243]
         - [Android弹幕实现][244]
     - [FFmpeg][322]    
         - [1.FFmpeg简介][323]
         - [2.FFmpeg常用命令行][324]
-        - [1.FFmpeg切片][325]
+        - [3.FFmpeg切片][325]
+        - [4.开发环境配置][333]
+        - [5. FFmpeg核心功能][334]
 - [操作系统][263]
     - [1.操作系统简介][264]
     - [2.进程与线程][265]
@@ -694,6 +703,15 @@ Android学习笔记
 [328]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/Android%E9%9F%B3%E8%A7%86%E9%A2%91%E5%BC%80%E5%8F%91/1.%E9%9F%B3%E8%A7%86%E9%A2%91%E5%9F%BA%E7%A1%80%E7%9F%A5%E8%AF%86.md "1.音视频基础知识"
 [329]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/Android%E9%9F%B3%E8%A7%86%E9%A2%91%E5%BC%80%E5%8F%91/2.%E7%B3%BB%E7%BB%9F%E6%92%AD%E6%94%BE%E5%99%A8MediaPlayer.md "2.系统播放器MediaPlayer"
 [330]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/Android%E9%9F%B3%E8%A7%86%E9%A2%91%E5%BC%80%E5%8F%91/11.%E6%92%AD%E6%94%BE%E7%BB%84%E4%BB%B6%E5%B0%81%E8%A3%85.md "11.播放器组件封装"
+[331]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E8%A7%86%E9%A2%91%E7%BC%96%E7%A0%81/%E8%A7%86%E9%A2%91%E7%BC%96%E7%A0%81%E5%8E%9F%E7%90%86.md "视频编码原理"
+[332]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/12.FBO.md "12.FBO"
+[333]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/FFmpeg/4.%E5%BC%80%E5%8F%91%E7%8E%AF%E5%A2%83%E9%85%8D%E7%BD%AE.md "4.开发环境配置"
+[334]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/FFmpeg/5.%20FFmpeg%E6%A0%B8%E5%BF%83%E5%8A%9F%E8%83%BD.md "5. FFmpeg核心功能"
+[335]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/%E9%9F%B3%E9%A2%91%E7%BC%96%E7%A0%81 "音频编码"
+[336]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E9%9F%B3%E9%A2%91%E7%BC%96%E7%A0%81/%E9%9F%B3%E9%A2%91%E7%BC%96%E7%A0%81%E6%A0%BC%E5%BC%8F.md "音频编码格式"
+[337]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E9%9F%B3%E9%A2%91%E7%BC%96%E7%A0%81/AAC.md "AAC"
+[338]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/%E9%9F%B3%E9%A2%91%E7%BC%96%E7%A0%81 "PCM"
+[339]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/%E9%9F%B3%E9%A2%91%E7%BC%96%E7%A0%81 "WAV"
       
 
 
diff --git "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md" "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"
index c82c89d4..e86877ad 100644
--- "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
+++ "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
@@ -507,6 +507,11 @@ void main() {
     }
 }
 ```
+相关功能介绍: 
+- 窗口，Window：主窗口，用于界面显示
+- 渲染，Render：GPU，硬件加速
+- 纹理，texture：存储描述信息
+- 画布，surface：内存中的一块地址，存储像素数据
 
 [上一篇: 8.GLES类及Matrix类](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/8.GLES%E7%B1%BB%E5%8F%8AMatrix%E7%B1%BB.md)  
 [下一篇: 10.GLSurfaceView+MediaPlayer播放视频](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md)
diff --git "a/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/PCM.md" "b/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/PCM.md"
new file mode 100644
index 00000000..32a18811
--- /dev/null
+++ "b/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/PCM.md"
@@ -0,0 +1,32 @@
+## PCM
+
+PCM(Pulse Code Modulation)，脉冲编码调制。人耳听到的是模拟信号，PCM是把声音从模拟信号转化为数字信号的技术。
+
+原理是用一个固定的频率对模拟信号进行采样，采样后的信号在波形上看就像一串连续的幅值不一的脉冲(脉搏似的短暂起伏的电冲击)，把这些脉冲的幅值按一定精度进行量化，这些量化后的数值被连续的输出、传输、处理或记录到存储介质中，所有这些组成了数字音频的产生过程(抽样、量化、编码三个过程)。
+
+### 声音的三要素
+
+- 音调：音频的快慢
+- 音量：震动的幅度
+- 音色：谐波
+
+### 量化
+- 采样大小(采样位数)：一个采样数据用多少bit存放，8bit、16bit
+- 采样率：采样的频率8k、16k、32k、44.1k、48k
+- 声道数：单声道、双声道、多声道
+
+
+### 大小计算
+一秒数据大小(码率) = 采样大小 * 采样率 * 声道数 (Kb/s)。
+假设采样率为8kHz、声道数、采样为16bit，时长为1s，则音频数据的大小为： 
+1 * 8000 * 2 * 16 = 256000 bit / 8 = 32000 byte / 1024 = 31.25KB
+
+### 数据排列方式
+
+
+
+左右声道每个样本点数据交错排列
+存储格式1： 交错、打包、packed
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/pcm_data_style.jpg?raw=true" width="100%" height="100%">
+存储格式2： 平面、平行、planar
diff --git "a/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/WAV.md" "b/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/WAV.md"
new file mode 100644
index 00000000..4f6e825d
--- /dev/null
+++ "b/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/WAV.md"
@@ -0,0 +1,12 @@
+## WAV
+
+WAVE文件格式是微软FIFF(Resource Interchange FileFormat)资源交换文件标准的一种，是针对于多媒体文件存储的一种文件格式和标准。
+
+一般而言，RIFF文件由文件头和数据两部分组成，一个WAVE文件由一个“WAVE"数据块组成，这个“WAVE”块又由一个fmt子数据块和一个data子数据块组成，也称这种格式为Canonical form(权威/牧师格式)，如下图所示: 
+
+<img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/wave_file_format.png?raw=true" width="100%" height="100%">
+
+
+
+
+- [WAV格式](https://docs.fileformat.com/audio/wav/)

From 60a6f624927a1ae4c7b5bcbfe77e4c57808b4b03 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 7 Jun 2023 19:10:12 +0800
Subject: [PATCH 127/213] udpate

---
 VideoDevelopment/.DS_Store                       | Bin 0 -> 6148 bytes
 ...4\226\347\240\201\346\240\274\345\274\217.md" |   3 +++
 2 files changed, 3 insertions(+)
 create mode 100644 VideoDevelopment/.DS_Store

diff --git a/VideoDevelopment/.DS_Store b/VideoDevelopment/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..fe0016573ba8e19c5945e1875b4ffbb37e84b05b
GIT binary patch
literal 6148
zcmeHKF-`+P47A~dBGIHml=}sKu!;g7-~$MPXo7--km$IIo(i7BpZEYXwuKZf6cjXQ
z9NDw$^X%%TILBt@i-*;T+1$)#aH2gkOpVX!6Wgl{(c_G3yII{|tuHs5^`v@tg4_c;
z!|&Ga>>Gc0{djwMI(qb99=iJ~Wu<@=kOERb3P=GcfSyg89VRMD0VyB_z7*j1p}~p0
za7>I(2SSVhzyawntYek{HYR|*a7;u7=1B!6)oaA?q$A&|t{0ApNjHz1aZcUrHKBOi
zj(m%9^PZ?E1*E{X0{gk0v;UvMf0+NbN!m#PDe$ip@L_qrT;P?ew@zM;y|%$G;H-Iv
r)36Q-LbPLGv}0`8j*p`#>l)X1-V4XXpd%l2p#BU{7nv0JYXv?5;<Ox6

literal 0
HcmV?d00001

diff --git "a/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/\351\237\263\351\242\221\347\274\226\347\240\201\346\240\274\345\274\217.md" "b/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/\351\237\263\351\242\221\347\274\226\347\240\201\346\240\274\345\274\217.md"
index 63e77d09..1834036f 100644
--- "a/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/\351\237\263\351\242\221\347\274\226\347\240\201\346\240\274\345\274\217.md"
+++ "b/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/\351\237\263\351\242\221\347\274\226\347\240\201\346\240\274\345\274\217.md"
@@ -1,5 +1,8 @@
 ## 音频编码格式
 
+原始的PCM音频数据也是非常大的数据量，因此也需要对其进行压缩编码。
+和视频编码一样，音频也有许多的编码格式，如：WAV、MP3、WMA、APE、FLAC等等，音乐发烧友应该对这些格式非常熟悉，特别是后两种无损压缩格式。
+
 音频压缩的本质： 消除冗余数据。
 
 人耳能察觉到的声音信号频率范围为20Hz ~ 20KHz，在这个频率范围以外的音频信号属于冗余信号。

From 782f028ebdc39d603bf5f72bc9e6efcaec8d1f71 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 8 Jun 2023 11:04:07 +0800
Subject: [PATCH 128/213] update

---
 VideoDevelopment/.DS_Store | Bin 6148 -> 6148 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/VideoDevelopment/.DS_Store b/VideoDevelopment/.DS_Store
index fe0016573ba8e19c5945e1875b4ffbb37e84b05b..913c247560b75eac4501248dc3b9a92ede877990 100644
GIT binary patch
delta 72
zcmZoMXfc=|&e%S&P;8=}A|vy}0Ba!8Bg4za;LlLNkjjw9;LhMPagHn_<Hmy~?3>v+
b1UMMmHy-@XJeglamyuz!qsU?Ai480OzzP$y

delta 72
zcmV-O0Jr~yFoZCW7XgNmaTbv-ApruBP&<<_6a<lv83_cJ^O%u;7I*=XTraWk7YC8>
e5VHpe5C{Q=vElavlMfUv1pxp60Kl_76vG2zvKL$c


From a6cb70ac9ced68a1a5209aaea3af95a48711a2c9 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 8 Jun 2023 15:13:40 +0800
Subject: [PATCH 129/213] update Audio part

---
 README.md                                      |  4 ++--
 ...226\347\240\201\346\240\274\345\274\217.md" | 18 ++++++++++++++++++
 2 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 32c75424..a5a5d450 100644
--- a/README.md
+++ b/README.md
@@ -710,8 +710,8 @@ Android学习笔记
 [335]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/%E9%9F%B3%E9%A2%91%E7%BC%96%E7%A0%81 "音频编码"
 [336]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E9%9F%B3%E9%A2%91%E7%BC%96%E7%A0%81/%E9%9F%B3%E9%A2%91%E7%BC%96%E7%A0%81%E6%A0%BC%E5%BC%8F.md "音频编码格式"
 [337]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E9%9F%B3%E9%A2%91%E7%BC%96%E7%A0%81/AAC.md "AAC"
-[338]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/%E9%9F%B3%E9%A2%91%E7%BC%96%E7%A0%81 "PCM"
-[339]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/%E9%9F%B3%E9%A2%91%E7%BC%96%E7%A0%81 "WAV"
+[338]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E9%9F%B3%E9%A2%91%E7%BC%96%E7%A0%81/PCM.md "PCM"
+[339]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E9%9F%B3%E9%A2%91%E7%BC%96%E7%A0%81/WAV.md "WAV"
       
 
 
diff --git "a/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/\351\237\263\351\242\221\347\274\226\347\240\201\346\240\274\345\274\217.md" "b/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/\351\237\263\351\242\221\347\274\226\347\240\201\346\240\274\345\274\217.md"
index 1834036f..84d9fe63 100644
--- "a/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/\351\237\263\351\242\221\347\274\226\347\240\201\346\240\274\345\274\217.md"
+++ "b/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/\351\237\263\351\242\221\347\274\226\347\240\201\346\240\274\345\274\217.md"
@@ -16,16 +16,27 @@
 
 ### WAV
 
+WAV是微软公司开发的一种声音文件格式，也叫波形声音文件，是最早的数字音频格式，被Windows平台及其应用程序广泛支持，但压缩率比较低。WAV编码是在PCM数据格式的前面加上44B的头部，分别用来描述PCM的采样率、声道数、数据格式等信息。WAV编码的特点是音质非常好、大量软件支持。一般应用于多媒体开发的中间文件、保存音乐和音效素材等。
+
 WAV编码是在PCM数据格式的前面加上44字节，分别用来描述PCM的采样率、声道数、数据根式等信息。
 特点： 音质非常好、大量软件都支持。
 使用场景：多媒体开发的中间文件、保存音乐和音效素材等。 
 
 ### MP3
+
+MP3全称是MPEG-1 Audio Layer 3，它在1992年合并至MPEG规范中。MP3能够以高音质、低采样率对数字音频文件进行压缩，应用最普遍。MP3具有不错的压缩比，使用LAME编码的中高码率的MP3文件，在听感上非常接近源WAV文件。其特点是音质在128kb/s以上表现还不错，压缩比比较高，兼容性好。主要应用于在高比特率下对兼容性有要求的音乐欣赏方面。
 MP3具有不错的压缩比，使用LAME编码的中高码率的MP3文件，听感上非常接近源WAV文件。
 特点：音质在128Kbps以上表现还不错，压缩比比较高，兼容性好。
 使用场景：高比特率下对兼容性有要求的音乐欣赏。
 
+### MP3Pro
+
+MP3Pro是由瑞典Coding科技公司开发的，其中包含了两大技术，一是来自于Coding科技公司所特有的解码技术，二是由MP3的专利持有者法国汤姆森多媒体公司和德国Fraunhofer集成电路协会共同研究的一项译码技术。MP3Pro可以在基本不改变文件大小的情况下改善原先的MP3音乐音质。它能够在用较低的比特率压缩音频文件的情况下，最大程度地保持压缩前的音质。
+
 ### AAC
+高级音频编码(Advanced Audio Coding，AAC)是由Fraunhofer IIS-A、杜比和AT&T共同开发的一种音频格式，它是MPEG-2规范的一部分。AAC所采用的运算法则与MP3的运算法则有所不同，AAC通过结合其他的功能来提高编码效率。AAC的音频算法在压缩能力上远远超过了以前的一些压缩算法，如MP3。它还同时支持多达48个音轨、15个低频音轨、更多种采样率和比特率、多种语言的兼容能力、更高的解码效率。总之，AAC可以在比MP3文件缩小30%的前提下提供更好的音质。
+AAC是新一代的音频有损压缩技术，它通过一些附加编码技术（如PS和SBR）衍生出LC-AAC、HE-AAC、HE-AAC V2这3种主要编码格式。在小于128kb/s码率下表现优异，且多用于视频中的音频编码。在128kb/s码率下的音频编码，多用于视频中的音频轨的编码。
+
 AAC是新一代的有损压缩技术，它通过一些附加编码技术(如PS、SBR)等，衍生出LC-AAC、HE-AAC、HE-AAC V2三种主要编码格式。
 
 特点：在小于128kbps码率下表现优异，且多用于视频中的音频编码。
@@ -33,7 +44,14 @@ AAC是新一代的有损压缩技术，它通过一些附加编码技术(如PS
 
 ### Ogg
 
+Ogg Vorbis是一种新的音频压缩格式，类似于MP3等现有的音乐格式，但有一点不同的是，它是完全免费、开放和没有专利限制的。Vorbis是这种音频压缩机制的名字，而Ogg则是一个计划的名字，该计划意图设计一个完全开放性的多媒体系统。Vorbis也是有损压缩，但通过使用更加先进的声学模型以减少损失，因此，同样位速率编码的Ogg与MP3相比听起来更好一些。Ogg编码音质好、完全免费，可以用更小的码率达到更好的音质，128kb/s的Ogg比192kb/s甚至更高的MP3还要出色，但是目前在媒体软件支持上还是不够友好。在高、中、低码率下都有良好的表现，但兼容性不够好，流媒体特性不支持。
+
 Ogg编码音质好、完全免费。
 可以用更小的码率达到更好的音质，128Kbps的Ogg比192Kbps甚至更高的MP3还要出色。但是目前媒体软件支持上还不够友好。 
 特点：高中低码率下都有良好的表现，兼容性不够好，流媒体特性不支持。
 使用场景：语音聊天的音频消息场景。 
+
+
+### APE
+
+APE是一种无损压缩音频格式，在音质不降低的前提下，可以压缩到传统无损格式WAV文件的一半。简单来讲，APE压缩与WinZip或WinRAR这类专业数据压缩软件压缩原理类似，只是APE等无损压缩数字音乐之后的APE音频文件是可以直接被播放的。APE的压缩速率是动态的，压缩时只压缩可被压缩的部分，不能被压缩的部分还是会被保留下来。

From be31dee8e94b1c4474611ac56ba8640bf3de3dd8 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 15 Jun 2023 11:28:32 +0800
Subject: [PATCH 130/213] update

---
 ...72\347\241\200\347\237\245\350\257\206.md" | 24 ++++++---
 ...55\346\224\276\347\256\200\344\273\213.md" | 50 +++++++++++++++++++
 .../\345\205\263\351\224\256\345\270\247.md"  |  7 +++
 .../AVI.md"                                   | 31 ++++++++++++
 4 files changed, 104 insertions(+), 8 deletions(-)
 create mode 100644 "VideoDevelopment/FFmpeg/6.\350\247\206\351\242\221\346\222\255\346\224\276\347\256\200\344\273\213.md"
 create mode 100644 "VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/AVI.md"

diff --git "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
index b6a15a82..664e9d8e 100644
--- "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
+++ "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/1.\351\237\263\350\247\206\351\242\221\345\237\272\347\241\200\347\237\245\350\257\206.md"
@@ -5,6 +5,13 @@
 基本概念
 ---
 
+- 图像
+    图像是人类视觉的基础，是自然景物的客观反映，是人类认识世界和人类本身发展的重要源泉。“图”是物体反射或透射光的分布，“像”是人的视觉系统所接收的图在人脑中所形成的印象或认识。图像是客观对象的一种相似性的、生动性的描述或写真，是人类社会活动中最常用的信息载体，或者说图像是客观对象的一种表示，它包含了被描述对象的有关信息。广义上，图像就是所有具有视觉效果的画面，包括纸介质的、底片或照片上的、电视上的、投影仪或计算机屏幕上的画面。在计算机领域，与图像相关的概念非常多，包括像素、PPI、图像位深度等。
+
+    图像本质上是由很多“带有颜色的点”组成的，而这些点，就是“像素”。像素的英文叫Pixel，缩写为PX。这个单词是由图像(Picture)和元素(Element)这两个单词所组成的。
+
+    像素是图像显示的基本单位，分辨率是指一张图片的宽度和高度的乘积，单位是像素。通常说一张图片的大小，例如1920×1080像素，是指宽度为1920像素，高度为1080像素。它们的乘积是1920×1080=2 073 600，也就是说这张图片是两百万像素的。1920×1080，也被称为这幅图片的分辨率
+
 - 媒体
 
     是表示，传输，存储信息的载体，常人们见到的文字、声音、图像、图形等都是表示信息的媒体。
@@ -88,10 +95,15 @@
     LCD液晶显示器和传统的CRT显示器，分辨率都是重要的参数之一。传统CRT显示器所支持的分辨率较有弹性，而LCD的像素间距已经固定，所以支持的显示模式不像CRT那么多。LCD的最佳分辨率，也叫最大分辨率，在该分辨率下，液晶显示器才能显现最佳影像。
 
 每个像素有RGB三种颜色组成，每色有8bit，取值范围为(0 ~ 255)也就是2的8次方。这种方式表达出来的颜色，也被称为24位色(占用24bit)。
-
 1080P的P是指Progressive scan(逐行扫描)，即垂直方向像素点，也就是高。所以1920*1080叫1080P，不叫1920P。
 
 
+RGB为3个分量，假如每个分量占8b，取值分别为0～255。那么这3个分量的组合取值为256×256×256=16 777 216种，因此也简称为1600万色。这种颜色范围已经超过了人眼可见的全部色彩，所以又叫真彩色。更高的精度，对于人眼来讲，已经没有意义了，完全识别不出来。RGB这3色，每色有8b，这种方式表达出来的颜色，也被称为24位真彩色。
+
+- PPI
+    每英寸的像素数(Pixels Per Inch，PPI)是手机屏幕（或计算机显示器）上每英寸面积到底能放下多少“像素”。这个值越高，图像就越清晰细腻。
+    PPI是像素的密度单位，PPI值越高，画面的细节就越丰富，所以数码相机拍出来的图片因品牌或生产时间不同可能有所不同，常见的有72PPI、180PPI和300PPI。DPI(Dots Per Inch)是指输出分辨率，是针对输出设备而言的，一般的激光打印机的输出分辨率为[300DPI，600DPI]，印刷的照排机可达到[1200DPI，2400DPI]，常见的冲印一般为[150DPI，300DPI]。
+
 - DTS
 
     Decode Time Stamp，主要用于标识读入内存中的比特流在什么时候开始送入解码器中进行解码。
@@ -279,7 +291,6 @@ U和V不是基础信号，他俩都是被正交调制的。早期的电视都是
 
 YUV和RGB视频信号相比，最大的优点在于只需要占用极少的带宽，YUV只需要占用RGB一般的带宽。
 
-
 YUV 色彩编码模型，其设计初衷为了解决彩色电视机与黑白电视的兼容问题，利用了人类眼睛的生理特性（对亮度敏感，对色度不敏感），允许降低色度的带宽，降低了传输带宽。
 
 在计算机系统中应用尤为广泛，利用 YUV 色彩编码模型可以降低图片数据的内存占用，YUV只需要占用RGB一般的带宽，从而提高数据处理效率。
@@ -287,10 +298,6 @@ YUV 色彩编码模型，其设计初衷为了解决彩色电视机与黑白电
 另外，YUV 编码模型的图像数据一般不能直接用于显示，还需要将其转换为 RGB（RGBA） 编码模型，才能够正常显示图像。
 
 
-————————————————
-版权声明：本文为CSDN博主「字节流动」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
-原文链接：https://blog.csdn.net/Kennethdroid/article/details/94031821
-
 
 YUV码流的存储格式其实与其采样的方式密切相关，主流的采样方式有四种，
 - YUV 4:4:4
@@ -372,8 +379,9 @@ PAR DAR SAR
 
 ##### 硬件加速
 
-硬件加速(Hardware acceleration)就是利用硬件模块来替代软件算法以充分利用硬件固有的快速特性。硬件加速通常比软件算法的效率要高。
-将2D、3D图形计算相关工作交给GPU处理，从而释放CPU的压力，也是属于硬件加速的一种。
+
+中央处理器(Central Processing Unit，CPU)，包括算术逻辑部件(Arithmetic Logic Unit，ALU)和高速缓冲存储器(Cache)及实现它们之间联系的数据(Data)、控制及状态的总线(Bus)。GPU即图形处理器(Graphics Processing Unit)，专为执行复杂的数学和几何计算而设计的，拥有二维或三维图形加速功能。GPU相比于CPU具有更强大的二维、三维图形计算能力，可以让CPU从图形处理的任务中解放出来，执行其他更多的系统任务，这样可以大大提高计算机的整体性能。硬件加速(Hardware Acceleration)就是利用硬件模块来替代软件算法以充分利用硬件所固有的快速特性，硬件加速通常比软件算法的效率要高。例如将与二维、三维图形计算相关的工作交给GPU处理，从而释放CPU的压力，是属于硬件加速的一种。
+
 
 
 
diff --git "a/VideoDevelopment/FFmpeg/6.\350\247\206\351\242\221\346\222\255\346\224\276\347\256\200\344\273\213.md" "b/VideoDevelopment/FFmpeg/6.\350\247\206\351\242\221\346\222\255\346\224\276\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..8614e0e5
--- /dev/null
+++ "b/VideoDevelopment/FFmpeg/6.\350\247\206\351\242\221\346\222\255\346\224\276\347\256\200\344\273\213.md"
@@ -0,0 +1,50 @@
+## 视频播放简介
+
+
+解封装是指将输入的封装格式的数据，分离成为音频流压缩编码数据和视频流压缩编码数据。封装格式种类有很多，例如MP4、MKV、RMVB、TS、FLV、AVI等，其作用就是将已经压缩编码的视频数据和音频数据按照一定的格式放到一起。例如FLV格式的数据，经过解封装操作后，输出H.264编码的视频码流和AAC编码的音频码流。
+<img src="https://github.com/CharonChui/Pictures/blob/master/video_play_list_1.png" />
+
+
+### 1.解协议    
+解协议是指将流媒体协议的数据，解析为标准的封装格式数据。音视频在网络上传播的时候，常采用各种流媒体协议，例如HTTP、RTMP、RTMP、MMS等。这些协议在传输音视频数据的同时，也会传输一些信令数据。这些信令数据包括对播放的控制（播放、暂停、停止），或者对网络状态的描述等。在解协议的过程中会去除信令数据而只保留音视频数据。例如采用RTMP协议传输的数据，经过解协议操作后，输出FLV格式的数据。
+注意：“文件”本身也是一种“协议”，常见的流媒体协议有HTTP、RTSP、RTMP等。
+
+### 2.解封装
+
+解封装是指将输入的封装格式的数据，分离成为音频流压缩编码数据和视频流压缩编码数据。封装格式种类有很多，例如MP4、MKV、RMVB、TS、FLV、AVI等，其作用就是将已经压缩编码的视频数据和音频数据按照一定的格式放到一起。例如FLV格式的数据，经过解封装操作后，输出H.264编码的视频码流和AAC编码的音频码流。
+
+### 3.解码
+
+解码是指将视频／音频压缩编码数据，解码成为非压缩的视频／音频原始数据。音频的压缩编码标准包含AAC、MP3、AC-3等，视频的压缩编码标准则包含H.264、MPEG-2、VC-1等。解码是整个系统中最重要也是最复杂的一个环节。通过解码，压缩编码的视频数据输出成为非压缩的颜色数据，例如YUV420P、RGB等。压缩编码的音频数据输出成为非压缩的音频抽样数据，例如PCM数据。
+
+### 4.音视频同步
+根据解封装模块在处理过程中获取的参数信息，同步解码出来的视频和音频数据，被送至系统的显卡和声卡播放出来。为什么需要音视频同步呢？媒体数据经过解复用流程后，音频／视频解码便是独立的，也是独立播放的，而在音频流和视频流中，其播放速度是由相关信息指定的，例如视频是根据帧率，音频是根据采样率。从帧率及采样率即可知道视频／音频播放速度。声卡和显卡均是以一帧数据来作为播放单位，如果单纯依赖帧率及采样率进行播放，在理想条件下，应该是同步的，不会出现偏差。
+
+下面以一个44.1kHz的AAC音频流和24f/s的视频流为例来说明。如果一个AAC音频frame每个声道包含1024个采样点，则一个frame的播放时长为(1024/44 100)×1000ms≈23.27ms，而一个视频frame播放时长为1000ms/24≈41.67ms。理想情况下，音视频完全同步，但实际情况下，如果用上面那种简单的方式，慢慢地就会出现音视频不同步的情况，要么是视频播放快了，要么是音频播放快了。可能的原因包括：一帧的播放时间难以精准控制；音视频解码及渲染的耗时不同，可能造成每一帧输出有一点细微差距，长久累计，不同步便越来越明显；音频输出是线性的，而视频输出可能是非线性的，从而导致有偏差；媒体流本身音视频有差距（特别是TS实时流，音视频能播放的第1个帧起点不同），所以解决音视频同步问题引入了时间戳，它包括几个特点：首先选择一个参考时钟（要求参考时钟上的时间是线性递增的），编码时依据参考时钟给每个音视频数据块都打上时间戳。播放时，根据音视频时间戳及参考时钟来调整播放，所以视频和音频的同步实际上是一个动态的过程，同步是暂时的，不同步则是常态。
+
+ffplay是使用FFmpeg API开发的功能完善的开源播放器。在ffplay中各个线程如图5-45所示，扮演角色如下：read_thread线程扮演着图中Demuxer的角色；video_thread线程扮演着图中VideoDecoder的角色；audio_thread线程扮演着图中Audio Decoder的角色。主线程中的event_loop函数循环调用refresh_loop_wait_event则扮演着视频渲染的角色。回调函数sdl_audio_callback扮演着图中音频播放的角色。VideoState结构体变量则扮演着各个线程之间的信使。
+
+- (1)read_thread线程负责读取文件内容，将video和audio内容分离出来后生成packet，将packet输出到packet队列中，包括Video Packet Queue和Audio Packet Queue，不考虑subtitle。
+- (2)video_thread线程负责读取Video PacketsQueue队列，将video packet解码得到VideoFrame，将Video Frame输出到Video FrameQueue队列中。
+- (3)audio_thread线程负责读取Audio PacketsQueue队列，将audio packet解码得到AudioFrame，将Audio Frame输出到Audio FrameQueue队列中。
+- (4)主线程→event_loop→refresh_loop_wait_event负责读取Video Frame Queue中的video frame，调用SDL进行显示，其中包括了音视频同步控制的相关操作。
+- (5)SDL的回调函数sdl_audio_callback负责读取Audio Frame Queue中的audio frame，对其进行处理后，将数据返回给SDL，然后SDL进行音频播放。
+
+FFmpeg解码流程图:  
+<img src="https://github.com/CharonChui/Pictures/blob/master/ffmpg_decod_list_1.jpg" />
+
+- (1)注册所有容器格式和CODEC，使用av_register_all，最新版本中无须调用该函数。
+- (2)打开文件av_open_input_file，最新版本为avformat_open_input。
+- (3)从文件中提取流信息av_find_stream_info。
+- (4)枚举所有流，查找的种类为CODEC_TYPE_VIDEO。
+- (5)查找对应的解码器avcodec_find_decoder。
+- (6)打开编解码器avcodec_open。
+- (7)为解码帧分配内存avcodec_alloc_frame。
+- (8)不停地从码流中提取帧数据av_read_frame。
+- (9)判断帧的类型，对于视频帧则调用avcodec_decode_video。
+- (10)解码完后，释放解码器avcodec_close。
+- (11)关闭输入文件av_close_input_file。
+
+注意：该流程图为FFmpeg 2.x的版本，最新的FFmpeg 4.x系列的流程图略有改动。
+
+
diff --git "a/VideoDevelopment/\345\205\263\351\224\256\345\270\247.md" "b/VideoDevelopment/\345\205\263\351\224\256\345\270\247.md"
index d4ad6c16..878ca9db 100644
--- "a/VideoDevelopment/\345\205\263\351\224\256\345\270\247.md"
+++ "b/VideoDevelopment/\345\205\263\351\224\256\345\270\247.md"
@@ -26,6 +26,13 @@ GOP(Group of Pictures)是一组连续的画面，由一张I帧和数张B/P帧组
 
 **编码器将多张图像进行编码后生产成一段一段的 GOP ( Group of Pictures ) ， 解码器在播放时则是读取一段一段的 GOP 进行解码后读取画面再渲染显示。**GOP ( Group of Pictures) 是一组连续的画面，由一张 I 帧和数张 B / P  帧组成，是视频图像编码器和解码器存取的基本单位，它的排列顺序将会一直重复到影像结束。I  帧是内部编码帧（也称为关键帧），P帧是前向预测帧（前向参考帧），B 帧是双向内插帧（双向参考帧）。简单地讲，I 帧是一个完整的画面，而 P 帧和 B 帧记录的是相对于 I 帧的变化。如果没有 I 帧，P 帧和 B 帧就无法解码。
 
+GOP是指一组连续的图像，由一个I帧和多个B/P帧组成，是编解码器存取的基本单位。GOP结构常用的两个参数为M和N，M用于指定GOP中首个P帧和I帧之间的距离，N用于指定一个GOP的大小。例如M=1，N=15，GOP结构为IPBBPBBPBBPBBPB IPBBPBB。GOP指两个I帧之间的距离，Reference指两个P帧之间的距离。一个I帧所占用的字节数大于一个P帧，一个P帧所占用的字节数大于一个B帧，所以在码率不变的前提下，GOP值越大，P、B帧的数量就会越多，平均每个I、P、B帧所占用的字节数就越多，也就更容易获取较好的图像质量；Reference越大，B帧的数量就越多，同理也更容易获得较好的图像质量。需要说明的是，通过提高GOP值来提高图像质量是有限度的，在遇到场景切换的情况时，H.264编码器会自动强制插入一个I帧，此时实际的GOP值被缩短了。
+
+另一方面，在一个GOP中，P、B帧是由I帧预测得到的，当I帧的图像质量比较差时，会影响到一个GOP中后续P、B帧的图像质量，直到下一个GOP开始才有可能得以恢复，所以GOP值也不宜设置得过大。同时，由于P、B帧的复杂度大于I帧，所以过多的P、B帧会影响编码效率，使编码效率降低。另外，过长的GOP还会影响Seek操作的响应速度，由于P、B帧是由前面的I或P帧预测得到的，所以Seek操作需要直接定位，在解码某个P或B帧时，需要先解码得到本GOP内的I帧及之前的N个预测帧才可以，GOP值越长，需要解码的预测帧就越多，Seek响应的时间也越长。
+
+GOP的形式通常有两种，包括闭合式GOP和开放式GOP。闭合式GOP只需参考本GOP内的图像，而不需参考前后GOP的数据。这种模式决定了闭合式GOP的显示顺序总是以I帧开始而以P帧结束。开放式GOP中的B帧解码时可能要用到其前一个GOP或后一个GOP的某些帧。码流中包含B帧的时候才会出现开放式GOP。
+
+
 ### IDR
 
 IDR（Instantaneous Decoding Refresh）是H.264视频编码中的一种特殊的I帧。它包含了所有的视频序列信息，并且通过强制性地要求解码器重新初始化来保证解码正确性。IDR通常用于视频流中断或丢失时，重新恢复视频流的一种方式。
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/AVI.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/AVI.md"
new file mode 100644
index 00000000..333b78dc
--- /dev/null
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/AVI.md"
@@ -0,0 +1,31 @@
+## AVI
+
+音频视频交错(Audio Video Interleaved，AVI)格式，是一门成熟的老技术，尽管国际学术界公认AVI已经属于被淘汰的技术，但是简单易懂的开发API，还在被广泛使用。AVI符合RIFF(ResourceInterchange File Format)文件规范，使用四字符码(Four-Character Code，FOURCC)表征数据类型。AVI的文件结构分为头部、主体和索引3部分。主体中图像数据和声音数据是交互存放的，从尾部的索引可以索引到想放的位置。AVI本身只提供了这么一个框架，内部的图像数据和声音数据格式可以是任意的编码形式。因为索引放在了文件尾部，所以在播放网络流媒体时已力不从心。例如从网络上下载AVI文件，如果没有下载完成，则很难正常播放出来。
+
+
+AVI中有两种最基本的数据单元，一个是Chunks，另一个是Lists，结构体如下：
+
+```c++
+// Chunks
+typedef struct {
+    DWORD dwFourcc;
+    DWORD dwSize;          // data
+    BYTE data[dwSize];     // contains headers or audio/video data
+} CHUNK;
+
+// Lists
+typedef struct {
+    DWORD dwList;
+    DWORD dwSize;
+    DWORD dwFourCC;
+    BYTE data[dwSize - 4];
+} LIST;
+```
+
+由如上代码可知，Chunks数据块由一个四字符码、4B的data size（指下面的数据大小）及数据组成。Lists由4部分组成，包括4B的四字符码、4B的数据大小（指后面列的两部分数据大小）、4B的list类型及数据组成。与Chunks数据块不同的是，Lists数据内容可以包含字块（Chunks或Lists）。
+
+
+
+
+
+

From 4592dad939676f1ea40d5732c37a6c5cf1982d66 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 19 Jun 2023 11:14:14 +0800
Subject: [PATCH 131/213] update

---
 README.md                                        |   7 +++++--
 VideoDevelopment/.DS_Store                       | Bin 6148 -> 0 bytes
 ...0\270\345\277\203\345\212\237\350\203\275.md" |   0
 3 files changed, 5 insertions(+), 2 deletions(-)
 delete mode 100644 VideoDevelopment/.DS_Store
 rename "VideoDevelopment/FFmpeg/5. FFmpeg\346\240\270\345\277\203\345\212\237\350\203\275.md" => "VideoDevelopment/FFmpeg/5.FFmpeg\346\240\270\345\277\203\345\212\237\350\203\275.md" (100%)

diff --git a/README.md b/README.md
index a5a5d450..ee9da0dd 100644
--- a/README.md
+++ b/README.md
@@ -79,6 +79,7 @@ Android学习笔记
         - [fMP4格式详解][255]
         - [视频封装格式][256]
         - [M3U8][321]
+        - [AVI][341]
     - [视频编码][257]
         - [视频编码原理][331]
         - [AV1][258]
@@ -115,6 +116,7 @@ Android学习笔记
         - [3.FFmpeg切片][325]
         - [4.开发环境配置][333]
         - [5. FFmpeg核心功能][334]
+        - [6.视频播放简介][340]
 - [操作系统][263]
     - [1.操作系统简介][264]
     - [2.进程与线程][265]
@@ -712,7 +714,8 @@ Android学习笔记
 [337]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E9%9F%B3%E9%A2%91%E7%BC%96%E7%A0%81/AAC.md "AAC"
 [338]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E9%9F%B3%E9%A2%91%E7%BC%96%E7%A0%81/PCM.md "PCM"
 [339]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E9%9F%B3%E9%A2%91%E7%BC%96%E7%A0%81/WAV.md "WAV"
-      
+[340]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/FFmpeg/6.%E8%A7%86%E9%A2%91%E6%92%AD%E6%94%BE%E7%AE%80%E4%BB%8B.md  "6.视频播放简介"
+[341]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E8%A7%86%E9%A2%91%E5%B0%81%E8%A3%85%E6%A0%BC%E5%BC%8F/AVI.md "AVI"
 
 
 Developed By
@@ -736,4 +739,4 @@ License
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
-    limitations under the License.
\ No newline at end of file
+    limitations under the License.
diff --git a/VideoDevelopment/.DS_Store b/VideoDevelopment/.DS_Store
deleted file mode 100644
index 913c247560b75eac4501248dc3b9a92ede877990..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6148
zcmeH~u}T9$5QhKJBLr+xiRHe6Z?J@@jbPymh(>Ip35a0lb=Fq;p1y$p%uXPB3aKpg
zpD_Dh=4N)eueiAZVAF^BAus_jrn}<Vm!bK6_krzXWS45O$2D%|_g9O{<#I8|{yyNf
zBOLR0ixs}qk8l>jJDlKjbK~yy{q5yx|IyY#9xoFC5fA|p5CIX`hCnvW@!mGc$`Jt(
z_*Vq{{ZQzxHMMUVuMRFT0#G}K!+0ID1hsg8T2uR`jL@u=Qd_Czh+(aq@sfEpwQt(W
zVL5zQo@_axSe(xNOQgeUQ>`K(0-p)^>`j|^|39MtF#mgwOaw&Wj}owMc0QZ(;j*_5
y9@Bemp<mF~#@tBf60MjTt(bqj6(4Nm6~E^Fn%Xywa>k>ast*C@A`^k%An*afEFlvB

diff --git "a/VideoDevelopment/FFmpeg/5. FFmpeg\346\240\270\345\277\203\345\212\237\350\203\275.md" "b/VideoDevelopment/FFmpeg/5.FFmpeg\346\240\270\345\277\203\345\212\237\350\203\275.md"
similarity index 100%
rename from "VideoDevelopment/FFmpeg/5. FFmpeg\346\240\270\345\277\203\345\212\237\350\203\275.md"
rename to "VideoDevelopment/FFmpeg/5.FFmpeg\346\240\270\345\277\203\345\212\237\350\203\275.md"

From 629415372887d2d09b507119110b4aee32188a40 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 21 Jun 2023 19:54:57 +0800
Subject: [PATCH 132/213] update

---
 .../1.OpenCV\347\256\200\344\273\213.md"       | 18 ++++++++++++++++++
 ...347\220\206_NAT\347\251\277\351\200\217.md" | 10 +++++++++-
 2 files changed, 27 insertions(+), 1 deletion(-)
 create mode 100644 "VideoDevelopment/OpenCV/1.OpenCV\347\256\200\344\273\213.md"

diff --git "a/VideoDevelopment/OpenCV/1.OpenCV\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenCV/1.OpenCV\347\256\200\344\273\213.md"
new file mode 100644
index 00000000..e1ab5d76
--- /dev/null
+++ "b/VideoDevelopment/OpenCV/1.OpenCV\347\256\200\344\273\213.md"
@@ -0,0 +1,18 @@
+1.OpenCV简介
+===
+
+![image](https://github.com/CharonChui/Pictures/blob/master/cdn.png?raw=true)
+
+### OpenCV4简介
+
+OpenCV是一个基于BSD许可(开源)发行的跨平台计算机视觉和机器学习软件库，可以运行在linux、windows、android和Mac OS操作系统上。
+
+它轻量级而且高效--由一系列C函数和少量C++类构成，同时提供了Python、Ruby、MATLAB等语言的接口，实现了图像处理和计算机视觉方面的很多通用算法。
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/VideoDevelopment/P2P\346\212\200\346\234\257/P2P\345\216\237\347\220\206_NAT\347\251\277\351\200\217.md" "b/VideoDevelopment/P2P\346\212\200\346\234\257/P2P\345\216\237\347\220\206_NAT\347\251\277\351\200\217.md"
index 0b3bd000..b8ffe932 100644
--- "a/VideoDevelopment/P2P\346\212\200\346\234\257/P2P\345\216\237\347\220\206_NAT\347\251\277\351\200\217.md"
+++ "b/VideoDevelopment/P2P\346\212\200\346\234\257/P2P\345\216\237\347\220\206_NAT\347\251\277\351\200\217.md"
@@ -5,7 +5,6 @@ P2P原理_NAT穿透
 
 NAT（Network Address Translation，网络地址转换），也叫做网络掩蔽或者IP掩蔽。NAT是一种网络地址翻译技术，主要是将内部的私有IP地址（private IP）转换成可以在公网使用的公网IP（public IP）。
 
-
 网络地址转换，就是替换IP报文头部的地址信息。NAT通常部署在一个组织的网络出口位置，通过将内部网络IP地址替换为出口的IP地址提供公网可达性和上层协议的连接能力。那么，什么是内部网络IP地址？
 
  [RFC1918](https://datatracker.ietf.org/doc/rfc1918/)规定了三个保留地址段落：10.0.0.0-10.255.255.255；172.16.0.0-172.31.255.255；192.168.0.0-192.168.255.255。这三个范围分别处于A,B,C类的地址段，不向特定的用户分配，被IANA作为私有地址保留。这些地址可以在任何组织或企业内部使用，和其他Internet地址的区别就是，仅能在内部使用，不能作为全球路由地址。这就是说，出了组织的管理范围这些地址就不再有意义，无论是作为源地址，还是目的地址。对于一个封闭的组织，如果其网络不连接到Internet，就可以使用这些地址而不用向IANA提出申请，而在内部的路由管理和报文传递方式与其他网络没有差异。
@@ -14,6 +13,15 @@ NAT（Network Address Translation，网络地址转换），也叫做网络掩
 
  那么，NAT与此同时也带来一些弊端：首先是，NAT设备会对数据包进行编辑修改，这样就降低了发送数据的效率；此外，各种协议的应用各有不同，有的协议是无法通过NAT的（不能通过NAT的协议还是蛮多的），这就需要通过穿透技术来解决。我们后面会重点讨论穿透技术。
 
+### NAT原理
+内网主机向外网主机发送的网络包，在经过NAT时，IP和PORT会被替换为NAT为该主机分配的外网IP/PORT，也就是该内网主机在NAT上的出口IP/PORT，外网主机收到该网络包后，会视该网络包是从NAT发送的。
+外网主机只能通过NAT为该内网主机分配的外网IP/PORT，向它发送网络包，内网主机的本地地址对外界不可见，网络包在经过NAT的时候，会被NAT做外网IP/PORT到内网IP/PORT的转换。
+可见，NAT维护内网主机内网地址和在NAT上为它分配的外网地址之间的映射关系，需要维护一张关联表。
+NAT在两个传输方向上做两次地址转化，出方向做源(src)信息转换，入方向做目的(dst)信息替换，内外网地址转换是在NAT上自动完成的。NAT网关的存在对通信双方是透明的。 
+
+那NAT是符合环节IPv4地址枯竭的问题的呢？ 
+答案是端口多路复用，通过PAT(Port Address Translation)，让NAT背后的多台内网主机共享一个外网IP，最大限度的节省外网IP资源。
+
 
 
 **虽然实际过程远比这个复杂，但上面的描述概括了NAT处理报文的几个关键特点：**

From ee2b06649d63b6aa0266a1d2b6a88d76a32c7553 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 21 Jun 2023 20:57:31 +0800
Subject: [PATCH 133/213] add OpenCV

---
 .../1.OpenCV\347\256\200\344\273\213.md"      | 181 +++++++++++++++++-
 1 file changed, 178 insertions(+), 3 deletions(-)

diff --git "a/VideoDevelopment/OpenCV/1.OpenCV\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenCV/1.OpenCV\347\256\200\344\273\213.md"
index e1ab5d76..4523a904 100644
--- "a/VideoDevelopment/OpenCV/1.OpenCV\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenCV/1.OpenCV\347\256\200\344\273\213.md"
@@ -1,13 +1,188 @@
 1.OpenCV简介
 ===
 
-![image](https://github.com/CharonChui/Pictures/blob/master/cdn.png?raw=true)
+[OpenCV官网](https://opencv.org/)
+
 
 ### OpenCV4简介
 
-OpenCV是一个基于BSD许可(开源)发行的跨平台计算机视觉和机器学习软件库，可以运行在linux、windows、android和Mac OS操作系统上。
+OpenCV是一个基于Apache2.0许可（开源）发行的跨平台计算机视觉和机器学习软件库，可以运行在Linux、Windows、Android和Mac OS操作系统上。 [1] 它轻量级而且高效——由一系列 C 函数和少量 C++ 类构成，同时提供了Python、Ruby、MATLAB等语言的接口，实现了图像处理和计算机视觉方面的很多通用算法。
+
+OpenCV用C++语言编写，它具有C ++，Python，Java和MATLAB接口，并支持Windows，Linux，Android和Mac OS，OpenCV主要倾向于实时视觉应用，并在可用时利用MMX和SSE指令， 如今也提供对于C#、Ch、Ruby，GO的支持。
+
+
+### OpenCV4的模块架构
+
+- calib3d（由calibration（标准）和3D 两个术语缩写组合而成）：主要包含相机定位与
+立体视觉等功能，例如物体位姿估计、三维重建、摄像头标定等；
+- core（核心功能模块）：主要包含OpenCV 库的基础结构以及基本操作，例如OpenCV
+基本数据结构、绘图函数、数组操作相关函数、动态数据结构等；
+- dnn（深度学习模块）：主要包括构建神经网络、加载序列化网络模型等，但目前仅适
+用于正向传递计算；
+- features2d（由feature（特征）和2D 两个术语缩写组合而成）：主要功能包括处理图
+像特征点，例如特征检测、描述与匹配等；
+- flann（快速近似最近邻库）：是高维的近似近邻快速搜索算法库，主要包含快速近似
+近邻搜索与聚类等；
+- gapi：加速常规的图像处理，与其他模块相比，此模块主要充当框架，而不是某些特定
+的计算机视觉算法；
+- highgui（高层GUI）：包含创建和操作显示图像的窗口、处理鼠标事件以及键盘命令、
+提供图形交互可视化界面等；
+- imgcodecs（图像文件读取与保存模块）：主要用于图像文件读取与保存；
+- imgproc（重要的图像处理模块）：主要包含图像滤波、几何变换、直方图、特征检测
+与目标检测等；
+- ml（机器学习模块）：主要为统计分类、回归和数据聚类等；
+- objdetect（目标检测模块）：主要用于图像目标检测，例如检测Haar 特征；
+- photo（计算摄影模块）：主要包含图像修复和去噪等；
+- stitching（图像拼接模块）：主要包含特征点寻找与匹配图像、估计旋转、自动校准、
+接缝估计等图像拼接过程的相关内容；
+- video（视频分析模块）：主要包含运动估计、背景分离、对象跟踪等视频处理相关内
+容；
+- videoio（视频输入/输出模块）：主要用于读取/写入视频或者图像序列。
+
+
+### 数据结构：Mat
+
+API：
+- imread(..url...)：加载本地图像
+	默认的BGR 彩色图像加载方式，此外支持灰度图像和任意格式。注意：在OpenCV中颜色值写法是BGR，而不是RGB。
+- imshow("namexx", ...url...)：显示图像
+- getStructuringElement(...)：获取腐蚀的内核矩阵
+- erode(...)：腐蚀(源图像、目的图像、内核矩阵）
+- blur(...) ：模糊
+- cvtColor(...)：颜色转换
+- Canny(...)：提取边缘
+- waitKey(...)：等待按键
+- imwrite(...): 图片保存，支持各种格式
+
+```c++
+// 图像模糊（blur）
+#include <iostream>
+#include <opencv2/opencv.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc/imgproc.hpp>
+using namespace std;
+using namespace cv;
+int main_p002(int argc, const char * argv[]) {
+	// insert code here...
+	Mat imgSource = imread("../../images/p1_tutu.jpg");//读取图片
+	imshow("source", imgSource);//显示图片在名为"source"的窗口里
+	Mat imgDst;//用来存放模糊之后的图片
+	blur(imgSource, imgDst, Size(20, 20));//进行均值滤波，在20*20 的像素内取平均值然
+	后低于的或者高于的被替换掉
+	imshow("target", imgDst);//显示图片在名为"target"的窗口里
+	waitKey(0);//等待按键操作再执行后续按随意键将进行下一步return 程序结束
+	return 0;
+}
+```
+
+
+#### 重要概念： 图像就是函数
+
+把一张图片放到坐标系中后，我们就能把一副图像看作是一个二维函数，定义成
+f(x, y)。
+![image](https://github.com/CharonChui/Pictures/blob/master/opencv_image_two.png?raw=true)
+
+
+任何一对空间坐标(x, y)处f的值看作该坐标点处的强度(intensity)或灰度。
+
+我们把每一坐标点处的强度在三维空间中看看。
+
+![image](https://github.com/CharonChui/Pictures/blob/master/opencv_image_san.png?raw=true)
+
+
+把图像看作是一个二维函数，将对后续的图像处理理解和计算带来极大的便利，对图像
+的处理就是对函数的处理。需要强调的是把图像作为二维函数时，它是一个离散函数，且取
+值范围有所限定，比如x, y 轴的坐标值，函数取值也限定在某个区间之内（不一定是[0-225]）。
+另外，图像作为函数，不可能得到上面类似f(x, y)=x**2+y**2 这样的表达式。
+对于彩色图像，同样可以看作是一个向量函数。f(x, y) = [r(x, y), g(x, y), b(x, y)]
+
+
+## Mat对象
+
+Mat 对象：OpenCV2.0 之后引进的图像数据结构、自动分配内存、不存在内存泄漏的问
+题，是面向对象的数据结构，分了两个部分，头部分与数据部分。     
+
+文档上边说，Mat 的数据成员由头部和数据组成。
+
+Mat 类的声明中的数据成员部分：    
+- Mat 的头部信息：flags，dims，rows，cols，data 指针，refcount 指针。
+- Mat 的数据部分：显然，意味着data 指针指向的空间。
+
+而refcount 指针，就是起引用计数的作用。有了引用计数机制，使得我们的Mat 能够很好
+地支持浅拷贝的操作：使用等号操作符给Mat 赋值（或者使用拷贝构造的时候），仅拷贝
+头部信息，如此能够节约许多的空间和时间。而深拷贝的工作，就交给成员方法clone()和
+copyTo()。
+
+
+### Mat对象的发展史
+
+在早期的OpenCV1.x 版本中，图像的处理是通过IplImage（该名称源于Intel 的另一个
+开源库Intel Image Processing Library ，缩写成IplImage）结构来实现的。
+
+早期的OpenCV 是用C 语言编写，因此提供的借口也是C 语言接口，其源代码完全是C
+的编程风格。IplImage 结构是OpenCV 矩阵运算的基本数据结构。
+
+到OpenCV2.x 版本，OpenCV 开源库引入了面向对象编程思想，大量源代码用C++重写。
+
+Mat 类(Matrix 的缩写) 是OpenCV 用于处理图像而引入的一个封装类。
+从功能上讲，Mat 类在IplImage 结构的基础上进一步增强，并且，由于引入C++高级编
+程特性，Mat 类的扩展性大大提高，Mat 类的内容在后期的版本中不断丰富。    
+该对象会自动分配内存、自动管理内存分配和释放，不存在内存泄漏的问题，OpenCV2.x
+版本以后，越来越多的函数实现了MatLab 所具有的功能，甚至干脆连函数名都一模一样（如
+imread, imshow,imwriter 等), 这些属性和方法如果你学过Matlab 掌握起来一定会很快。
+
+
+#### Mat知识点
+
+Mat 对象构造函数与常用方法
+##### 构造函数：
+- Mat(); // 默认构造函数
+- Mat(int rows, int cols, int type); //指定行数、列数、类型的构造函数
+- Mat(Size size, int type); // 指定矩阵大小、类型的构造函数
+- Mat(int rows, int cols, int type, const Scalar& s); // 指定矩阵行列、类型、颜色的构造函数
+- Mat(Size size, int type, const Scalar& s);// 指定矩阵大小、类型、颜色的构造函数
+- Mat(int ndims, const int* sizes, int type);
+- Mat(int ndims, const int* sizes, int type, const Scalar& s);
+- Mat(const Mat& m);
+- Mat(int rows, int cols, int type, void* data, size_t step=AUTO_STEP);
+- Mat(Size size, int type, void* data, size_t step=AUTO_STEP);
+- Mat(int ndims, const int* sizes, int type, void* data, const size_t* steps=0);
+
+```c++
+// start your code...
+Mat m1; // m1 为用默认拷贝构造创建的对象
+Mat m2(500, 500, CV_8UC3);//指定行数、列数、类型的构造函数CV_8UC3：8 位无符号3 通
+道图像
+m2 = Scalar(10, 20, 30);
+Mat m3(Size(300, 300), CV_8UC3); // 指定矩阵大小、类型的构造函数
+m3 = Scalar(50, 10, 215);
+Mat m4 = Mat(400, 400, CV_8UC3, Scalar(255, 0, 255)); // 指定矩阵行列、类型、颜色
+的构造函数Scalar(255,0,0)：颜色列表依次为b g r
+Mat m5 = Mat(src.size(), src.type()); // 创建一个和原图大小类型相同的图像
+```
+
+##### 常用方法：
+- void copyTo(Mat mat)
+- void convertTo(Mat dst,int type)
+- Mat clone()
+- int channels()
+- int depth()
+- bool empty()
+- uchar * ptr(i = 0)
+
+
+##### Mat 对象四个要点
+1. 输出图像内存是自动分配的
+2. 使用OpenCV 的C++接口，不需要考虑内存分配问题
+3. 复制操作和拷贝构造函数只会复制头部分
+4. 使用clone 和copyTo 两个函数实现数据完全复制
+
+
+
+
+
+
 
-它轻量级而且高效--由一系列C函数和少量C++类构成，同时提供了Python、Ruby、MATLAB等语言的接口，实现了图像处理和计算机视觉方面的很多通用算法。
 
 
 

From ac82bfdb134da8be58220cc9d2308c0d8ca93fe9 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 21 Jun 2023 21:00:45 +0800
Subject: [PATCH 134/213] update

---
 README.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/README.md b/README.md
index ee9da0dd..01ed8394 100644
--- a/README.md
+++ b/README.md
@@ -117,6 +117,9 @@ Android学习笔记
         - [4.开发环境配置][333]
         - [5. FFmpeg核心功能][334]
         - [6.视频播放简介][340]
+    - [OpenCV][342]
+        - [1.OpenCV简介][343]
+
 - [操作系统][263]
     - [1.操作系统简介][264]
     - [2.进程与线程][265]
@@ -716,6 +719,8 @@ Android学习笔记
 [339]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E9%9F%B3%E9%A2%91%E7%BC%96%E7%A0%81/WAV.md "WAV"
 [340]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/FFmpeg/6.%E8%A7%86%E9%A2%91%E6%92%AD%E6%94%BE%E7%AE%80%E4%BB%8B.md  "6.视频播放简介"
 [341]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E8%A7%86%E9%A2%91%E5%B0%81%E8%A3%85%E6%A0%BC%E5%BC%8F/AVI.md "AVI"
+[342]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/OpenCV "OpenCV"
+[343]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenCV/1.OpenCV%E7%AE%80%E4%BB%8B.md "1.OpenCV简介"
 
 
 Developed By

From a0d8bbbe03e3fa84876d729b16f11095f3c7f5a0 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 28 Jun 2023 15:45:31 +0800
Subject: [PATCH 135/213] update

---
 .../UML\347\261\273\345\233\276.pdf"          | Bin 0 -> 542659 bytes
 ...70\345\277\203\345\212\237\350\203\275.md" |   2 +-
 .../1.OpenCV\347\256\200\344\273\213.md"      |   4 +
 ...30\345\210\266\345\233\276\345\275\242.md" |  86 ++++++++++++++++++
 ...74\345\274\217\350\257\246\350\247\243.md" |  53 +++++++++++
 .../TS.md"                                    |   4 +
 6 files changed, 148 insertions(+), 1 deletion(-)
 create mode 100644 "JavaKnowledge/UML\347\261\273\345\233\276.pdf"
 create mode 100644 "VideoDevelopment/OpenCV/2.\347\273\230\345\210\266\345\233\276\345\275\242.md"

diff --git "a/JavaKnowledge/UML\347\261\273\345\233\276.pdf" "b/JavaKnowledge/UML\347\261\273\345\233\276.pdf"
new file mode 100644
index 0000000000000000000000000000000000000000..d7f9f7f791605cda7d6021f4f497abeab1cfc952
GIT binary patch
literal 542659
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
R;9WhS$59l=<N-bFe*otT+TZ{H

literal 0
HcmV?d00001

diff --git "a/VideoDevelopment/FFmpeg/5.FFmpeg\346\240\270\345\277\203\345\212\237\350\203\275.md" "b/VideoDevelopment/FFmpeg/5.FFmpeg\346\240\270\345\277\203\345\212\237\350\203\275.md"
index 7a942f32..0cfbb91a 100644
--- "a/VideoDevelopment/FFmpeg/5.FFmpeg\346\240\270\345\277\203\345\212\237\350\203\275.md"
+++ "b/VideoDevelopment/FFmpeg/5.FFmpeg\346\240\270\345\277\203\345\212\237\350\203\275.md"
@@ -75,7 +75,7 @@ AVCodecContext 中有两个成员：AVCodec，AVFrame。
 - AVFrame 中主要包饭了编码后的帧信息。
 ```
 typedef struct AVFrame {
-FF_COMMON_FRAME
+    FF_COMMON_FRAME
 } AVFrame;
 ```
 其中FF_COMMON_FRAME 是以宏出现的，由于编码过程中AVFrame 中的数据是要经常存取
diff --git "a/VideoDevelopment/OpenCV/1.OpenCV\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenCV/1.OpenCV\347\256\200\344\273\213.md"
index 4523a904..df0ceeee 100644
--- "a/VideoDevelopment/OpenCV/1.OpenCV\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenCV/1.OpenCV\347\256\200\344\273\213.md"
@@ -45,6 +45,10 @@ OpenCV用C++语言编写，它具有C ++，Python，Java和MATLAB接口，并支
 API：
 - imread(..url...)：加载本地图像
 	默认的BGR 彩色图像加载方式，此外支持灰度图像和任意格式。注意：在OpenCV中颜色值写法是BGR，而不是RGB。
+    imread() 函数默认加载图像文件，加载进来的是3 通道彩色图像，色彩空间是RGB 色彩空间。
+    通道顺序是：BGR （蓝色、绿色、红色）。
+    通道分离函数：split（）
+    通道合并函数：merge（）
 - imshow("namexx", ...url...)：显示图像
 - getStructuringElement(...)：获取腐蚀的内核矩阵
 - erode(...)：腐蚀(源图像、目的图像、内核矩阵）
diff --git "a/VideoDevelopment/OpenCV/2.\347\273\230\345\210\266\345\233\276\345\275\242.md" "b/VideoDevelopment/OpenCV/2.\347\273\230\345\210\266\345\233\276\345\275\242.md"
new file mode 100644
index 00000000..7306bedf
--- /dev/null
+++ "b/VideoDevelopment/OpenCV/2.\347\273\230\345\210\266\345\233\276\345\275\242.md"
@@ -0,0 +1,86 @@
+2.卷积
+===
+
+
+### 数字信号处理中卷积
+
+卷积一词最开始出现在信号与线性系统中，信号与线性系统中讨论的就是信号经过一个
+线性系统以后发生的变化。由于现实情况中常常是一个信号前一时刻的输出影响着这一时刻
+的输出，所在一般利用系统的单位响应与系统的输入求卷积，以求得系统的输出信号（当然
+要求这个系统是线性时不变的）。
+卷积的定义：
+卷积是两个变量在某范围内相乘后求和的结果。
+
+### 数字图像处理中卷积
+
+数字图像是一个二维的离散信号，对数字图像做卷积操作其实就是利用卷积核（卷积模
+板）在图像上滑动，将图像点上的像素灰度值与对应的卷积核上的数值相乘，然后将所有
+相乘后的值相加作为卷积核中间像素对应的图像上像素的灰度值，并最终滑动完所有图像的
+过程。
+
+
+我们经常能看到的，平滑，模糊，去燥，锐化，边缘提取等等工作，其实都可以通过
+卷积操作来完成
+
+### 模糊原理：
+
+1. 是拿一个矩阵（3X3, 5X5）等，和原图从左向右从上到下分别进行卷积，将卷
+积值最后赋值个当前卷积的中心像素。
+2. 那么其最关键的参数，也就在于矩阵的大小和矩阵的值，我们通常称矩阵为卷积核。
+3. 模糊操作的重要原因之一也是为了给图像预处理时降低噪声。
+
+
+### 均值模糊：
+也称为均值滤波，相当于卷积核的矩阵值全部为1/(卷积SIZE)，
+本次要记录的是图像的三种基本模糊操作：均值模糊、高斯模糊和中值模糊。
+
+均值模糊的原理是通过一个卷积核，在图像上进行移动，对每次覆盖的像素范围进行求
+平均值，然后将求得的平均值赋值给当前卷积核中心位置处的像素点。经过卷积核对一整幅
+图像的多次平移，就得到了一幅均值模糊过后的图像，该图像上的每个像素点的值，都是其
+邻域内所有像素点的平均值。均值模糊能够抹除图像的边缘和细节，对噪声也有一定的抑
+制作用，但是它作为一种最最最基础的模糊操作，实现简单的同时，其效果也是麻麻嘚。
+
+高斯模糊和均值模糊其原理上的唯一区别只是在于卷积核的值不同罢了，高斯卷积核矩
+阵值服从二维高斯函数，也就是说一个图像与服从二维高斯分布的函数做卷积，由于高斯函
+数是连续的，所有要将二维高斯函数进行采样和离散化，最后得到服从高斯函数规律的卷积
+核矩阵。
+
+高斯模糊也是一种基本的模糊操作，和均值模糊不同的是，高斯模糊是对某一像素点的邻域
+内所有像素点进行加权求和，能够比较好的保留中心像素点对图像的影响。高斯模糊的效果
+相比起均值模糊，要更好一些，而且在抑制噪声方面的能力也更强，尤其是对于高斯噪声的
+抑制效果比较好。
+
+
+
+
+
+### 锐化的概念
+图像锐化的目的是使模糊的图像变得清晰起来，主要用于增强图像的灰度跳变部分，
+这一点与图像平滑对灰度跳变的抑制正好相反。而且从算子可以看出来，平滑是基于对图像
+邻域的加权求和或者说积分运算的，而锐化则是通过其逆运算导数（梯度）或者说有限差分
+来实现的。
+图像的卷积计算除了可以完成我们前面介绍的模糊去噪、边缘检测等任务外，还可以
+实现图像锐化/增强的功能。
+图像锐化是一种突出和加强图像中景物的边缘和轮廓的技术。
+在图像中，边缘可以看作是位于一阶导数较大的像素位置，因此可以通过求图像的一阶
+导数来加强图像的边缘。同样我们也可以通过求图像的二阶导数来完成图像锐化。
+一般也通过Laplacian 滤波加原图权重像素叠加，
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/MP4\346\240\274\345\274\217\350\257\246\350\247\243.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/MP4\346\240\274\345\274\217\350\257\246\350\247\243.md"
index 6e36462a..8f7769d9 100644
--- "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/MP4\346\240\274\345\274\217\350\257\246\350\247\243.md"
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/MP4\346\240\274\345\274\217\350\257\246\350\247\243.md"
@@ -96,6 +96,59 @@ mvhd定义了整个movie的特性，通常包含媒体无关的信息，例如
 **普通MP4文件播放时，ftyp与moov box需同时加载完成后，并下载部分mdat box的帧数据后，才能开始播放**。 那对于一些长视频，确实存在文件头过大，从而影响第一帧的加载速度问题。 另外，对于不是很规范的文件，例 `mp4视频文件举例`中moov box基本在文件最后的的MP4文件，还有可能存在视频文件基本下载完成后才能播放的问题。
 
 
+### ES
+
+ES：Elementary Streams (原始流)是直接从编码器出来的数据流，可以是编码过的视
+频数据流（H.264,MJPEG 等），音频数据流（AAC、AC3、MP3），或其他编码数据流的统称。
+ES 流经过PES 打包器之后，被转换成PES 包。
+
+ES 是只包含一种内容的数据流，如只含视频或只含音频等，打包之后的PES 也是只含
+一种性质的ES,如只含视频ES 的PES,只含音频ES 的PES 等。
+每个ES 都由若干个存取单元（AU:Access Unit）组成，每个视频AU 或音频AU 都是由
+头部和编码数据两部分组成，1 个AU 相当于编码的1 幅视频图像或1 个音频帧，也可以说，
+每个AU 实际上是编码数据流的显示单元，即相当于解码的1 幅视频图像或1 个音频帧的取
+样。
+
+
+### PES
+PES：Packetized Elementary Streams (分组的ES)，ES 形成的分组称为PES 分组，是用
+来传递ES 的一种数据结构。PES 流是ES 流经过PES 打包器处理后形成的数据流，在这个过
+程中完成了将ES 流分组、打包、加入包头信息等操作（对ES 流的第一次打包）。
+PES 流的基本单位是PES 包。PES 包由包头和payload 组成。
+
+
+### PTS、DTS
+PTS：PresentationTime Stamp（显示时间标记）表示显示单元出现在系统目标解码器
+（H.264、MJPEG 等）的时间。
+DTS：Decoding Time Stamp（解码时间标记）表示将存取单元全部字节从解码缓存器移走
+的时间。
+PTS/DTS 是打在PES 包的包头里面的，这两个参数是解决音视频同步显示，防止解码器
+输入缓存上溢或下溢的关键。每一个I（关键帧）、P（预测帧）、B（双向预测帧）帧的
+包头都有一个PTS 和DTS，但PTS 与DTS 对于B 帧不一样，无需标出B 帧的DTS，对于I 帧
+和P 帧，显示前一定要存储于视频解码器的重新排序缓存器中，经过延迟（重新排序）后再
+显示，所以一定要分别标明PTS 和DTS。
+
+### PS
+PS：Program Stream(节目流)PS 流由PS 包组成，而一个PS 包又由若干个PES 包组成（到
+这里，ES 经过了两层的封装）。
+PS 包的包头中包含了同步信息与时钟恢复信息。
+一个PS 包最多可包含具有同一时钟基准的16 个视频PES 包和32 个音频PES 包。
+
+### TS
+TS：Transport Stream（传输流）由定长的TS 包组成（188 字节），而TS 包是对PES 包
+的一个重新封装（到这里，ES 也经过了两层的封装）。PES 包的包头信息依然存在于TS 包
+中。
+
+TS 流与PS 流的区别在于TS 流的包结构是固定长度的,而PS 流的包结构是可变长度的。
+PS 包由于长度是变化的,一旦丢失某一PS 包的同步信息,接收机就会进入失步状态,从而
+导致严重的信息丢失事件。
+而TS 码流由于采用了固定长度的包结构,当传输误码破坏了某一TS 包的同步信息时,接
+收机可在固定的位置检测它后面包中的同步信息,从而恢复同步,避免了信息丢失。因此在信
+道环境较为恶劣、传输误码较高时一般采用TS 码流,而在信环境较好、传输误码较低时一般
+采用PS 码流。
+
+
+
 
 
 
diff --git "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/TS.md" "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/TS.md"
index 6b0e0dc2..e2b7e467 100644
--- "a/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/TS.md"
+++ "b/VideoDevelopment/\350\247\206\351\242\221\345\260\201\350\243\205\346\240\274\345\274\217/TS.md"
@@ -51,6 +51,10 @@ PCR是节目时钟参考，PCR、DTS、PTS都是对同一个系统时钟的采
 
 视频流和音频流都需要加adaptation field，通常加在一个帧的第一个ts包和最后一个ts包里，中间的ts包不加。
 
+
+
+
+
 #### 3. TS Payload
 
 TS包中Payload所传输的信息包括两种类型：视频、音频的PES包以及辅助数据；节目专用信息PSI。

From 35167870d738a01036e6f144eec10a1e53115fa4 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 28 Jun 2023 17:06:46 +0800
Subject: [PATCH 136/213] update OS part

---
 ...13\344\270\216\347\272\277\347\250\213.md" | 52 +++++++++++++------
 1 file changed, 36 insertions(+), 16 deletions(-)

diff --git "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md" "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
index 71260d02..9c1b345b 100644
--- "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
+++ "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
@@ -323,8 +323,9 @@ A给B发送信号，B收到信号之前执行自己的代码，收到信号后
 
 信号的特质：由于信号是通过软件方法实现，其实现手段导致信号有很强的延时性。但对于用户来说，这个延迟时间非常短，不易察觉。
 每个进程收到的所有信号，都是由内核负责发送的，内核处理。
-
-    
+```c
+int kill(pid_t pid, int sig);
+```
 
     两个或多个进程可以通过简单的信号进行合作，可以强迫一个进程在某个位置停止，直到它接收到一个特定的信号。信号量是一个特殊的变量。用于进程间传递信息的一个整数值。
 
@@ -337,16 +338,37 @@ A给B发送信号，B收到信号之前执行自己的代码，收到信号后
     操作系统会中断目标程序的进程来向其发送信号、在任何非原子指令中，执行都可以中断，如果进程已经注册了新号处理程序，那么就执行进程，如果没有注册，将采用默认处理的方式。
 
    信号效率非常高，但是可携带的数据有限，只能写到一个标志位，无法携带其他数据。
+
+    不建议使用信号完成进程间通信，因为信号的优先级太高，产生信号之后会打断程序的执行。
+
+
 - 信号量
 
     信号量（semaphore）是由荷兰人E.W.Dijkstra在20世纪60年代所构思出的一种程序设计构造。其原型来源于铁路的运行：在一条单轨铁路上，任何时候只能有一列列车行驶在上面。而管理这条铁路的系统就是信号量。任何一列火车必须等到表明铁路可以行驶的信号后才能进入轨道。当一列列车进入单轨运行后，需要将信号改为禁止进入，从而防止别的火车同时进入轨道。而当列车驶出单轨后，则需要将信号变回允许进入状态。这很像以前的旗语，在计算机里，信号量实际上就是一个简单整数。一个进程在信号变为0或者1的情况下推进，并且将信号变为1或0来防止别的进程推进。当进程完成任务后，则将信号再改变为0或1，从而允许其他进程执行。需要注意的是，信号量不只是一种通信机制，更是一种同步机制。
 
 - Shared Memory共享内存
 
-    管道、套接字、信号、信号量，虽然满足了多种通信需要，但还是有一种需要未能满足。这就是两个进程需要共享大量数据。这就像两个人，他们互相喜欢，并想要一起生活时（共享大量数据量），打电话、握手、对白等就显得不够了，这个时候需要的是拥抱，只有将其紧紧拥抱于怀，感觉才最到位，也才能尽可能地共享。进程的拥抱就是共享内存。共享内存就是两个进程共同拥有同一片内存。对于这片内存中的任何内容，二者均可以访问。要使用共享内存进行通信，一个进程首先需要创建一片内存空间专门作为通信用，而其他进程则将该片内存映射到自己的（虚拟）地址空间。这样，读写自己地址空间中对应共享内存的区域时，就是在和其他进程进行通信。乍一看，共享内存有点像管道，有些管道不也是一片共享内存吗？这是形似而神不似。首先，使用共享内存机制通信的两个进程必须在同一台物理机器上；其次，共享内存的访问方式是随机的，而不是只能从一端写，另一端读，因此其灵活性比管道和套接字大很多，能够传递的信息也复杂得多。共享内存的缺点是管理复杂，且两个进程必须在同一台物理机器上才能使用这种通信方式。共享内存的另外一个缺点是安全性脆弱。因为两个进程存在一片共享的内存，如果一个进程染有病毒，很容易就会传给另外一个进程。就像两个紧密接触的人，一个人的病毒是很容易传染另外一个人的。这里需要注意的是，使用全局变量在同一个进程的进程间实现通信不称为共享内存。
+    管道、套接字、信号、信号量，虽然满足了多种通信需要，但还是有一种需要未能满足。这就是两个进程需要共享大量数据。这就像两个人，他们互相喜欢，并想要一起生活时（共享大量数据量），打电话、握手、对白等就显得不够了，这个时候需要的是拥抱，只有将其紧紧拥抱于怀，感觉才最到位，也才能尽可能地共享。进程的拥抱就是共享内存。    
+    共享内存就是两个进程共同拥有同一片内存。对于这片内存中的任何内容，二者均可以访问。要使用共享内存进行通信，一个进程首先需要在内核中创建一片内存空间专门作为通信用，然后该进程与这片内存空间进行关联，而其他进程则将该片内存映射到自己的（虚拟）地址空间。    
+    这样，读写自己地址空间中对应共享内存的区域时，就是在和其他进程进行通信。乍一看，共享内存有点像管道，有些管道不也是一片共享内存吗？这是形似而神不似：- 首先，使用共享内存机制通信的两个进程必须在同一台物理机器上；
+- 其次，共享内存的访问方式是随机的，而不是只能从一端写，另一端读，因此其灵活性比管道和套接字大很多，能够传递的信息也复杂得多。
+
+共享内存的缺点是管理复杂，且两个进程必须在同一台物理机器上才能使用这种通信方式。共享内存的另外一个缺点是安全性脆弱。因为两个进程存在一片共享的内存，如果一个进程染有病毒，很容易就会传给另外一个进程。就像两个紧密接触的人，一个人的病毒是很容易传染另外一个人的。这里需要注意的是，使用全局变量在同一个进程的进程间实现通信不称为共享内存。
 
-    共享内存是进程通信中最快的一种方法，因为数据不需要在进程间复制，而可以直接映射到各个进程的地址空间中。在共享内存中要注意的一个问题是：当多个进程对共享内存区域进行访问时，要注意这些进程之间的同步问题。例如，如果server正在向共享内存区域中写数据，那么client进程就不能访问这些数据，直到server全部写完之后，client才可以访问。为了实现进程间的同步问题，通常使用前面介绍过的信号量来实现这一目标。一个共享内存段可以由一个进程创建，然后由任意共享这一内存段的进程对它进行读写。当进程间需要通信时，一个进程可以创建一个共享内存段，然后需要通信的各个进程就可以在信号量的控制下保持同步，在这里交换数据，完成通信。
+    共享内存是进程通信中最快的一种方法，因为数据不需要在进程间复制，而可以直接映射到各个进程的地址空间中。在共享内存中要注意的一个问题是：当多个进程对共享内存区域进行访问时，要注意这些进程之间的同步问题。    
+例如，如果server正在向共享内存区域中写数据，那么client进程就不能访问这些数据，直到server全部写完之后，client才可以访问。    
+为了实现进程间的同步问题，通常使用前面介绍过的信号量来实现这一目标。一个共享内存段可以由一个进程创建，然后由任意共享这一内存段的进程对它进行读写。    
+当进程间需要通信时，一个进程可以创建一个共享内存段，然后需要通信的各个进程就可以在信号量的控制下保持同步，在这里交换数据，完成通信。
+创建共享内存: 
+```c
+#include <sys/ipc.h>
+#include <sys/shm.h>
+// 创建或者获得共享内存ID
+int shmget(key_t key, size_t size, int shmflg);
+// 连接共享内存
+void *shmat(int shmid, const void *shmaddr, int shmflg);
 
+```
 
 - FIFO
 
@@ -360,16 +382,16 @@ FIFO常被称为命名管道，以区分管道(pipe)。管道(pipe)只能用于
 
 
 - 存储映射
-       存储映射I/O (Memory-mapped I/O) 使一个磁盘文件与存储空间中的一个缓冲区相映射。于是当从缓冲区中取数据，就相当于读文件中的相应字节。于此类似，将数据存入缓冲区，则相应的字节就自动写入文件。这样，就可在不适用read和write函数的情况下，使用地址（指针）完成I/O操作。
-       使用这种方法，首先应通知内核，将一个指定文件映射到存储区域中。这个映射工作可以通过mmap函数来实现。
-总结：使用mmap时务必注意以下事项：
-1.     创建映射区的过程中，隐含着一次对映射文件的读操作。
-2.     当MAP_SHARED时，要求：映射区的权限应 <=文件打开的权限(出于对映射区的保护)。而MAP_PRIVATE则无所谓，因为mmap中的权限是对内存的限制。
-3.     映射区的释放与文件关闭无关。只要映射建立成功，文件可以立即关闭。
-4.     特别注意，当映射文件大小为0时，不能创建映射区。所以：用于映射的文件必须要有实际大小！！   mmap使用时常常会出现总线错误，通常是由于共享文件存储空间大小引起的。
-5.     munmap传入的地址一定是mmap的返回地址。坚决杜绝指针++操作。
-6.     如果文件偏移量必须为4K的整数倍
-7.     mmap创建映射区出错概率非常高，一定要检查返回值，确保映射区建立成功再进行后续操作。
+   存储映射I/O (Memory-mapped I/O) 使一个磁盘文件与存储空间中的一个缓冲区相映射。于是当从缓冲区中取数据，就相当于读文件中的相应字节。于此类似，将数据存入缓冲区，则相应的字节就自动写入文件。这样，就可在不适用read和write函数的情况下，使用地址（指针）完成I/O操作。     
+   使用这种方法，首先应通知内核，将一个指定文件映射到存储区域中。这个映射工作可以通过mmap函数来实现。     
+总结：使用mmap时务必注意以下事项：    
+1. 创建映射区的过程中，隐含着一次对映射文件的读操作。
+2. 当MAP_SHARED时，要求：映射区的权限应 <=文件打开的权限(出于对映射区的保护)。而MAP_PRIVATE则无所谓，因为mmap中的权限是对内存的限制。
+3. 映射区的释放与文件关闭无关。只要映射建立成功，文件可以立即关闭。
+4. 特别注意，当映射文件大小为0时，不能创建映射区。所以：用于映射的文件必须要有实际大小！！   mmap使用时常常会出现总线错误，通常是由于共享文件存储空间大小引起的。
+5. munmap传入的地址一定是mmap的返回地址。坚决杜绝指针++操作。
+6. 如果文件偏移量必须为4K的整数倍
+7. mmap创建映射区出错概率非常高，一定要检查返回值，确保映射区建立成功再进行后续操作。
 
 - 匿名映射
 
@@ -388,8 +410,6 @@ int *p = mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0);
     进程与其它的进程进行通信而不必借助共享数据，通过互相发送和接收消息，建立一条通信链路。
 
 
-
-
 ## 进程调度
 
 当一个计算机是多道程序设计系统时，会频繁的有很多进程或者线程来同时竞争 CPU 时间片。当两个或两个以上的进程/线程处于就绪状态时，就会发生这种情况。如果只有一个 CPU 可用，那么必须选择接下来哪个进程/线程可以运行。操作系统中有一个叫做调度程序(scheduler) 的角色存在，它就是做这件事儿的，该程序使用的算法叫做调度算法(scheduling algorithm) 。进程调度就是处理器调度(上下文切换)。

From 1d9e2dcd389a18a9b10e175f1be46f99c13896c4 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 31 Jul 2023 14:38:47 +0800
Subject: [PATCH 137/213] update

---
 ...3.\345\206\205\345\255\230\347\256\241\347\220\206.md" | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git "a/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md" "b/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
index 0f00ea4f..a0b3297b 100644
--- "a/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
+++ "b/OperatingSystem/3.\345\206\205\345\255\230\347\256\241\347\220\206.md"
@@ -43,6 +43,14 @@
 
 上述几种内存区域中数据段、BSS和堆通常是被连续存储的——内存位置上是连续的，而代码段和栈往往会被独立存放。有趣的是，堆和栈两个区域关系很“暧昧”，他们一个向下“长”（i386体系结构中栈向下、堆向上），一个向上“长”，相对而生。但你不必担心他们会碰头，因为他们之间间隔很大（到底大到多少，你可以从下面的例子程序计算一下），绝少有机会能碰到一起。
 
+
+##### 虚拟存储技术
+所谓虚拟存储技术是指：当进程运行时，先将其一部分装入内存，另一部分暂留在磁盘，当要执行的指令或访问的数据不在内存时，由操作系统自动完成将它们从磁盘调入内存的工作。
+虚拟地址空间即为分配给进程的虚拟内存。
+虚拟地址是在虚拟内存中指令或数据的位置，该位置可以被访问，仿佛它是内存的一部分。
+
+
+
 ## 内存的演变
 
 在早些的操作系统中，并没有引入内存抽象的概念。程序直接访问和操作的都是物理内存，内存的管理也非常简单，除去操作系统所用的内存之外，全部给用户程序使用，想怎么折腾都行，只要别超出最大的容量。这种内存操作方式使得操作系统中存在多进程变得完全不可能，比如MS-DOS，你必须执行完一条指令后才能接着执行下一条。如果是多进程的话，由于直接操作物理内存地址，当一个进程给内存地址1000赋值后，另一个进程也同样给内存地址赋值，那么第二个进程对内存的赋值会覆盖第一个进程所赋的值，这回造成两条进程同时崩溃。随着计算机技术发展，要求操作系统支持多进程的需求，所谓多进程，并不需要同时运行这些进程，只要它们都处于ready 状态，操作系统快速地在它们之间切换，就能达到同时运行的假象。每个进程都需要内存，Context Switch时，之前内存里的内容怎么办？简单粗暴的方式就是先dump到磁盘上，然后再从磁盘上restore之前dump的内容（如果有的话），但效果并不好，太慢了！那怎么才能不慢呢？把进程对应的内存依旧留在物理内存中，需要的时候就切换到特定的区域。这就涉及到了内存的保护机制，毕竟进程之间可以随意读取、写入内容就乱套了，非常不安全。

From b699171bd57a197884f49092f6dd108e3703460c Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 7 Aug 2023 11:49:54 +0800
Subject: [PATCH 138/213] update OperationSystem part

---
 ...73\347\273\237\347\256\200\344\273\213.md" | 20 +++++++++++++++++--
 ...13\344\270\216\347\272\277\347\250\213.md" | 11 ++++++++++
 2 files changed, 29 insertions(+), 2 deletions(-)

diff --git "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md" "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
index 52f42ab2..ddfe2b25 100644
--- "a/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
+++ "b/OperatingSystem/1.\346\223\215\344\275\234\347\263\273\347\273\237\347\256\200\344\273\213.md"
@@ -250,10 +250,14 @@ Android平台的基础是Linux内核，比如ART虚拟机最终调用底层Linux
 
 ## CPU(Central Processing Unit)
 
-CPU(中央处理器)是计算机的大脑，它主要和内存进行交互，从内存中提取指令并执行它。它是一块超大规模的集成电路(Integrated Circuit)，是信息处理、程序运行的最终执行单元。其功能主要是解释计算机指令以及处理计算机软件中的数据。由于访问内存获取执行或数据要比执行指令花费的时间长，因此所有的 CPU 内部都会包含一些寄存器来保存关键变量和临时结果。因此，在指令集中通常会有一些指令用于把关键字从内存中加载到寄存器中，以及把关键字从寄存器存入到内存中。从功能方面来看，CPU的内部主要由寄存器，控制器，运算器构成，各部分之间由电流信号相互连通。其中运算器负责算术运算和逻辑运算，控制器负责计算指令的解析，产生各种控制指令，寄存器组用来临时存放参加运算的数据和计算的中间结果。CPU计算结果最终需要写到内存中，内存的存取速度远低于CPU，为提升数据交换速率，CPU内部一般还集成了高速缓存（CACHE）,其中缓存分为一级缓存和二级缓存，一级缓存和CPU速率相当，二级缓存次之。
-
+CPU(中央处理器)是计算机的大脑，它主要和内存进行交互，从内存中提取指令并执行它。它是一块超大规模的集成电路(Integrated Circuit)，是信息处理、程序运行的最终执行单元。其功能主要是解释计算机指令以及处理计算机软件中的数据。由于访问内存获取执行或数据要比执行指令花费的时间长，因此所有的 CPU 内部都会包含一些寄存器来保存关键变量和临时结果。    
+因此，在指令集中通常会有一些指令用于把关键字从内存中加载到寄存器中，以及把关键字从寄存器存入到内存中。
+    
+从功能方面来看，CPU的内部主要由寄存器，控制器，运算器构成，各部分之间由电流信号相互连通。其中运算器负责算术运算和逻辑运算，控制器负责计算指令的解析，产生各种控制指令，寄存器组用来临时存放参加运算的数据和计算的中间结果。    
+CPU计算结果最终需要写到内存中，内存的存取速度远低于CPU，为提升数据交换速率，CPU内部一般还集成了高速缓存（CACHE）,其中缓存分为一级缓存和二级缓存，一级缓存和CPU速率相当，二级缓存次之。
 
 
+CPU“取值-解码-执行”的速度叫时钟速度，单位是赫兹，赫兹是用来表示频率的单位。1赫兹代表1秒1个周期。   
 为了驱动CPU运转，称为“时钟信号”的电信号必不可少。这种电信号就好像带有一个时钟，滴答滴答地每隔一定时间就变换一次电压的高低。输出时钟信号的元件叫作“时钟发生器”。时钟发生器中带有晶振，根据其自身的频率（振动的次数）产生时钟信号。时钟信号的频率可以衡量CPU的运转速度。这里使用的是2.5MHz（兆赫兹）的时钟发生器。最大时钟频率(maximum clock speed)，也称主频，是影响处理器速度的决定性因素之一。时钟频率决定了执行一条指令所需要的时间，处理器的数据位宽也影响处理器的速度。
 
 操作系统通过虚拟化（virtualizing）CPU来提供这种假象。通过让一个进程只运行一个时间片，然后切换到其他进程，操作系统提供了存在多个虚拟CPU的假象。这就是时分共享（time sharing）CPU技术，允许用户如愿运行多个并发进程。潜在的开销就是性能损失，因为如果CPU必须共享，每个进程的运行就会慢一点。
@@ -377,6 +381,11 @@ CPU 的内部由**寄存器、控制器、运算器和时钟**四部分组成，
 
 ### 中断/异常
 
+为什么要引入中断与异常？
+中断的引入: 为了支持CPU和设备之间的并行操作。     
+当CPU启动设备进行输入/输出后，设备便可以独立工作，CPU转去处理与此次输入/输出不相关的事情。当设备完成输入/输出后，通过向CPU发中断报告此次输入/输出的结果，让CPU决定如何处理以后的事情。 
+异常的引入：表示CPU执行指令时本身出现的问题。    
+如算数溢出、除零、读取时的奇偶错，访问地址时的越界或执行了“陷入指令”等，这时硬件改变了CPU当前的执行流程，转到相应的错误处理程序或异常处理程序或执行系统调用。 
 
 
 #### 中断的概念
@@ -461,8 +470,15 @@ CPU 的内部由**寄存器、控制器、运算器和时钟**四部分组成，
 
 
 
+#### 中断异常机制工作原理
+
+中断/异常机制是现代计算机系统的核心机制之一。硬件和软件相互配合而使计算机系统得以充分发挥能力。
 
+硬件该做什么是？  --- 中断/异常响应
+捕获中断源发出的中断/异常请求，以一定方式响应，将处理器控制权交给特定的处理程序。 
 
+软件要做什么是？  ---中断/异常处理程序
+识别终端/异常类型并完成相应的处理
 ## 存储器
 
 在任何一种计算机中，第二种主要部件都是存储器。在理想情况下，存储器应该极为迅速（快于执行一条指令，这样CPU就不会受到存储器的限制），充分大并且非常便宜。但是目前的技术无法同时满足这三个目标。
diff --git "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md" "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
index 9c1b345b..fd97534b 100644
--- "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
+++ "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
@@ -346,6 +346,12 @@ int kill(pid_t pid, int sig);
 
     信号量（semaphore）是由荷兰人E.W.Dijkstra在20世纪60年代所构思出的一种程序设计构造。其原型来源于铁路的运行：在一条单轨铁路上，任何时候只能有一列列车行驶在上面。而管理这条铁路的系统就是信号量。任何一列火车必须等到表明铁路可以行驶的信号后才能进入轨道。当一列列车进入单轨运行后，需要将信号改为禁止进入，从而防止别的火车同时进入轨道。而当列车驶出单轨后，则需要将信号变回允许进入状态。这很像以前的旗语，在计算机里，信号量实际上就是一个简单整数。一个进程在信号变为0或者1的情况下推进，并且将信号变为1或0来防止别的进程推进。当进程完成任务后，则将信号再改变为0或1，从而允许其他进程执行。需要注意的是，信号量不只是一种通信机制，更是一种同步机制。
 
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/linux_signal_pv_1.png?raw=true)
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/signal_pv_2.png?raw=true)
+
+
+
 - Shared Memory共享内存
 
     管道、套接字、信号、信号量，虽然满足了多种通信需要，但还是有一种需要未能满足。这就是两个进程需要共享大量数据。这就像两个人，他们互相喜欢，并想要一起生活时（共享大量数据量），打电话、握手、对白等就显得不够了，这个时候需要的是拥抱，只有将其紧紧拥抱于怀，感觉才最到位，也才能尽可能地共享。进程的拥抱就是共享内存。    
@@ -681,6 +687,11 @@ Android使用的进程有些不同。活动管理器是Android负责正在运行
 
 #### 线程系统调用
 
+系统调用：用户在编程时可以调用的操作系统功能。
+系统调用是操作系统提供给编程人员的唯一接口。 可以使CPU状态从用户态陷入内核态。每个操作系统都提供几百种系统调用(进程控制、进程通信、文件使用、目录操作、设备管理、信息维护等).    
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/linux_system_call_1.png?raw=true)
+
 进程通常会从当前的某个单线程开始，然后这个线程通过调用一个库函数（比如 `thread_create`）创建新的线程。线程创建的函数会要求指定新创建线程的名称。创建的线程通常都返回一个线程标识符，该标识符就是新线程的名字。
 
 当一个线程完成工作后，可以通过调用一个函数（比如 `thread_exit`）来退出。紧接着线程消失，状态变为终止，不能再进行调度。在某些线程的运行过程中，可以通过调用函数例如 `thread_join` ，表示一个线程可以等待另一个线程退出。这个过程阻塞调用线程直到等待特定的线程退出。在这种情况下，线程的创建和终止非常类似于进程的创建和终止。

From ccb22c1352d5df102a64ac5360e71c80deabfd7a Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 23 Aug 2023 10:55:11 +0800
Subject: [PATCH 139/213] update

---
 .../\347\256\227\346\263\225.md"                              | 4 ++++
 1 file changed, 4 insertions(+)

diff --git "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\347\256\227\346\263\225.md" "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\347\256\227\346\263\225.md"
index c6ce6686..7c8a9a26 100644
--- "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\347\256\227\346\263\225.md"
+++ "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\347\256\227\346\263\225.md"
@@ -17,7 +17,11 @@
     算法的每一步都必须是可行的，也就是说，每一步都能够通过执行有限次数完成
 
 
+
 ### 算法时间复杂度
+
+一个算法的时间复杂度（Time Complexity）是指算法运行从开始到结束所需要的时间。这个时间就是该算法中每条语句的执行时间之和，而每条语句的执行时间是该语句执行次数（也称为频度）与执行该语句所需时间的乘积。但是，当算法转换为程序之后，一条语句执行一次所需的时间与机器的性能及编译程序生成目标代码的质量有关，是很难确定的。为此，假设执行每条语句所需的时间均为单位时间。在这一假设下，一个算法所花费的时间就等于算法中所有语句的频度之和。这样就可以脱离机器的硬、软件环境而独立地分析算法所消耗的时间。
+
 在进行算法分析时，语句总的执行次数T（n）是关于问题规模n的函数，进而分析T（n）随n的变化情况并确定T（n）的数量级。算法的时间复杂度，也就是算法的时间量度，记作：T（n）=O(f(n))。它表示随问题规模n的增大，算法执行时间的增长率和f（n）的增长率相同，称作算法的渐近时间复杂度，简称为时间复杂度。其中f（n）是问题规模n的某个函数。
 
 这样用大写O( )来体现算法时间复杂度的记法，我们称之为大O记法。

From 44f03d76c950a93510a5247dceb9497f3f9f3140 Mon Sep 17 00:00:00 2001
From: Charon <CharonChui@users.noreply.github.com>
Date: Tue, 5 Sep 2023 20:52:33 +0800
Subject: [PATCH 140/213] =?UTF-8?q?Update=201.Kotlin=5F=E7=AE=80=E4=BB=8B&?=
 =?UTF-8?q?=E5=8F=98=E9=87=8F&=E7=B1=BB&=E6=8E=A5=E5=8F=A3.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...17\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md" | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md" "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
index 72fdaebe..50112793 100644
--- "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
+++ "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
@@ -381,7 +381,7 @@ class Test{
 
     fun main(){
         // 如果 myService 对象还未初始化，则进行初始化
-        if(!::myService.isInitialized){
+        if(!this::myService.isInitialized){
             println("hha")
             myService = MyService()
         }

From 65f31a3bafb12699141ed967318318561821ab7d Mon Sep 17 00:00:00 2001
From: Charon <CharonChui@users.noreply.github.com>
Date: Tue, 5 Sep 2023 21:07:50 +0800
Subject: [PATCH 141/213] =?UTF-8?q?Update=201.Kotlin=5F=E7=AE=80=E4=BB=8B&?=
 =?UTF-8?q?=E5=8F=98=E9=87=8F&=E7=B1=BB&=E6=8E=A5=E5=8F=A3.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...17\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md" | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md" "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
index 50112793..72fdaebe 100644
--- "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
+++ "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
@@ -381,7 +381,7 @@ class Test{
 
     fun main(){
         // 如果 myService 对象还未初始化，则进行初始化
-        if(!this::myService.isInitialized){
+        if(!::myService.isInitialized){
             println("hha")
             myService = MyService()
         }

From 39a717bdba4e77214de07f41fe3374384d956984 Mon Sep 17 00:00:00 2001
From: Charon <CharonChui@users.noreply.github.com>
Date: Tue, 5 Sep 2023 21:18:56 +0800
Subject: [PATCH 142/213] =?UTF-8?q?Update=201.Kotlin=5F=E7=AE=80=E4=BB=8B&?=
 =?UTF-8?q?=E5=8F=98=E9=87=8F&=E7=B1=BB&=E6=8E=A5=E5=8F=A3.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md" | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md" "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
index 72fdaebe..8f2a250c 100644
--- "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
+++ "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
@@ -388,7 +388,9 @@ class Test{
     }
 }
 ```
-注意: ::myService.isInitialized可用于判断adapter变量是否已经初始化。虽然语法看上去有点奇怪，但这是固定的写法。`::`前缀不能省
+注意: ::myService.isInitialized可用于判断adapter变量是否已经初始化。虽然语法看上去有点奇怪，但这是固定的写法。`::`前缀不能省。
+这里可以写成`::myService.isInitialized`或`this::myService.isInitialized`。
+如果在listener或者内部类中，可以这样写`this@OuterClassName::myService.isInitialized`
 
 除了使用`lateinit`外还可以使用`by lazy {}`效果是一样的：   
 ```kotlin

From e6e90f0d69ec5c9ed656131c6089b3c603a115cf Mon Sep 17 00:00:00 2001
From: Charon <CharonChui@users.noreply.github.com>
Date: Tue, 5 Sep 2023 21:32:40 +0800
Subject: [PATCH 143/213] =?UTF-8?q?Update=201.Kotlin=5F=E7=AE=80=E4=BB=8B&?=
 =?UTF-8?q?=E5=8F=98=E9=87=8F&=E7=B1=BB&=E6=8E=A5=E5=8F=A3.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...0\351\207\217&\347\261\273&\346\216\245\345\217\243.md" | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md" "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
index 8f2a250c..f2f97abb 100644
--- "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
+++ "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
@@ -369,7 +369,7 @@ private fun switchFragment(position: Int) {
 }
 ```
 会报`kotlin.UninitializedPropertyAccessException: lateinit property test has not been initialized`
-
+> We’ve added a new reflection API allowing you to check whether a lateinit variable has been initialized:
 这里想要判断是否初始化了，需要用isInitialized来判断:  
 ```kotlin
 class MyService{
@@ -388,9 +388,12 @@ class Test{
     }
 }
 ```
-注意: ::myService.isInitialized可用于判断adapter变量是否已经初始化。虽然语法看上去有点奇怪，但这是固定的写法。`::`前缀不能省。
+注意: ::myService.isInitialized可用于判断adapter变量是否已经初始化。虽然语法看上去有点奇怪，但这是固定的写法。`::`前缀不能省。::是一个引用运算符，一般用于反射相关的操作中，可以引用属性或者函数。
 这里可以写成`::myService.isInitialized`或`this::myService.isInitialized`。
 如果在listener或者内部类中，可以这样写`this@OuterClassName::myService.isInitialized`
+那lateinit有什么用呢？ 每次使用还要判断isInitialized。 
+The primary use-case for lateinit is when you can't initialize a property in the constructor but can guarantee that it's initialized "early enough" in some sense that most uses won't need an isInitialized check. E.g. because some framework calls a method initializing it immediately after construction.
+
 
 除了使用`lateinit`外还可以使用`by lazy {}`效果是一样的：   
 ```kotlin

From 020e8a57b0f3cd4334dd57ddc9ab21bd6fae07fe Mon Sep 17 00:00:00 2001
From: Charon <CharonChui@users.noreply.github.com>
Date: Wed, 6 Sep 2023 09:20:04 +0800
Subject: [PATCH 144/213] =?UTF-8?q?Update=201.Kotlin=5F=E7=AE=80=E4=BB=8B&?=
 =?UTF-8?q?=E5=8F=98=E9=87=8F&=E7=B1=BB&=E6=8E=A5=E5=8F=A3.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...0\351\207\217&\347\261\273&\346\216\245\345\217\243.md" | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md" "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
index f2f97abb..0bf3f4f6 100644
--- "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
+++ "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
@@ -394,6 +394,10 @@ class Test{
 那lateinit有什么用呢？ 每次使用还要判断isInitialized。 
 The primary use-case for lateinit is when you can't initialize a property in the constructor but can guarantee that it's initialized "early enough" in some sense that most uses won't need an isInitialized check. E.g. because some framework calls a method initializing it immediately after construction.
 
+Lateinit Initialization is used when you want to initialize a variable at a later stage, especially when it's non-null and must be initialized before use.
+It's commonly used in dependency injection and testing.
+
+
 
 除了使用`lateinit`外还可以使用`by lazy {}`效果是一样的：   
 ```kotlin
@@ -417,7 +421,8 @@ test is not null haha
 
 - `by lazy{}`只能用在`val`类型而`lateinit`只能用在`var`类型
 - `lateinit`不能用在可空的属性上和`java`的基本类型上,否则会报`lateinit`错误   
-
+- lateinit在分配之前不会初始化变量，而by lazy在第一次访问时初始化它。
+- 如果在初始化之前访问，lateinit会抛出异常，而lazy则可以确保已初始化。
 lazy的背后是接收一个lambda并返回一个Lazy<T>实例的函数，第一次访问该属性时，会执行lazy对应的Lambda表达式并记录结果，后续访问该属性时只是返回记录的结果。
 
 另外系统会给lazy属性默认加上同步锁，也就是LazyThreadSafetyMode.SYNCHRONIZED，它在同一时刻只允许一个线程对lazy属性进行初始化，所以它是线程安全的。

From a408ebbdefda5eb25928bff2ab36c1bd00a7a3fc Mon Sep 17 00:00:00 2001
From: Charon <CharonChui@users.noreply.github.com>
Date: Wed, 6 Sep 2023 09:23:21 +0800
Subject: [PATCH 145/213] =?UTF-8?q?Update=201.Kotlin=5F=E7=AE=80=E4=BB=8B&?=
 =?UTF-8?q?=E5=8F=98=E9=87=8F&=E7=B1=BB&=E6=8E=A5=E5=8F=A3.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...17\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md" | 2 ++
 1 file changed, 2 insertions(+)

diff --git "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md" "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
index 0bf3f4f6..36f64c4c 100644
--- "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
+++ "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
@@ -459,6 +459,8 @@ private var lazyValue: Fragment? = null
     }
 ```
 
+当您稍后需要在代码中初始化var时，请选择lateinit，它将被重新分配。当您想要初始化一个val值一次时，特别是当初始化的计算量很大时，请选择by lazy。
+
 
 ## 类的定义:使用`class`关键字
 

From 732cf6d2cf5957f3e8bc297d405ac4fa8a0251e3 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 6 Sep 2023 15:47:32 +0800
Subject: [PATCH 146/213] update

---
 "Jetpack/architecture/1.\347\256\200\344\273\213.md"     | 6 ++----
 .../2.ViewBinding\347\256\200\344\273\213.md"            | 9 ++++++---
 ...351\207\217&\347\261\273&\346\216\245\345\217\243.md" | 5 +++--
 3 files changed, 11 insertions(+), 9 deletions(-)

diff --git "a/Jetpack/architecture/1.\347\256\200\344\273\213.md" "b/Jetpack/architecture/1.\347\256\200\344\273\213.md"
index f64448a8..3bf0bd85 100644
--- "a/Jetpack/architecture/1.\347\256\200\344\273\213.md"
+++ "b/Jetpack/architecture/1.\347\256\200\344\273\213.md"
@@ -37,9 +37,7 @@
 - `Room`:一个`SQLite`对象映射库
 
 
-平时我们比较熟悉的的架构有`MVC`,`MVP`及`MVVM`.这些结构有各自的优缺点,以现在比较流行的`MVP`为例, 它将不是关于界面的操作分发到`Presenter`中操作,再将结果通知给`View`接口的实现(通常是 `Activity/Fragment`).
-
-这些结构有各自的优缺点, 以现在比较流行的`MVP`为例, 它将不是关于界面的操作分发到`Presenter`中操作,再将结果通知给`View`接口的实现(通常是`Activity/Fragment`).
+平时我们比较熟悉的的架构有`MVC`,`MVP`及`MVVM`.这些结构有各自的优缺点, 以现在比较流行的`MVP`为例, 它将不是关于界面的操作分发到`Presenter`中操作,再将结果通知给`View`接口的实现(通常是`Activity/Fragment`).
 `MVP`架构,当异步获取结果时,可能`UI`已经销毁,而`Presenter`还持有`UI`的引用,从而导致内存泄漏
 
 
@@ -133,4 +131,4 @@ override fun onDestroy() {
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! `
\ No newline at end of file
+- Good Luck! `
diff --git "a/Jetpack/architecture/2.ViewBinding\347\256\200\344\273\213.md" "b/Jetpack/architecture/2.ViewBinding\347\256\200\344\273\213.md"
index 012cbdf1..4718b3f9 100644
--- "a/Jetpack/architecture/2.ViewBinding\347\256\200\344\273\213.md"
+++ "b/Jetpack/architecture/2.ViewBinding\347\256\200\344\273\213.md"
@@ -7,7 +7,7 @@ ViewBinding是Google在2019年I/O大会上公布的一款Android视图绑定工
 ## 使用方法
 
 ### 1.build.gradle中开启
-在build.gradle文件中的androidj节点添加如下代码: 
+在build.gradle文件中的android节点添加如下代码: 
 ```
 android {
    ...
@@ -134,9 +134,12 @@ class TextAdapter(
   class TextViewHolder(val binding : ItemTextBinding) : RecyclerView.ViewHolder(binding.root)
 }
 ```
-#### includ
+#### include
 
-ViewBinding同样可以被用于<include>中。include又分为两种形式，一种是有<merge>标签的样式，一种是没有的。
+ViewBinding同样可以被用于include中。
+include又分为两种形式:     
+- 一种是有<merge>标签的样式
+- 一种是没有的     
 没有<merge>标签的时候需要对include指定id，通过id来获取,例如:  
 ```xml
 <?xml version="1.0" encoding="utf-8"?>
diff --git "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md" "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
index 36f64c4c..6128245e 100644
--- "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
+++ "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
@@ -755,7 +755,8 @@ data class Artist(
     var mbid: String)
 ```
 
-数据类自动覆盖它们的equals方法以改变==操作符的行为，由此通过检查对象的每个属性值来判断是否相等。例如，假设你创建了两个属性值完全相同的Artist对象，
+数据类自动覆盖它们的equals方法以改变==操作符的行为，由此通过检查对象的每个属性值来判断是否相等。    
+例如，假设你创建了两个属性值完全相同的Artist对象，
 使用==操作符对它们进行比较将返回true，因为它们存放了相同的数据：除了提供从Any父类继承的equals方法的新实现，数据类还覆盖了hashCode和toString方法。
 
 通过数据类，会自动提供以下函数：
@@ -767,7 +768,7 @@ data class Artist(
 - `toString()`
 - `componentN()`
 
-如果我们使用不可修改的对象，就像我们之前讲过的，假如我们需要修改这个对象状态，必须要创建一个新的一个或者多个属性被修改的实例。
+如果我们使用不可修改的对象，就像我们之前讲过的，假如我们需要修改这个对象状态，必须要创建一个新的或者多个属性被修改的实例。
 这个任务是非常重复且不简洁的。
 
 举个例子,如果要修改`Person`类中`charon`的`age`: 

From 17218219a84f1d1931d78ae6ea6ccbfdb5e55bd0 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Tue, 21 Nov 2023 13:07:53 +0800
Subject: [PATCH 147/213] upate

---
 ...13\344\270\216\347\272\277\347\250\213.md" | 57 +++++++++++++++++++
 1 file changed, 57 insertions(+)

diff --git "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md" "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
index fd97534b..906d5fd8 100644
--- "a/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
+++ "b/OperatingSystem/2.\350\277\233\347\250\213\344\270\216\347\272\277\347\250\213.md"
@@ -675,6 +675,63 @@ Android使用的进程有些不同。活动管理器是Android负责正在运行
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/thread_heap.png?raw=true)  
 
+#### 线程的创建
+
+```c
+#include <pthread.h>
+
+int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg);
+```
+功能: 创建一个线程     
+参数:  
+- thread: 线程标识符地址
+- attr: 线程属性结构体地址
+- start_routine: 线程函数的入口地址
+- arg: 传给线程函数的参数
+
+成功返回0，失败返回非0.
+
+与进程fork()函数不同的是pthread_create()创建的线程不与父线程在同一点开始运行，而是从指定的函数开始运行，该函数运行完后，该线程也就退出了。    
+
+```c
+#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+
+void *thread_fun(void *arg) {
+    printf("thread start run");
+}
+
+int main() {
+    printf("main thread run");
+    pthread_t thread;
+    if (pthread_create(&thread, NULL, thread_fun, NULL) != 0) {
+        perror("fail to create thread");
+        exit(1);
+    }
+    // 由于进程结束后，进程中所有的线程都会强制退出，所以现阶段不要让进程退出
+    // 等待子线程执行，不然程序到这里直接结束，子线程还没来的及运行
+    system("sleep 3"); 
+    return 0;
+}
+```
+
+#### 线程退出
+
+```c
+#include <pthread.h>
+
+int pthread_join(pthread_t thread, void **retval);
+```
+功能: 堵塞等待一个子线程的退出，可以接收到某一个子线程调用pthread_exit时设置的退出状态值。 
+
+参数:  
+- thread: 指定线程的id
+- retval: 保存子线程的退出状态值，如果不接受则设置为NULL。 
+
+
+
+
 #### 线程和进程的区别
 
 单个线程的状态与进程状态非常类似。线程有一个程序计数器（PC），记录程序从哪里获取指令。每个线程有自己的一组用于计算的寄存器。所以，如果有两个线程运行在一个处理器上，从运行一个线程（T1）切换到另一个线程（T2）时，必定发生上下文切换（context switch）。线程之间的上下文切换类似于进程间的上下文切换。对于进程，我们将状态保存到进程控制块（Process Control Block，PCB）。现在，我们需要一个或多个线程控制块（Thread Control Block，TCB），保存每个线程的状态。但是，与进程相比，线程之间的上下文切换有一点主要区别：地址空间保持不变（即不需要切换当前使用的页表）。

From 99ff3b404f4e92b11253c307c742a6d071263992 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 23 Nov 2023 10:27:28 +0800
Subject: [PATCH 148/213] update opengl part

---
 .../1.OpenCV\347\256\200\344\273\213.md"      |   6 +-
 .../1.OpenGL\347\256\200\344\273\213.md"      | 450 +++++++++++++-----
 ...66\344\270\211\350\247\222\345\275\242.md" |  28 +-
 ...42\345\217\212\345\234\206\345\275\242.md" |  31 +-
 ...45\231\250\350\257\255\350\250\200GLSL.md" |  33 +-
 5 files changed, 408 insertions(+), 140 deletions(-)

diff --git "a/VideoDevelopment/OpenCV/1.OpenCV\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenCV/1.OpenCV\347\256\200\344\273\213.md"
index df0ceeee..d9b77c6e 100644
--- "a/VideoDevelopment/OpenCV/1.OpenCV\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenCV/1.OpenCV\347\256\200\344\273\213.md"
@@ -42,6 +42,10 @@ OpenCV用C++语言编写，它具有C ++，Python，Java和MATLAB接口，并支
 
 ### 数据结构：Mat
 
+Mat是一个基本图像容器，也是一个类，数据由两个部分组成:   
+- 矩阵头(包含矩阵尺寸、存储方法、存储地址等信息)
+- 一个指向存储所有像素值的矩阵的指针
+
 API：
 - imread(..url...)：加载本地图像
 	默认的BGR 彩色图像加载方式，此外支持灰度图像和任意格式。注意：在OpenCV中颜色值写法是BGR，而不是RGB。
@@ -55,7 +59,7 @@ API：
 - blur(...) ：模糊
 - cvtColor(...)：颜色转换
 - Canny(...)：提取边缘
-- waitKey(...)：等待按键
+- waitKey(int delay = 0)：等待按键
 - imwrite(...): 图片保存，支持各种格式
 
 ```c++
diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
index eeb9c5dc..26a08a44 100644
--- "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -1,38 +1,43 @@
 ## 1.OpenGL简介
 
-最近想要在播放器上做一个效果，需要用到OpenGL，一直以来也没关注学习过，就想着学习学习。在网上已经有很多文章，这里为什么还要写？主要是因为在学的
-时候发现那些文章看完后还是雨里雾里的不明白。要不就是不连贯，要不就是各种错误，各种理解的不对，而且版本不同，最开始看的3.0版本，后面我就都用3.0的来写，
-结果网上的例子都是2.0的，GLSL的语法不一样，搞的死活出不来效果，耽误时间，所以干脆我系统学一遍，顺便记录下来，写一个简单的，能从入门开始一步步学习的，
-文章里面有一些是从下面写的参考链接中拷贝过来的，也有一些是自己从书上看的。本书所有的例子都是用OpenGL ES3.0版本、GLSL ES 300版本来写。
-文章里面有一些是从下面写的参考链接中拷贝过来的，也有一些是自己从书上看的。
+OpenGL(Open Graphics Library开放图形库)是用于渲染2D、3D矢量图形的跨语言、跨平台的应用程序编程**接口**。
+
+
+然而，**OpenGL本身并不是一个API，它仅仅是一个由Khronos组织制定并维护的规范(Specification)**。
+
+**OpenGL规范严格规定了每个函数该如何执行，以及它们的输出值。至于内部具体每个函数是如何实现(Implement)的，将由编写OpenGL库的人自行决定。**
 
 [OpenGL官网](https://www.opengl.org/)
 
-OpenGL(Open Graphics Library开放图形库)是用于渲染2D、3D矢量图形的跨语言、跨平台的应用程序编程接口。
 
-OpenGL的前身是硅谷图形功能(SGI)公司为其图形工作站开发的IRIS GL,后来因为IRIS GL的移植性不好，所以在其基础上，开发出了OpenGl。OpenGl一般用
-于在图形工作站，PC端使用，由于性能各方面原因，在移动端使用OpenGl基本带不动。为此，Khronos公司就为OpenGl提供了一个子集，OpenGl ES(OpenGl for Embedded System)。
+OpenGL的前身是硅谷图形功能(SGI)公司为其图形工作站开发的IRIS GL,后来因为IRIS GL的移植性不好，所以在其基础上，开发出了OpenGL。
 
+OpenGL一般用于在图形工作站，PC端使用，由于性能各方面原因，在移动端使用OpenGL基本带不动。       
+为此，Khronos公司就为OpenGL提供了一个子集，OpenGL ES(OpenGL for Embedded System)。
 
 
 
 [后面文章所有的源码都在Github上](https://github.com/CharonChui/OpenGLES3.0StudyDemo)
+且本文章使用的OpenGL版本为OpenGL 3.3(对应OpenGL ES 版本为OpenGL ES 3.3)。 
 
 
 ### OpenGL ES
 
 [OpenGL ES 官网](https://www.khronos.org/opengles/)
 
-OpenGL ES是免费的跨平台的功能完善的2D/3D图形库接口的API,是OpenGL的一个子集,主要针对手机、Pad和游戏主机等嵌入式设备而设计。
+OpenGL ES是免费的跨平台的功能完善的2D/3D图形库接口的API, 是OpenGL的一个子集,主要针对手机、Pad和游戏主机等嵌入式设备而设计。
 
-移动端使用到的基本上都是OpenGL ES，当然Android开发下还专门为OpenGL提供了android.opengl包，并且提供了GlSurfaceView,GLU,GlUtils等工具类。
+移动端使用到的基本上都是OpenGL ES，当然Android开发下还专门为OpenGL提供了android.opengl包，并且提供了GlSurfaceView, GLU, GlUtils等工具类。         
 
+OpenGL ES由OpenGL裁剪而来，因此有必要了解一下两者版本的对应关系:       
 
+![image](https://github.com/CharonChui/Pictures/blob/master/opengl_vs_gles.png?raw=true)
 
 ### OpenGL的作用
 
-在手机上有两大元件，一个是CPU,一个是GPU。显示图形界面也有两种方式，一个是使用CPU渲染，一个是使用GPU渲染，但是目前为止最高效的方法就是有效的使用图形处理单元(GPU)，
-图像的处理和渲染就是在将要渲染到窗口上的像素上做很多的浮点运算，而GPU可以并行的做浮点运算，所以用GPU来分担CPU的部分，可以提高效率，可以说GPU渲染其实是一种硬件加速。
+在手机或电脑上有两大元件，一个是CPU,一个是GPU。      
+显示图形界面也有两种方式，一个是使用CPU渲染，一个是使用GPU渲染。        
+但是目前为止最高效的方法就是有效的使用图形处理单元(GPU)，图像的处理和渲染就是在将要渲染到窗口上的像素上做很多的浮点运算，而GPU可以并行的做浮点运算，所以用GPU来分担CPU的部分，可以提高效率，可以说GPU渲染其实是一种硬件加速。
 
 - 图片处理:比如图片色调转换、美颜等。
 - 摄像头预览效果处理。比如美颜相机、恶搞相机等。
@@ -52,136 +57,349 @@ Android中OpenGL ES的版本支持如下:
 
 
 
+### OpenGL状态机(State Machine)
+>>> As long as you keep in mind that OpenGL is basically one large state machine,most of its functionality will make more sense. 
+
+- OpenGL自身是一个巨大的状态机: 描述该如何操作的所有变量的大集合
+- OpenGL的状态通常被称为上下文(Context)
+- 状态设置函数(State-changing Function)
+- 状态应用的函数(State-using Function)
+
+![image](https://github.com/CharonChui/Pictures/blob/master/opengl_state_machine.png?raw=true)
+
+我们通过改变一些**上下文变量**来改变OpenGL的状态，从而告诉OpenGL如何去绘图。 
+
+既然OpenGL是一个大的状态机，那状态机中肯定会有两种函数:      
+
+- 设置状态的函数，例如`glClearColor(0.2f, 0.3f, 0.3f, 1.0f);`
+- 使用状态的函数，例如`glClear(GL_COLOR_BUFFER_BIT);`
+
+
+### OpenGL Context
+
+OpenGL是一个仅仅关注图像渲染的图像接口库，在渲染过程中它需要将顶点信息、纹理信息、编译好的着色器等渲染状态信息存储起来，而存储这些信息调用任何OpenGL函数前，必须先创建OpenGL Context，它存储了OpenGL的状态变量以及其他渲染有关的信息。            
+OpenGL是个状态机，有很多状态变量，是个标准的过程式操作过程，改变状态会影响后续所有的操作，这和面向对象的解耦原则不符，毕竟渲染本身就是个复杂的过程。               
+OpenGL采用Client-Server模型来解释OpenGL程序，即Server存储OpenGL Context，Client提出渲染请求，Server给予响应。之后的渲染工作就要依赖这些渲染状态信息来完成，当一个上下文被销毁时，它所对应的OpenGL渲染工作也将结束。
+
+
+OpenGL ES API没有提及如何创建渲染上下文，或者渲染上下文如何连接到原生窗口系统。EGL是Khronos渲染API(如OpenGL ES)和原生窗口系统之间的接口。
+
+### 对象
+OpenGL在开发的时候引入了一些抽象层，对象(Object)就是其中的一个。 
+
+一个对象是指一些选项的集合，代表OpenGL状态的一个子集。     
+
+可以将OpenGL中的对象看作是C语言中的结构体。   
+例如下面可以用一个对象代表绘制窗口的设置，之后就可以设置它的大小、窗口支持的颜色位数等值。 
+
+```	C
+struct object_Window_Target {
+    float set_window_size;    // 这里调用的是OpenGL提供的设置窗口大小的某个方法
+    float set_window_color;   // 这里调用的事OpenGL提供的设置窗口颜色位数的某个方法
+        ....
+}
+```
+
+通常把OpenGL上下文比作一个大的结构体，包含很多子集。  
+
+```C
+// OpenGL的状态
+struct OpenGL_Context {
+    ....
+    object *object_Window_Target;  // 设置窗口大小、颜色位数等的对象
+    ....
+}
+```
+
+但是，这样也有问题:        
+
+- 当前状态只有一份，如果每次显示不同的效果，都重新配置会很麻烦。 
+- 这时候我们就需要一些小助理(对象)，来帮忙记录某些状态信息，以便复用。  
+
+如果我们有10中子集，那就需要10个小助理(对象)，而当前状态(Context，只有一份)，可以通过装配这些对象来完成。 
+
+![image](https://github.com/CharonChui/Pictures/blob/master/opengl_zhuli.jpg?raw=true)
+
+
+
+
 ###  渲染管线
 
-在OpenGL中，任何事物都在3D空间中，而屏幕和窗口却是2D像素数组，这导致OpenGL的大部分工作都是关于把3D坐标转变为适应你屏幕的2D像素。3D坐标转为2D坐标的处理过程是由OpenGL的图形渲染管线（Graphics Pipeline，大多译为管线，实际上指的是一堆原始图形数据途经一个输送管道，期间经过各种变化处理最终出现在屏幕的过程）管理的。图形渲染管线可以被划分为两个主要部分：第一部分把你的3D坐标转换为2D坐标，第二部分是把2D坐标转变为实际的有颜色的像素。
+在OpenGL中，任何事物都在3D空间中，而屏幕和窗口却是2D像素数组，这导致OpenGL的大部分工作都是关于把3D坐标转变为适应你屏幕的2D像素。        
+
+3D坐标转为2D坐标的处理过程是由OpenGL的图形渲染管线（Graphics Pipeline，大多译为管线，实际上指的是一堆原始图形数据途经一个输送管道，期间经过各种变化处理最终出现在屏幕的过程）管理的。        
 
-图形渲染管线接受一组3D坐标，然后把它们转变为你屏幕上的有色2D像素输出。图形渲染管线可以被划分为几个阶段，每个阶段将会把前一个阶段的输出作为输入。所有这些阶段都是高度专门化的（它们都有一个特定的函数），并且很容易并行执行。正是由于它们具有并行执行的特性，当今大多数显卡都有成千上万的小处理核心，它们在GPU上为每一个（渲染管线）阶段运行各自的小程序，从而在图形渲染管线中快速处理你的数据。这些小程序叫做着色器(Shader)。
+图形渲染管线可以被划分为两个主要部分:       
+
+- 第一部分把你的3D坐标转换为2D坐标
+- 第二部分是把2D坐标转变为实际的有颜色的像素
+
+图形渲染管线接收一组3D坐标，然后把它们转变为你屏幕上的有色2D像素输出。          
+
+图形渲染管线可以被划分为几个阶段，每个阶段将会把前一个阶段的输出作为输入。      
+所有这些阶段都是高度专门化的（它们都有一个特定的函数），并且很容易并行执行。          
+正是由于它们具有并行执行的特性，当今大多数显卡都有成千上万的小处理核心，它们在GPU上为每一个（渲染管线）阶段运行各自的小程序，从而在图形渲染管线中快速处理你的数据。这些小程序叫做**着色器(Shader)**。
 
 简单来说，渲染管线就是一个顶点在呈现为像素之前经过的全部过程。
-OpenGL 1.x系列采用的是固定功能管线。
 
-OpenGL ES 2.0开始采用了可编程图形管线。
+- OpenGL 1.x系列采用的是固定功能管线。
+- OpenGL ES 2.0开始采用了可编程图形管线。
+- OpenGL ES 3.0兼容了2.0，并丰富了更多功能。
 
-OpenGL ES 3.0兼容了2.0，并丰富了更多功能。
+OpenGL渲染管线的流程为: 
+>> 顶点数据 -> 顶点着色器 -> 图元装配 -> 几何着色器 -> 光栅化 -> 片段着色器 -> 逐片段处理 -> 帧缓冲   
 
-OpenGL渲染管线的流程为: 顶点数据 -> 顶点着色器 -> 图元装配 -> 几何着色器 -> 光栅化 -> 片段着色器 -> 逐片段处理 -> 帧缓冲   
+OpenGL ES 3.0实现了具有可编程着色功能的图形管线，有两个规范组成:
 
-OpenGL ES 3.0实现了具有可编程着色功能的图形管线，有两个规范组成:OpenGL ES3.0 API规范和OpenGL ES着色语言3.0规范(OpenGL ES SL)。
+- OpenGL ES3.0 API规范
+- OpenGL ES着色语言3.0规范(OpenGL ES SL)。
 
 如下图，展示了OpenGL ES 3.0的图形管线。阴影的表示OpenGL ES 3.0管线中可编程阶段。
 
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/oepngl_es_pip.jpg)
 
-下面，你会看到一个图形渲染管线的每个阶段的抽象展示。要注意蓝色部分代表的是我们可以注入自定义的着色器的部分:
+下面，你会看到一个图形渲染管线的每个阶段的抽象展示。    
+要注意蓝色部分代表的是我们可以注入自定义的着色器的部分:
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_progress.jpg)
 
-首先，我们以数组的形式传递3个3D坐标作为图形渲染管线的输入，用来表示一个三角形，这个数组叫做顶点数据(Vertex Data)；顶点数据是一系列顶点的集合。一个顶点(Vertex)是一个3D坐标的数据的集合。而顶点数据是用顶点属性(Vertex Attribute)表示的，它可以包含任何我们想用的数据，但是简单起见，我们还是假定每个顶点只由一个3D位置和一些颜色值组成的吧。
+首先，我们以数组的形式传递3个3D坐标作为图形渲染管线的输入，用来表示一个三角形，这个数组叫做顶点数据(Vertex Data)；      
+顶点数据是一系列顶点的集合。     
+一个顶点(Vertex)是一个3D坐标的数据的集合。      
+而顶点数据是用顶点属性(Vertex Attribute)表示的，它可以包含任何我们想用的数据，但是简单起见，我们还是假定每个顶点只由一个3D位置和一些颜色值组成的吧。
+
+
+### 着色器
+
+着色器(shader)是在GPU上运行的小程序。     
+从名称可以看出，可通过处理它们来处理顶点。        
+此程序使用OpenGL ES SL语言来编写。           
+它是一个描述顶点或像素特性的简单程序。          
+**OpenGL最本质的概念之一就是着色器，它是图形硬件设备所执行的一类特殊函数。**               
+**理解着色器最好的办法就是把它看做是专为图形处理单元(即GPU)编译的一种小型程序。**   
+
+任何一种OpenGL程序本质上都可以被分为两部分：  
+
+- CPU端运行的部分，采用C++、Java之类的语言编写
+- GPU端运行的部分，使用GLSL语言编写
+
+### 顶点着色器     
+
+
+图形渲染管线的第一个部分是顶点着色器，他是用来渲染图形顶点的OpenGL ES代码。         
+它把一个单独的顶点作为输入。顶点着色器主要的目的是把3D坐标转为另一种3D坐标（后面会解释）从而生成每个顶点的最终位置，同时顶点着色器允许我们对顶点属性进行一些基本处理。
+
+
+顶点着色器可以操作的属性有: 位置、颜色、纹理坐标，但是不能创建新的顶点。最终产生纹理坐标、颜色、点位置等信息送往后续阶段。
+
+顶点着色器会在GPU上创建内存用于存储我们的顶点数据，还要配置OpenGL如何解释这些内存，并且指定其如何发送给显卡。顶点着色器接着会处理我们在内存中指定数量的顶点。
+
+我们通过顶点缓冲对象(Vertex Buffer Object, VBO)管理这个内存，它会在GPU内存(通常被称为显存)中储存大量顶点。      
+
+顶点缓冲对象是OpenGL中的一个对象(小助手)，就像OpenGL中的其它对象一样，这个缓冲有一个独一无二的ID，所以我们可以使用glGenBuffers()函数和一个缓冲ID生成一个VBO对象: 
+
+[OpenGL文档](https://docs.gl/)
+
+glGenBuffers函数的定义为:    
+
+```C
+// glGenBuffers — glGenBuffers returns n buffer object names in buffers. 
+void glGenBuffers(GLsizei n,
+    GLuint *buffers);
+// n : Specifies the number of buffer object names to be generated.
+// buffers : Specifies an array in which the generated buffer object names are stored. 
+```
+C使用:    
+
+```C
+GLuint vertex_buffer;
+// 创建一个小助理(对象)，并且给小助理起一个名字
+glGenBuffers(1, &vertex_buffer);
+```
+Java使用:  
+
+```java
+// 下面只生成一个vbo对象，所以这里申请一个容量为1的int型缓冲区就可以
+IntBuffer vbo = IntBuffer.allocate(1);
+// 该方法有两个参数，第一个是生成的数量，然后把它们的id储存在第二个参数的IntBuffer数组中
+GLES30.glGenBuffers(1, vbo);
+```
+在OpenGL中有很多缓冲对象类型，顶点缓冲对象的缓冲类型是GL_ARRAY_BUFFER。       
+OpenGL允许我们同时绑定多个缓冲，只要它们是不同的缓冲类型。       
+
+我们可以使用glBindBuffer函数把新创建的缓冲绑定到GL_ARRAY_BUFFER目标上，glBindBuffer函数的定义为:    
+
+```C
+// glBindBuffer — bind a named buffer object
+
+void glBindBuffer(GLenum target,
+    GLuint buffer);
+// target : Specifies the target to which the buffer object is bound. The symbolic constant must be GL_ARRAY_BUFFER, GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, GL_PIXEL_UNPACK_BUFFER, GL_TEXTURE_BUFFER, GL_TRANSFORM_FEEDBACK_BUFFER, or GL_UNIFORM_BUFFER.
+// buffer: Specifies the name of a buffer object.
+```
+C使用：  
+
+```C
+// 让上下文给这个小助理分配工作任务，让小助理明确这次的工作内容 (绑定小助理(对象)到上下文）
+glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
+```
+Java使用:           
+
+```java
+GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, vbo.get(0));
+```
+从这一刻起，我们使用的任何(在GL_ARRAY_BUFFER目标上的)缓冲调用都会用来配置当前绑定的缓冲(VBO)。      
+然后我们可以调用glBufferData()函数，它会把之前定义的顶点数据复制到缓冲的内存中(小助理把对应的数据单独记录下来了)。   
+      
+```C
+// glBufferData creates a new data store for the buffer object currently bound to target. 
+// glBufferData为当前绑定到的目标缓冲区对象创建一个新的数据存储
+void glBufferData(GLenum target,
+    GLsizeiptr size,
+    const GLvoid *data,
+    GLenum usage);
+
+// target : Specifies the target buffer object. The symbolic constant must be GL_ARRAY_BUFFER, GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, GL_ELEMENT_ARRAY_BUFFER, GL_PIXEL_PACK_BUFFER, GL_PIXEL_UNPACK_BUFFER, GL_TEXTURE_BUFFER, GL_TRANSFORM_FEEDBACK_BUFFER, or GL_UNIFORM_BUFFER.
+// size : Specifies the size in bytes of the buffer object's new data store.
+// data : Specifies a pointer to data that will be copied into the data store for initialization, or NULL if no data is to be copied.
+// usage : Specifies the expected usage pattern of the data store. The symbolic constant must be GL_STREAM_DRAW, GL_STREAM_READ, GL_STREAM_COPY, GL_STATIC_DRAW, GL_STATIC_READ, GL_STATIC_COPY, GL_DYNAMIC_DRAW, GL_DYNAMIC_READ, or GL_DYNAMIC_COPY.
+```
+C使用:          
+```C
+GLuint vertex_buffer; // Save this for later rendering
+glGenBuffers(1, &vertex_buffer);
+glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
+glBufferData(GL_ARRAY_BUFFER, data_size_in_bytes, NULL, GL_STATIC_DRAW);
+```
+Java使用:              
+
+```java
+GLES30.glBufferData(GLES30.GL_ARRAY_BUFFER, POSITION_VERTEX.size * 4,
+                vertexBuffer, GLES30.GL_STATIC_DRAW);
+```
+
+**至此，已经把顶点数据储存在显卡的内存中，用创建的这个VBO顶点缓冲对象管理**      
+
+glBufferData是一个专门用来把用户定义的数据复制到当前绑定缓冲的函数。也就是让小助理来记录需要的数据。  
+
+- 第一个参数是目标缓冲的类型：这里顶点缓冲对象当前绑定到GL_ARRAY_BUFFER目标上。
+- 第二个参数是指定传输数据的大小(以字节为单位)，c++中用一个简单的sizeof计算顶点数据的大小就可以，这里float的大小为4个字节。
+- 第三个参数是我们希望发送的实际数据。
+- 第四个参数指定了我们希望显卡如何管理给定的数据。它有三种常用的形式: 
+    - GL_STATIC_DRAW ：数据不会或几乎不会改变。
+    - GL_DYNAMIC_DRAW：数据会被改变很多。
+    - GL_STREAM_DRAW ：数据每次绘制时都会改变。
+    
+    
+**使用这些缓冲对象的好处是我们可以一次性的发送一大批数据到显卡上，而不是每个顶点发送一次。从CPU把数据发送到显卡相对较慢，所以只要可能我们都尝试尽量一次性发送尽可能多的数据。** 
 
+当数据发送至显卡的内存中后，顶点着色器几乎能立即访问顶点，这个是非常快的过程。
 
-- 顶点着色器(Vertex Shader): 图形渲染管线的第一个部分是顶点着色器，他是用来渲染图形顶点的OpenGL ES代码。它把一个单独的顶点作为输入。顶点着色器主要的目的是把3D坐标转为另一种3D坐标（后面会解释）从而生成每个顶点的最终位置，同时顶点着色器允许我们对顶点属性进行一些基本处理。
+整体总结为:     
 
-    着色器(shader)是在GPU上运行的小程序。从名称可以看出，可通过处理它们来处理顶点。此程序使用OpenGL ES SL语言来编写。它是一个描述顶点或像素特性的简单程序。OpenGL最本质的概念之一就是着色器，它是图形硬件设备所执行的一类特殊函数。理解着色器最好的办法就是把它看做是专为图形处理单元(即GPU)编译的一种小型程序。任何一种OpenGL程序本质上都可以被分为两部分：CPU端运行的部分，采用C++、Java之类的语言编写；以及GPU端运行的部分，使用GLSL语言编写。
+- 它会在GPU上创建内存，用于存储我们的顶点数据
+    - 通过顶点缓冲对象(Vertex Buffer Objects, VBO)来管理数据，顶点缓冲对象的缓冲类型是GL_ARRAY_BUFFER。
+    - OpenGL允许我们同时绑定多个缓冲，只要它们是不同的缓冲类型(每一个缓冲类型类似于前面说的子集，每个VBO是一个小助理)。
 
-    顶点着色器可以操作的属性有: 位置、颜色、纹理坐标，但是不能创建新的顶点。最终产生纹理坐标、颜色、点位置等信息送往后续阶段。
+- 配置OpenGL如何解释这些内存            
+    通过顶点数组对象(Vertex Array Objects, VAO）来管理，数组中的每一个项都对应一个属性的解析。        
+    **注意: VAO并不保存实际数据，而是放顶点结构的定义**
 
-    顶点着色器会在GPU上创建内存用于存储我们的顶点数据，还要配置OpenGL如何解释这些内存，并且指定其如何发送给显卡。顶点着色器接着会处理我们在内存中指定数量的顶点。
-    我们通过顶点缓冲对象(Vertex Buffer Object, VBO)管理这个内存，它会在GPU内存(通常被称为显存)中储存大量顶点。使用这些缓冲对象的好处是我们可以一次性的发送一大批数据到显卡上，而不是每个顶点发送一次。从CPU把数据发送到显卡相对较慢，所以只要可能我们都尝试尽量一次性发送尽可能多的数据。当数据发送至显卡的内存中后，顶点着色器几乎能立即访问顶点，这个是非常快的过程。
+![image](https://github.com/CharonChui/Pictures/blob/master/vao_vbo.jpg?raw=true)
 
-    OpenGLES2.0 编程中，用于绘制的顶点数组数据首先保存在 CPU 内存，在调用 glDrawArrays 或者 glDrawElements 等进行绘制时，需要将顶点数组数据从 CPU 内存拷贝到显存。
+    
 
-    但是很多时候我们没必要每次绘制的时候都去进行内存拷贝，如果可以在显存中缓存这些数据，就可以在很大程度上降低内存拷贝带来的开销。
+OpenGLES2.0编程中，用于绘制的顶点数组数据首先保存在CPU内存，在调用glDrawArrays或者glDrawElements等进行绘制时，需要将顶点数组数据从CPU内存拷贝到显存。
 
-    OpenGLES3.0 VBO 和 EBO 的出现就是为了解决这个问题。 VBO 和 EBO 的作用是在显存中提前开辟好一块内存，用于缓存顶点数据或者图元索引数据，从而避免每次绘制时的 CPU 与 GPU 之间的内存拷贝，可以提升渲染性能，降低内存带宽和功耗。
+但是很多时候我们没必要每次绘制的时候都去进行内存拷贝，如果可以在显存中缓存这些数据，就可以在很大程度上降低内存拷贝带来的开销。
 
+OpenGLES3.0 VBO和EBO的出现就是为了解决这个问题。VBO和EBO的作用是在显存中提前开辟好一块内存，用于缓存顶点数据或者图元索引数据，从而避免每次绘制时的CPU与GPU之间的内存拷贝，可以提升渲染性能，降低内存带宽和功耗。
 
-    顶点缓冲对象是OpenGL中的一个对象，就像OpenGL中的其它对象一样，这个缓冲有一个独一无二的ID，所以我们可以使用glGenBuffers()函数和一个缓冲ID生成一个VBO对象: 
-    ```java
-    // 下面只生成一个vbo对象，所以vbo的容量设置为1即可
-    IntBuffer vbo = IntBuffer.allocate(1);
-    // 该方法有两个参数，第一个是输入生成纹理的数量，然后把它们的id储存在第二个参数的IntBuffer数组中
-    GLES30.glGenBuffers(1, vbo);
-    ```
-    在OpenGL中有很多缓冲对象类型，顶点缓冲对象的缓冲类型是GL_ARRAY_BUFFER。OpenGL允许我们同时绑定多个缓冲，只要它们是不同的缓冲类型。我们可以使用glBindBuffer函数把新创建的缓冲绑定到GL_ARRAY_BUFFER目标上:  
-    ```java
-    GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, vbo.get(0));
-    ```
-    从这一刻起，我们使用的任何(在GL_ARRAY_BUFFER目标上的)缓冲调用都会用来配置当前绑定的缓冲(VBO)。然后我们可以调用glBufferData()函数，它会把之前定义的顶点数据复制到缓冲的内存中:   
-    ```java
-    GLES30.glBufferData(GLES30.GL_ARRAY_BUFFER, POSITION_VERTEX.size * 4,
-                    vertexBuffer, GLES30.GL_STATIC_DRAW);
-    ```
-    glBufferData是一个专门用来把用户定义的数据复制到当前绑定缓冲的函数。
-    他的第一个参数是目标缓冲的类型：顶点缓冲对象当前绑定到GL_ARRAY_BUFFER目标上。
-    第二个参数是指定传输数据的大小(以字节为单位)，c++中用一个简单的sizeof计算顶点数据的大小就可以，这里float的大小为4个字节。
-    第三个参数是我们希望发送的实际数据。
-    第四个参数指定了我们希望显卡如何管理给定的数据。它有三种形式: 
-    - GL_STATIC_DRAW ：数据不会或几乎不会改变。
-    - GL_DYNAMIC_DRAW：数据会被改变很多。
-    - GL_STREAM_DRAW ：数据每次绘制时都会改变。
+把数据发送给OpenGL管线还要更加复杂一点，有两种方式:    
 
-    把数据发送给OpenGL管线还要更加复杂一点，有两种方式:      
-    - 通过顶点属性的缓冲区；
-    - 直接发送给统一变量。
-    理解这两种方式的机制非常重要，因为这样我们才能为每个要发送的项目选取合适的方式。  
+- 通过顶点属性的缓冲区；
+- 直接发送给统一变量。
 
+理解这两种方式的机制非常重要，因为这样我们才能为每个要发送的项目选取合适的方式。  
 
-#####　缓冲区和顶点属性    
 
-想要绘制一个对象，它的顶点数据需要发送给顶点着色器。通常会把顶点数据在放入一个缓冲区，并把这个缓冲区和着色器中声明的顶点属性相关联。要完成这件事，有好几个步骤需要做，有些步骤只需要做一次，而对于动画场景，一些步骤则需要每帧做一次。只做一次的步骤如下，它们一般包含在init()中:      
+### 缓冲区和顶点属性    
+
+想要绘制一个对象，它的顶点数据需要发送给顶点着色器。       
+通常会把顶点数据在放入一个缓冲区，并把这个缓冲区和着色器中声明的顶点属性相关联。         
+要完成这件事，有好几个步骤需要做，有些步骤只需要做一次，而对于动画场景，一些步骤则需要每帧做一次。只做一次的步骤如下，它们一般包含在init()中:      
 
 - 创建缓冲区。
 - 将顶点数据复制到缓冲区。    
-    每帧都要做的步骤如下，它们一般包含在display()中。
+    - 每帧都要做的步骤如下，它们一般包含在display()中。
 - 启用包含顶点数据的缓冲区。
 - 将这个缓冲区和一个顶点属性相关联。
 - 启用这个顶点属性。
-- 使用glDrawArrays()绘制对象。
-所有缓冲区通常都在程序开始的时候统一创建，可以在init()中，或者在被init()调用的函数中。在OpenGL中，缓冲区被包含在顶点缓冲对象(Vertex Buffer Object, VBO)中，VBO在OpenGL应用程序中被声明和实例化。一个场景可能需要很多VBO，所以我们常常会在init()中生成并填充若干个VBO，以备程序需要时直接使用。
+- 使用glDrawArrays()绘制对象。      
+
+所有缓冲区通常都在程序开始的时候统一创建，可以在init()中，或者在被init()调用的函数中。       
+
+在OpenGL中，缓冲区被包含在顶点缓冲对象(Vertex Buffer Object, VBO)中，VBO在OpenGL应用程序中被声明和实例化。      
+
+一个场景可能需要很多VBO，所以我们常常会在init()中生成并填充若干个VBO，以备程序需要时直接使用。
 
 
-- 图元装配(Primitive Assembly)
+### 图元装配(Primitive Assembly)
 
-    顶点组合成图元的过程叫做图元装配，这里的图元就是指点、线、三角。     
-    图元装配阶段将顶点着色器输出的所有顶点作为输入(如果是GL_POINTS，那么就是一个顶点),并将所有的点装配成指定的图元的形状。           
-    也就是说图元装配是将顶点着色器中设置的顶点数据装配成指定图元的形状。    
+顶点组合成图元的过程叫做图元装配，这里的图元就是指点、线、三角。           
+图元装配阶段将顶点着色器输出的所有顶点作为输入(如果是GL_POINTS，那么就是一个顶点),并将所有的点装配成指定的图元的形状。           
+也就是说图元装配是将顶点着色器中设置的顶点数据装配成指定图元的形状。           
 
-    OpenGL ES中最基础且唯一的多边形就是三角形，所有更复杂的图形都是由三角形组成的。复杂的图形都可以拆分成多个三角形。比如OpenGL提供给开发者的绘制方法glDrawArrays，这个方法的第一个参数就是指定绘制方式，可选值有:  
+OpenGL中最基础且唯一的多边形就是三角形，所有更复杂的图形都是由三角形组成的。复杂的图形都可以拆分成多个三角形。比如OpenGL提供给开发者的绘制方法glDrawArrays，这个方法的第一个参数就是指定绘制方式，可选值有:  
 
-    - GL_POINTS:以点的形式绘制
-    - GL_LINES:以线的形式绘制
-    - GL_TRIANGLE_STRIP:以三角形的形式绘制，所有二维图像的渲染都会使用这种方式。
+- GL_POINTS:以点的形式绘制
+- GL_LINES:以线的形式绘制
+- GL_TRIANGLE_STRIP:以三角形的形式绘制，所有二维图像的渲染都会使用这种方式。
 
-    该过程还有两个重要操作：裁剪和淘汰。
-    - 裁剪是指对于不在视椎体(屏幕上可见的3D区域)内的图元进行裁剪。
-    - 淘汰是指根据图元面向前方或后方选择抛弃它们(如事物内部的点)。
+该过程还有两个重要操作，裁剪和淘汰:      
+
+- 裁剪是指对于不在视椎体(屏幕上可见的3D区域)内的图元进行裁剪。
+- 淘汰是指根据图元面向前方或后方选择抛弃它们(如事物内部的点)。
    
-- 几何着色器(Geometry Shader)     
-    图元装配阶段的输出会传递给几何着色器(Geometry Shader)。几何着色器把图元形式的一系列顶点的集合作为输入，它可以通过产生新顶点构造出新的图元来生成其他形状。本例子中，它生成了另一个三角形。
+### 几何着色器(Geometry Shader)     
+
+图元装配阶段的输出会传递给几何着色器(Geometry Shader)。        
+
+几何着色器把图元形式的一系列顶点的集合作为输入，它可以通过产生新顶点构造出新的图元来生成其他形状。例如它生成了另一个三角形。
+
+几何着色器的输出会被传入光栅化阶段(Rasterization Stage)，这里它会把图元映射为最终屏幕上相应的像素，生成供片段着色器(Fragment Shader)使用的片段(Fragment)。          
+
+在片段着色器运行之前会执行裁切(Clipping)。裁切会丢弃超出你的视图以外的所有像素，用来提升执行效率。
+
+### 光栅化阶段(Rasterization Stage)
+
+这里会把图元映射为最终屏幕上相应的像素，生成供片段着色器(fragment shader)使用的片段。       
+在图元装配后传递过来的图元数据中，这些图元信息只是顶点而已。         
+顶点处都还没有像素点，直线段端点之间是空的、多边形的边和内部也是空的，光栅化的任务就是构造这些。将图片转化为片段(fragment)的过程叫做光栅化。        
+
+这个阶段会将图元数据分解成更小的单元并对应于帧缓冲区的各个像素，这些单元成为片元，一个片元可能包含窗口颜色、纹理坐标等属性。
 
-    几何着色器的输出会被传入光栅化阶段(Rasterization Stage)，这里它会把图元映射为最终屏幕上相应的像素，生成供片段着色器(Fragment Shader)使用的片段(Fragment)。在片段着色器运行之前会执行裁切(Clipping)。裁切会丢弃超出你的视图以外的所有像素，用来提升执行效率。
-- 光栅化阶段(Rasterization Stage)
+光栅化其实是一种将几何图元变成二维图像的过程。在这里，虚拟3D世界中的物体投影到平面上，并生成一系列的片段。    
 
-    这里会把图元映射为最终屏幕上相应的像素，生成供片段着色器(fragment shader)使用的片段。     
-    在图元装配后传递过来的图元数据中，这些图元信息只是顶点而已。顶点处都还没有像素点，直线段端点之间是空的、多边形的边和内部也是空的，光栅化的任务就是构造这些。将图片转化为片段(fragment)的过程叫做光栅化。      
-    这个阶段会将图元数据分解成更小的单元并对应于帧缓冲区的各个像素，这些单元成为片元，一个片元可能包含窗口颜色、纹理坐标等属性。
+### 片段着色器或片元着色器(Fragment Shader)
 
-    光栅化其实是一种将几何图元变成二维图像的过程。在这里，虚拟3D世界中的物体投影到平面上，并生成一系列的片段。  
+使用颜色或纹理(texture)渲染图形表面的OpenGLES代码。
 
-- 片段着色器或片元着色器(Fragment Shader):使用颜色或纹理(texture)渲染图形表面的OpenGLES代码。
+主要目的是计算一个像素的最终颜色。         
 
-    主要目的是计算一个像素的最终颜色。光栅化操作构造了像素点，这个阶段就是处理这些像素点，根据自己的业务，例如高亮、饱和度调节、高斯模糊等来变化这个片元的颜色。为组成点、直线和三角形的每个片元生成最终颜色/纹理，针对每个片元都会执行一次，一个片元是一个小的、单一颜色的长方形区域，类似于计算机屏幕上的一个像素。一旦最终颜色生成，OpenGL就会把它们写到一块成为帧缓冲区的内存块中，然后Android就会把这个帧缓冲区显示到屏幕上。
+光栅化操作构造了像素点，这个阶段就是处理这些像素点，根据自己的业务，例如高亮、饱和度调节、高斯模糊等来变化这个片元的颜色。      
+为组成点、直线和三角形的每个片元生成最终颜色/纹理，针对每个片元都会执行一次，一个片元是一个小的、单一颜色的长方形区域，类似于计算机屏幕上的一个像素。        
+一旦最终颜色生成，OpenGL就会把它们写到一块成为帧缓冲区的内存块中，然后Android就会把这个帧缓冲区显示到屏幕上。
 
-    通常在这里对片段进行处理(纹理采样、颜色汇总等)，将每个片段的颜色等属性计算出来并送给后续阶段。
+通常在这里对片段进行处理(纹理采样、颜色汇总等)，将每个片段的颜色等属性计算出来并送给后续阶段。
 
 可以看到，图形渲染管线非常复杂，它包含很多可配置的部分。然而，对于大多数场合，我们只需要配置顶点和片段着色器就行了。几何着色器是可选的，通常使用它默认的着色器就行了。
 
-在现代OpenGL中，我们必须定义至少一个顶点着色器和一个片段着色器（因为GPU中没有默认的顶点/片段着色器）。
+**在现代OpenGL中，我们必须定义至少一个顶点着色器和一个片段着色器（因为GPU中没有默认的顶点/片段着色器）。**  
 
-- 逐片段操作
+整个处理过程又分为以下几个部分:     
 
+- 逐片段操作
     具体的细分步骤又分为:  
-
     ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_fragment_opera.jpg)
 
   - 像素归属测试
@@ -208,62 +426,54 @@ OpenGL ES 3.0实现了具有可编程着色功能的图形管线，有两个规
 
     用于最小化，因为使用有限精度在帧缓冲区中保存颜色值而产生的伪像，使用少量颜色模拟更宽的颜色范围。
 
-- 帧缓冲区
-    OpenGL实际上并不是把图像直接绘制到计算机屏幕上，而是将之渲染到一个帧缓冲区，然后由计算机来负责把帧缓冲区中的内容绘制到屏幕上的一个窗口中。
-    OpenGL管线的最终渲染目的地被称为帧缓存(framebuffer也被记做FBO)
+### 帧缓冲区
 
-- 着色器语言
+OpenGL实际上并不是把图像直接绘制到计算机屏幕上，而是将之渲染到一个帧缓冲区，然后由计算机来负责把帧缓冲区中的内容绘制到屏幕上的一个窗口中。            
 
-    GLSL(OpenGL Shading Language)是OpenGL着色语言。
+OpenGL管线的最终渲染目的地被称为帧缓存(framebuffer也被记做FBO)
 
-    在图形卡的GPU上执行，代替了固定的渲染管线的一部分，是渲染管线中不同层次具有可编程性，例如：视图转换、投影转换等。GLSL的着色器代码分为两个部分: 
+### 着色器语言
 
-  - 顶点着色器(Vertex Shader)
-  - 片段着色器(Fragment Shader)
+GLSL(OpenGL Shading Language)是OpenGL着色语言。
 
-- 坐标系
+在图形卡的GPU上执行，代替了固定的渲染管线的一部分，是渲染管线中不同层次具有可编程性，例如：视图转换、投影转换等。GLSL的着色器代码分为两个部分: 
 
-    OpenGL ES是一个3D的世界，由x、y、z坐标组成顶点坐标。采用虚拟的右手坐标。
-
-    ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_xy.png)
-
-    OpenGL ES采用的是右手坐标，选取屏幕中心为原点，从原点到屏幕边缘默认长度为1，也就是默认情况下，从原点到x左边的1和到y左边的1的位置在屏幕上显示的并不相同。
-
-- 形状面和缠绕
+  - 顶点着色器(Vertex Shader)
+  - 片段着色器(Fragment Shader)
 
-    在OpenGL的世界里，我们只能画点、线、三角形，图元装配中说到所有复杂的图形都是由三角形组成。
+### 坐标系
 
-    ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_ex_xy_1.jpg)
+OpenGL ES是一个3D的世界，由x、y、z坐标组成顶点坐标。采用虚拟的右手坐标。
 
-    三角形的点按顺序定义，使得它们以逆时针方向绘制。绘制这些坐标的顺序定义了形状的缠绕方向。默认情况下，在OpenGL中，逆时针绘制的面是正面。
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_xy.png)
 
-- 程式(Program)
+OpenGL采用的是右手坐标，选取屏幕中心为原点，从原点到屏幕边缘默认长度为1，也就是默认情况下，从原点到x左边的1和到y左边的1的位置在屏幕上显示的并不相同。
 
-    一个OpenGL ES对象，包含了你所希望用来绘制图形所要用到的着色器，最后顶点着色器和片元着色器都要放入到程式中，然后才可以使用，简单的说就是将两个着色器变为一个对象。
+### 形状面和缠绕
 
+在OpenGL的世界里，我们只能画点、线、三角形，图元装配中说到所有复杂的图形都是由三角形组成。
 
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_ex_xy_1.jpg)
 
-如果想要绘制图像，需要至少一个顶点着色器来定义一个图形顶点，以及一个片元着色器为该图形上色。这些着色器必须被编译然后再添加到一个OpenGL ES Program中，并利用这个Program来绘制形状。
+三角形的点按顺序定义，使得它们以逆时针方向绘制。绘制这些坐标的顺序定义了形状的缠绕方向。默认情况下，在OpenGL中，逆时针绘制的面是正面。
 
+### 程式(Program)
 
+一个OpenGL对象，包含了你所希望用来绘制图形所要用到的着色器，最后顶点着色器和片元着色器都要放入到程式中，然后才可以使用，简单的说就是将两个着色器变为一个程序对象。
 
-### OpenGL Context
 
-OpenGL是一个仅仅关注图像渲染的图像接口库，在渲染过程中它需要将顶点信息、纹理信息、编译好的着色器等渲染状态信息存储起来，而存储这些信息调用任何OpenGL函数前，必须先创建OpenGL Context，它存储了OpenGL的状态变量以及其他渲染有关的信息。     
-OpenGL是个状态机，有很多状态变量，是个标准的过程式操作过程，改变状态会影响后续所有的操作，这和面向对象的解耦原则不符，毕竟渲染本身就是个复杂的过程。
-OpenGL采用Client-Server模型来解释OpenGL程序，即Server存储OpenGL Context，Client提出渲染请求，Server给予响应。之后的渲染工作就要依赖这些渲染状态信息来完成，当一个上下文被销毁时，它所对应的OpenGL渲染工作也将结束。
+如果想要绘制图像，需要至少一个顶点着色器来定义一个图形顶点，以及一个片元着色器为该图形上色。这些着色器必须被编译然后再添加到一个OpenGL Program中，并利用这个Program来绘制形状。
 
 
-OpenGL ES API没有提及如何创建渲染上下文，或者渲染上下文如何连接到原生窗口系统。EGL是Khronos渲染API(如OpenGL ES)和原生窗口系统之间的接口。
 ### EGL
 
 在OpenGL的设计中，OpenGL是不负责管理窗口的，窗口的管理交由各个设备自己完成。具体的来说就是iOS平台上使用EAGL提供本地平台对OpenGL的实现，在Android平台上使用EGL提供本地平台对OpenGL的实现。OpenGL其实是通过GPU进行渲染。但是我们的程序是运行在CPU上，要与GPU关联，这就需要通过EGL，它相当于Android上层应用于GPU通讯的中间层。
 
 EGL提供了OpenGL ES和运行于计算机上的原生窗口系统(如Windows、Mac OSX)之间的一个“结合”层次。    
-在EGL能够确定可用的绘制表面类型(或者底层系统的其他特性)之前，它必须打开和窗口系统的通信渠道。注意。Apple提供自己的EGL API的iOS实现，成为EAGL。     
+在EGL能够确定可用的绘制表面类型(或者底层系统的其他特性)之前，它必须打开和窗口系统的通信渠道。注意。Apple提供自己的EGL API的iOS实现，称为EAGL。     
 因为每个窗口系统都有不同的语言，所以EGL提供基本的不透明类型--EGLDisplay，该类型封装了所有系统相关性，用于和原生窗口系统接口。任何使用EGL的应用程序必须执行的第一个操作就是创建和初始化与本地EGL显示的连接。
 
-EGL 是 OpenGL ES 和本地窗口系统（Native Window System）之间的通信接口，它的主要作用：
+EGL是OpenGL和本地窗口系统（Native Window System）之间的通信接口，它的主要作用：
 
 - 与设备的原生窗口系统通信；
 - 查询绘图表面的可用类型和配置；
@@ -273,7 +483,9 @@ EGL 是 OpenGL ES 和本地窗口系统（Native Window System）之间的通信
 OpenGL ES 的平台无关性正是借助 EGL 实现的，EGL 屏蔽了不同平台的差异（Apple 提供了自己的 EGL API 的 iOS 实现，自称 EAGL）。
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/egl_interface_1.png?raw=true)
-上图中: 
+
+上图中:        
+
 - Display(EGLDisplay) 是对实际显示设备的抽象；
 - Surface（EGLSurface）是对用来存储图像的内存区域 FrameBuffer 的抽象，包括 Color Buffer（颜色缓冲区）， Stencil Buffer（模板缓冲区） ，Depth Buffer（深度缓冲区）；
 - Context (EGLContext) 存储 OpenGL ES 绘图的一些状态信息；
@@ -281,7 +493,6 @@ OpenGL ES 的平台无关性正是借助 EGL 实现的，EGL 屏蔽了不同平
 
 
 
-
 本地窗口相关的 API 提供了访问本地窗口系统的接口，而 EGL 可以创建渲染表面 EGLSurface ，同时提供了图形渲染上下文 EGLContext，用来进行状态管理，接下来 OpenGL ES 就可以在这个渲染表面上绘制。
 
 
@@ -321,7 +532,7 @@ EGL为双缓冲工作模式(Double Buffer)，既有一个Back Frame Buffer和一
 通过上述操作，就完成了EGL的初始化设置，便可以进行OpenGL的渲染操作。所有EGL命令都是以egl前缀开始，对组成命令名的每个单词使用首字母大写(如eglCreateWindowSurface)。
 
 #### 创建屏幕外渲染区域: EGL Pbuffer
-除了可以用OpenGL ES在屏幕上的窗口渲染之外，还可以渲染称作pbuffer(像素缓冲区Pixel buffer的缩写)的不可见屏幕外表面。         
+除了可以用OpenGL在屏幕上的窗口渲染之外，还可以渲染称作pbuffer(像素缓冲区Pixel buffer的缩写)的不可见屏幕外表面。          
 和窗口一样，Pbuffer可以利用OpenGL ES3.0中的任何硬件加速。      
 Pbuffer最常用于生成纹理贴图。如果你想要做的是渲染到一个纹理，那么我们建议使用帧缓冲区对象代替Pbuffer，因为帧缓冲区更高效。不过，在某些帧缓冲区对象无法使用的情况下，Pbuffer仍然有用，例如用OpenGL ES在屏幕外表面上渲染，然后将其作为其他API(如OpenVG)中的纹理。     
 创建Pbuffer和创建EGL窗口非常相似，只有少数微小的不同。为了创建Pbuffer，需要和窗口一样找到EGLConfig，并作一处修改：我们需要扩增EGL_SURFACE_TYPE的值，使其包含EGL_PBUFFER_BIT。
@@ -333,7 +544,6 @@ Pbuffer最常用于生成纹理贴图。如果你想要做的是渲染到一个
 纹理(Texture)是一个2D图片(也有1D和3D纹理)，他可以用来添加物体的细节，你可以想象纹理是一张绘有砖块的纸，无缝折叠贴合到你的3D房子上，这样你的房子看起来就有砖墙的外表了。
 
 
-
 Android 通过其框架 API 和原生开发套件 (NDK) 来支持 OpenGL。
 
 Android 框架中有如下两个基本类，用于通过 OpenGL ES API 来创建和操控图形：`GLSurfaceView` 和 `GLSurfaceView.Renderer`。
diff --git "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md" "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"
index 36391f49..4b9285ba 100644
--- "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
@@ -10,6 +10,7 @@ OpenGL ES的绘制需要有以下步骤:
   所有在这个范围内的坐标叫做标准化设备坐标(Normalized Device Coordinates)，此范围内的坐标最终显示在屏幕上（在这个范围以外的坐标则不会显示）。
 
 由于我们希望渲染一个三角形，我们一共要指定三个顶点，每个顶点都有一个3D位置。我们会将它们以标准化设备坐标的形式（OpenGL的可见区域）定义为一个float数组。
+
 ```glsl
 float vertices[] = {
     -0.5f, -0.5f, 0.0f,
@@ -98,6 +99,7 @@ GLES30.glLinkProgram(shaderProgramId);
 链接完后需要使用glUseProgram方法，用刚创建的程序对象的Id作为参数，以激活这个程序对象。调用glUserProgram方法后，所有后续的渲染将用连接到这个程序对象的顶点和片段着色器进行。
 
 对了，在把着色器对象链接到程序对象以后，记得删除着色器对象，我们不再需要它们了：
+
 ```java
 GLES30.glDeleteShader(vertexShaderId);
 GLES30.glDeleteShader(fragmentShaderId);
@@ -121,13 +123,13 @@ GLES30.glDeleteShader(fragmentShaderId);
 
 有了这些信息我们就可以使用glVertexAttribPointer函数告诉OpenGL该如何解析顶点数据（应用到逐个顶点属性上）了：
 
-  ```
+  ```java
 // glVertexAttribPointer是把顶点位置属性赋值给着色器程序
 // 第一个参数0是上面着色器中写的vPosition的变量位置(location = 0)。意思就是绑定vertex坐标数据，然后将在vertextBuffer中的顶点数据传给vPosition变量。
 // 你肯定会想，如果我在着色器中不写呢？int vposition = glGetAttribLocation(program, "vPosition");就可以获得他的属性位置了
 // 第二个size是3，是因为上面我们triangleCoords声明的属性就是3位，xyz
 GLES30.glVertexAttribPointer(0, 3, GLES30.GL_FLOAT, false, 3 * 4, vertexBuffer);
-//启用顶点变量，这个0也是vPosition在着色器变量中的位置，和上面一样，在着色器文件中的location=0声明的
+//启用顶点变量，参数为数据中第一个值在缓冲开始的位置。 这个0也是vPosition在着色器变量中的位置，和上面一样，在着色器文件中的location=0声明的
 GLES30.glEnableVertexAttribArray(0);
   ```
 
@@ -146,8 +148,10 @@ GLES30.glEnableVertexAttribArray(0);
 由于在调用glVertexAttribPointer之前绑定的是先前定义的VBO对象，顶点属性现在会链接到它的顶点数据。
 
 现在我们已经定义了OpenGL该如何解释顶点数据，接着应该使用glEnableVertexAttribArray，以顶点属性位置值作为参数，启用顶点属性；顶点属性默认是禁用的。    
+
 自此，所有东西都已经设置好了：我们使用一个顶点缓冲对象将顶点数据初始化至缓冲中，建立了一个顶点和一个片段着色器，并告诉了OpenGL如何把顶点数据链接到顶点着色器的顶点属性上。    
 在OpenGL中绘制一个物体，代码会像是这样：
+
 ```java
 // 0. 复制顶点数组到缓冲中供OpenGL使用,使用glGenBuffers函数和一个缓冲ID生成一个VBO对象
 IntBuffer vbo = IntBuffer.allocate(1);
@@ -184,12 +188,15 @@ someOpenGLFunctionThatDrawsOurTriangle();
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/vertex_array_objects.png)
 
 创建一个VAO和创建一个VBO很类似：
+
 ```java
 IntBuffer arrays = IntBuffer.allocate(1);
 GLES30.glGenVertexArrays(1, arrays);
 ```
 要想使用VAO，要做的只是使用glBindVertexArray绑定VAO。从绑定之后起，我们应该绑定和配置对应的VBO和属性指针，之后解绑VAO供之后使用。    
 当我们打算绘制一个物体的时候，我们只要在绘制物体前简单地把VAO绑定到希望使用的设定上就行了。这段代码应该看起来像这样：
+
+VAO小助理偷偷帮我们记录一切：   
 ```java
 // ..:: 初始化代码（只运行一次 (除非你的物体频繁改变)） :: ..
 // 1. 绑定VAO
@@ -211,9 +218,15 @@ GLES30.glBindVertexArray(0);
 someOpenGLFunctionThatDrawsOurTriangle();
 ```
 
-就这么多了！前面做的一切都是等待这一刻，一个储存了我们顶点属性配置和应使用的VBO的顶点数组对象。一般当你打算绘制多个物体时，你首先要生成/配置所有的VAO（和必须的VBO及属性指针)，然后储存它们供后面使用。    
+就这么多了！前面做的一切都是等待这一刻，一个储存了我们顶点属性配置和应使用的VBO的顶点数组对象。        
+一般当你打算绘制多个物体时，你首先要生成/配置所有的VAO（和必须的VBO及属性指针)，然后储存它们供后面使用。    
 注意： 先绑定VAO后再绑定VBO，这样他们才能关联起来当我们打算绘制物体的时候就拿出相应的VAO，绑定它，绘制完物体后，再解绑VAO。
 
+![image](https://github.com/CharonChui/Pictures/blob/master/vao_vbo.jpg?raw=true)
+
+
+当目前是GL_ELEMENT_ARRAY_BUFFER的时候，VAO会储存glBindBuffer的函数调用(这也意味着它也会存储解绑调用)。     
+当时VAO不会存储GL_ARRAY_BUFFER(VBO)的glBindBuffer的函数调用。   
 
 
 
@@ -242,6 +255,7 @@ Preferences -> Plugins -> 搜GLSL Support安装就可以了。
 安装完GLSL插件后，就可以开始了。一般将GLSL文件放到raw或assets目录，我们这里在raw目录上右键New，然后选择GLSL Shader创建就可以了，创建后默认会生成一个main()函数。
 
 - 顶点着色器(triangle_vertex_shader.glsl)
+
 ```glsl 
 // 声明着色器的版本 
 #version 300 es 
@@ -283,12 +297,14 @@ precision是精度限定符，它可以使着色器创作者指定着色器变
 在较低的精度上，有些OpenGL ES实现在运行着色器时可能更快，或者电源效率更高。当然这种效率提升是以精度为代价的，在没有正确使用精度限定符时可能造成伪像。
 
 精度限定符可以用于指定任何浮点数或整数的变量的精度。指定精度的关键字是lowp、mediump和highp。下面是一些带有精度限定符的声明示例: 
-```
+
+```glsl
 highp vec4 position;
 mediump float specularExp;
 ```
 除了精度限定符之外，还有默认精度的概念。也就是说，如果变量声明时没有使用精度限定符，它将拥有该类型的默认精度。默认精度限定符在顶点或片段着色器的开头用以下语法指定： 
-```
+
+```glsl
 precision highp float;
 precision mediump int;
 ```
@@ -570,7 +586,7 @@ public class TriangleRender implements GLSurfaceView.Renderer {
 ```
 
 
-调用glCreateShader将根据传入的type参数创建一个新的顶点或片段着色器。返回值是指向新着色器对象的句柄。当完成链接着色器对象时，可以用glDeleteShader删除。            
+调用glCreateShader将根据传入的type参数创建一个新的顶点或片段着色器。返回值是指向新着色器对象的句柄。当完成链接着色器对象时，可以用glDeleteShader删除。             
 注意，如果一个着色器连接到一个程序对象，那么调用glDeleteShader不会立即删除着色器，而是将着色器编标记为删除，在着色器不再连接到任何程序对象时，它的内存将被释放。
 
 效果如下:   
diff --git "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md" "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"
index a44d86be..c73d718e 100644
--- "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"	
@@ -158,7 +158,11 @@ public abstract class BaseGLSurfaceViewRenderer implements GLSurfaceView.Rendere
 
 
 ### 元素缓冲对象(EBO)
-在渲染顶点这一话题上我们还有最后一个需要讨论的东西——元素缓冲对象(Element Buffer Object，EBO)，也叫索引缓冲对象(Index Buffer Object，IBO)。要解释元素缓冲对象的工作方式最好还是举个例子：假设我们不再绘制一个三角形而是绘制一个矩形。我们可以绘制两个三角形来组成一个矩形（OpenGL主要处理三角形）。这会生成下面的顶点的集合：
+在渲染顶点这一话题上我们还有最后一个需要讨论的东西——元素缓冲对象(Element Buffer Object，EBO)，也叫索引缓冲对象(Index Buffer Object，IBO)。       
+
+要解释元素缓冲对象的工作方式最好还是举个例子：假设我们不再绘制一个三角形而是绘制一个矩形。       
+我们可以绘制两个三角形来组成一个矩形（OpenGL主要处理三角形）。这会生成下面的顶点的集合：
+
 ```java
 float vertices[] = {
     // 第一个三角形
@@ -171,10 +175,17 @@ float vertices[] = {
     -0.5f, 0.5f, 0.0f   // 左上角
 };
 ```
-可以看到，有几个顶点叠加了。我们指定了右下角和左上角两次！一个矩形只有4个而不是6个顶点，这样就产生50%的额外开销。当我们有包括上千个三角形的模型之后这个问题会更糟糕，这会产生一大堆浪费。更好的解决方案是只储存不同的顶点，并设定绘制这些顶点的顺序。这样子我们只要储存4个顶点就能绘制矩形了，之后只要指定绘制的顺序就行了。如果OpenGL提供这个功能就好了，对吧？
+可以看到，有几个顶点叠加了。        
+我们指定了右下角和左上角两次！       
+
+一个矩形只有4个而不是6个顶点，这样就产生50%的额外开销。       
+当我们有包括上千个三角形的模型之后这个问题会更糟糕，这会产生一大堆浪费。        
+
+更好的解决方案是只储存不同的顶点，并设定绘制这些顶点的顺序。这样子我们只要储存4个顶点就能绘制矩形了，之后只要指定绘制的顺序就行了。如果OpenGL提供这个功能就好了，对吧？
 
 值得庆幸的是，元素缓冲区对象的工作方式正是如此。 EBO是一个缓冲区，就像一个顶点缓冲区对象一样，它存储 OpenGL 用来决定要绘制哪些顶点的索引。    
 这种所谓的索引绘制(Indexed Drawing)正是我们问题的解决方案。首先，我们先要定义（不重复的）顶点，和绘制出矩形所需的索引：
+
 ```java
 float vertices[] = {
     0.5f, 0.5f, 0.0f,   // 右上角
@@ -192,21 +203,25 @@ int indices[] = {
     1, 2, 3  // 第二个三角形
 };
 ```
-你可以看到，当使用索引的时候，我们只定义了4个顶点，而不是6个。下一步我们需要创建元素缓冲对象：
+
+你可以看到，当使用索引的时候，我们只定义了4个顶点，而不是6个。下一步我们需要创建元素缓冲对象:     
+
 ```java
 //创建 ebo
 GLES30.glGenBuffers(1,ebo,0)
 //绑定 ebo 到上下文
-GLES30.glBindBuffer(GLES30.GL_ELEMENT_ARRAY_BUFFER,ebo[0])
-//昂丁
+GLES30.glBindBuffer(GLES30.GL_ELEMENT_ARRAY_BUFFER, ebo[0])
+//设置数据
 GLES30.glBufferData(GLES30.GL_ELEMENT_ARRAY_BUFFER,
     indexData.capacity() * 4,
     indexData,
     GLES30.GL_STATIC_DRAW
 )
 ```
-与VBO类似，我们先绑定EBO然后用glBufferData把索引复制到缓冲里。同样，和VBO类似，我们会把这些函数调用放在绑定和解绑函数调用之间，只不过这次我们把缓冲的类型定义为GL_ELEMENT_ARRAY_BUFFER。
+与VBO类似，我们先绑定EBO然后用glBufferData把索引复制到缓冲里。      
+同样，和VBO类似，我们会把这些函数调用放在绑定和解绑函数调用之间，只不过这次我们把缓冲的类型定义为GL_ELEMENT_ARRAY_BUFFER。       
 注意：我们传递了GL_ELEMENT_ARRAY_BUFFER当作缓冲目标。最后一件要做的事是用glDrawElements来替换glDrawArrays函数，表示我们要从索引缓冲区渲染三角形。使用glDrawElements时，我们会使用当前绑定的索引缓冲对象中的索引进行绘制：
+
 ```java
 GLES30.glDrawElements(GLES30.GL_TRIANGLE_STRIP,6,GLES30.GL_UNSIGNED_INT,0)
 ```
@@ -216,7 +231,9 @@ glDrawElements函数从当前绑定到GL_ELEMENT_ARRAY_BUFFER目标的EBO中获
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/vertex_array_objects_ebo.png?raw=true)
 
-当目标是GL_ELEMENT_ARRAY_BUFFER的时候，VAO会储存glBindBuffer的函数调用。这也意味着它也会储存解绑调用，所以确保你没有在解绑VAO之前解绑索引数组缓冲，否则它就没有这个EBO配置了。
+**注意:  EBO的绑定一定要在VAO解绑之前绑定！**
+**当目标是GL_ELEMENT_ARRAY_BUFFER的时候，VAO会储存glBindBuffer的函数调用。这也意味着它也会储存解绑调用，所以确保你没有在解绑VAO之前解绑索引数组缓冲，否则它就没有这个EBO配置了。**
+**OpenGL中会解绑VBO和VAO但是不能解绑EBO)**
 
 
 
diff --git "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md" "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
index b2f3e96d..b7d82bae 100644
--- "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
+++ "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
@@ -2,15 +2,26 @@
 
 着色器是使用一种叫GLSL的类C语言写成的。GLSL是为图形计算量身定制的，它包含一些针对向量和矩阵操作的有用特性。
 
-着色器的开头总是要声明版本，接着是输入和输出变量、uniform和main函数。每个着色器的入口点都是main函数，在这个函数中我们处理所有的输入变量，并将结果输出到输出变量中。
+着色器的开头总是要声明版本，接着是输入和输出变量、uniform和main函数。       
+每个着色器的入口点都是main函数，在这个函数中我们处理所有的输入变量，并将结果输出到输出变量中。
 
-和其他编程语言一样，GLSL有数据类型可以来指定变量的种类。GLSL中包含C等其它语言大部分的默认基础数据类型：int、float、double、uint和bool。GLSL也有两种容器类型，它们会在这个教程中使用很多，分别是向量(Vector)和矩阵(Matrix)。
+和其他编程语言一样，GLSL有数据类型可以来指定变量的种类。      
+GLSL中包含C等其它语言大部分的默认基础数据类型：int、float、double、uint和bool。       
+GLSL也有两种容器类型，它们会在这个教程中使用很多，分别是向量(Vector)和矩阵(Matrix)。
+
+与C语言有区别的地方:    
+- 共享命名空间(Shared Namespace)          
+    Shaders操作是相互独立的，但是为了方便Shaders间通信，在链接成一个shader program时会共享变量的名字。 
+- GLSL没有char、char *和string数据类型，也没有字符串操作
+- 不支持隐式类型转换，例如: int(arg)
+- vec数据方位: vec4(r,g,b,a / x,y,z,w / s,t,p,q)。 vec3.xy = vec2
+- 新的变量类型: Attribute、Uniform、Varying
 
 
 
 ### 顶点着色器:
 
-```
+```glsl
 #version 300 es
 layout (location = 0) in vec3 position; // position变量的属性位置值为0
 
@@ -22,8 +33,10 @@ void main() {
 }
 ```
 
+```glsl
 #version 300 es是表示GLSL语言的版本为300，对应的是OpenGL ES 3.0版本。
 #version必须写在文件的第一行，即是第一行是注释也不行。
+```
 
 <img src="https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_vertex_shader.jpg" style="zoom:80%" />
 
@@ -34,7 +47,9 @@ void main() {
 - 采样器:代表顶点着色器使用纹理的特殊统一变量类型。
 - 着色器程序:描述顶点上执行操作的顶点着色器的程序源代码或可执行文件。
 
-这里需要重点讲一下上面的版本:   OpenGL ES版本有自己的着色器语言，其中OpenGL ES的版本与GLSL的版本有对应的关联关系，如果没有在着色器文件中用#version标明使用版本的时候默认使用的是OpenGL ES 2.0版本（GLSL ES 100）:
+这里需要重点讲一下上面的版本:   
+
+OpenGL ES版本有自己的着色器语言，其中OpenGL ES的版本与GLSL的版本有对应的关联关系，如果没有在着色器文件中用#version标明使用版本的时候默认使用的是OpenGL ES 2.0版本（GLSL ES 100）:
 
 - OpenGL ES 2.0版本对应GLSL ES 100版本
 - OpenGL ES 3.0版本对应GLSL ES 300版本
@@ -55,7 +70,7 @@ void main() {
 
     当使用samplerExternalOES是，如果在\#extension GL_OES_EGL_image_external : require会报错，需要变成#extension GL_OES_EGL_image_external_essl3 : require
 
-- #version 300 es这种声明版本的语句，必须放到第一行，并且shader中不能有Tab键，只能用空格替换。
+- `#version 300 es`这种声明版本的语句，必须放到第一行，并且shader中不能有Tab键，只能用空格替换。
 
 虽然着色器是各自独立的小程序，但是它们都是一个整体的一部分，出于这样的原因，我们希望每个着色器都有输入和输出，这样才能进行数据交流和传递。GLSL定义了in和out关键字专门来实现这个目的。每个着色器使用这两个关键字设定输入和输出，只要一个输出变量与下一个着色器阶段的输入匹配，它就会传递下去。但在顶点和片段着色器中会有点不同。
 
@@ -120,7 +135,12 @@ precision mediump int;
 
 
 #### Uniform
-Uniform是一种从CPU中的应用向GPU中的着色器发送数据的方式，但uniform和顶点属性有些不同。首先，uniform是全局的(Global)。全局意味着uniform变量必须在每个着色器程序对象中都是独一无二的，而且它可以被着色器程序的任意着色器在任意阶段访问。第二，无论你把uniform值设置成什么，uniform会一直保存它们的数据，直到它们被重置或更新。
+Uniform是一种从CPU中的应用向GPU中的着色器发送数据的方式，但uniform和顶点属性有些不同。     
+
+首先，uniform是全局的(Global)。     
+全局意味着uniform变量必须在每个着色器程序对象中都是独一无二的，而且它可以被着色器程序的任意着色器在任意阶段访问。       
+
+第二，无论你把uniform值设置成什么，uniform会一直保存它们的数据，直到它们被重置或更新。
 
 统一变量通常保存在硬件中，这个区域被称作“常量存储”，是硬件中为存储常量值而分配的特殊空间。因为常量存储的大小一般是固定的，所以程序中可以使用的统一变量数量受到限制。这种限制可以通过读取内建变量gl_MaxVertexUniformVectors和gl_MaxFragmentUniformVectors的值来确定。
 但是对于在编译时已知值的变量应该是常量，而不是统一变量，这样可以提高效率。
@@ -143,6 +163,7 @@ void main()
 如果你声明了一个uniform却在GLSL代码中没用过，编译器会静默移除这个变量，导致最后编译出的版本中并不会包含它，这可能导致几个非常麻烦的错误，记住这点！
 
 这个uniform现在还是空的；我们还没有给它添加任何数据，所以下面我们就做这件事。我们首先需要找到着色器中uniform属性的索引/位置值。当我们得到uniform的索引/位置值后，我们就可以更新它的值了。这次我们不去给像素传递单独一个颜色，而是让它随着时间改变颜色：
+
 ```glsl
 float timeValue = glfwGetTime();
 float greenValue = (sin(timeValue) / 2.0f) + 0.5f;

From 71c512348b8e034c0cdcdec4645b6df0e3afa1e4 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 23 Nov 2023 10:40:22 +0800
Subject: [PATCH 149/213] update

---
 ...45\231\250\350\257\255\350\250\200GLSL.md" | 22 +++++++++++++++----
 1 file changed, 18 insertions(+), 4 deletions(-)

diff --git "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md" "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
index b7d82bae..90c75bb4 100644
--- "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
+++ "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
@@ -9,6 +9,13 @@
 GLSL中包含C等其它语言大部分的默认基础数据类型：int、float、double、uint和bool。       
 GLSL也有两种容器类型，它们会在这个教程中使用很多，分别是向量(Vector)和矩阵(Matrix)。
 
+向量(Vector):   
+- vecn : the default vector of n floats
+- bvecn : a vector of n booleans
+- ivecn : a vector of n integers
+- uvecn : a vector of u unsigned integers
+- dvecn : a vector of n double components
+
 与C语言有区别的地方:    
 - 共享命名空间(Shared Namespace)          
     Shaders操作是相互独立的，但是为了方便Shaders间通信，在链接成一个shader program时会共享变量的名字。 
@@ -79,11 +86,15 @@ OpenGL ES版本有自己的着色器语言，其中OpenGL ES的版本与GLSL的
 
 
 #### in、out
-顶点着色器应该接收的是一种特殊形式的输入，否则就会效率低下。顶点着色器的输入特殊在，它从顶点数据中直接接收输入。为了定义顶点数据该如何管理，我们使用location这一元数据指定输入变量，这样我们才可以在CPU上配置顶点属性。我们已经在前面的教程看过这个了，layout (location = 0)。顶点着色器需要为它的输入提供一个额外的layout标识，这样我们才能把它链接到顶点数据。
+顶点着色器应该接收的是一种特殊形式的输入，否则就会效率低下。      
+顶点着色器的输入特殊在，它从顶点数据中直接接收输入。       
+为了定义顶点数据该如何管理，我们使用location这一元数据指定输入变量，这样我们才可以在CPU上配置顶点属性。       
+我们已经在前面的教程看过这个了，layout (location = 0)。顶点着色器需要为它的输入提供一个额外的layout标识，这样我们才能把它链接到顶点数据。
 
 你也可以忽略layout (location = 0)标识符，通过在OpenGL代码中使用glGetAttribLocation查询属性位置值(Location)，但是我更喜欢在着色器中设置它们，这样会更容易理解而且节省你（和OpenGL）的工作量。
 
-如果我们打算从一个着色器向另一个着色器发送数据，我们必须在发送方着色器中声明一个输出，在接收方着色器中声明一个类似的输入。当类型和名字都一样的时候，OpenGL就会把两个变量链接到一起，它们之间就能发送数据了（这是在链接程序对象时完成的）。
+如果我们打算从一个着色器向另一个着色器发送数据，我们必须在发送方着色器中声明一个输出，在接收方着色器中声明一个类似的输入。       
+**当类型和名字都一样的时候，OpenGL就会把两个变量链接到一起，它们之间就能发送数据了（这是在链接程序对象时完成的）。**
 
 顶点着色器
 ```glsl
@@ -142,7 +153,10 @@ Uniform是一种从CPU中的应用向GPU中的着色器发送数据的方式，
 
 第二，无论你把uniform值设置成什么，uniform会一直保存它们的数据，直到它们被重置或更新。
 
-统一变量通常保存在硬件中，这个区域被称作“常量存储”，是硬件中为存储常量值而分配的特殊空间。因为常量存储的大小一般是固定的，所以程序中可以使用的统一变量数量受到限制。这种限制可以通过读取内建变量gl_MaxVertexUniformVectors和gl_MaxFragmentUniformVectors的值来确定。
+统一变量通常保存在硬件中，这个区域被称作“常量存储”，是硬件中为存储常量值而分配的特殊空间。    
+
+因为常量存储的大小一般是固定的，所以程序中可以使用的统一变量数量受到限制。      
+这种限制可以通过读取内建变量gl_MaxVertexUniformVectors和gl_MaxFragmentUniformVectors的值来确定。
 但是对于在编译时已知值的变量应该是常量，而不是统一变量，这样可以提高效率。
 
 
@@ -160,7 +174,7 @@ void main()
 ```
 我们在片段着色器中声明了一个uniform vec4的ourColor，并把片段着色器的输出颜色设置为uniform值的内容。因为uniform是全局变量，我们可以在任何着色器中定义它们，而无需通过顶点着色器作为中介。顶点着色器中不需要这个uniform，所以我们不用在那里定义它。
 
-如果你声明了一个uniform却在GLSL代码中没用过，编译器会静默移除这个变量，导致最后编译出的版本中并不会包含它，这可能导致几个非常麻烦的错误，记住这点！
+**如果你声明了一个uniform却在GLSL代码中没用过，编译器会静默移除这个变量，导致最后编译出的版本中并不会包含它，这可能导致几个非常麻烦的错误，记住这点！**
 
 这个uniform现在还是空的；我们还没有给它添加任何数据，所以下面我们就做这件事。我们首先需要找到着色器中uniform属性的索引/位置值。当我们得到uniform的索引/位置值后，我们就可以更新它的值了。这次我们不去给像素传递单独一个颜色，而是让它随着时间改变颜色：
 

From 0f502b6070e6fb6158ae886fa83b8a0868e74a93 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 23 Nov 2023 21:29:27 +0800
Subject: [PATCH 150/213] update opengl part

---
 .../1.OpenGL\347\256\200\344\273\213.md"      |  39 +++++++
 .../11.OpenGL ES\346\273\244\351\225\234.md"  |   3 +-
 VideoDevelopment/OpenGL/12.FBO.md             |  14 +--
 ...66\344\270\211\350\247\222\345\275\242.md" | 104 ++++++++++-------
 ...42\345\217\212\345\234\206\345\275\242.md" |  29 +++--
 ...45\231\250\350\257\255\350\250\200GLSL.md" | 110 +++++++++++-------
 ...\261\273\345\217\212Matrix\347\261\273.md" |  21 ++--
 .../9.OpenGL ES\347\272\271\347\220\206.md"   |  65 ++++++-----
 8 files changed, 249 insertions(+), 136 deletions(-)

diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
index 26a08a44..7578a7eb 100644
--- "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -168,6 +168,45 @@ OpenGL ES 3.0实现了具有可编程着色功能的图形管线，有两个规
 而顶点数据是用顶点属性(Vertex Attribute)表示的，它可以包含任何我们想用的数据，但是简单起见，我们还是假定每个顶点只由一个3D位置和一些颜色值组成的吧。
 
 
+### 立即渲染模式(Immediate mode) && 核心模式(Core-profile)
+早期的OpenGL使用立即渲染模式（Immediate mode，也就是固定渲染管线），这个模式下绘制图形很方便。OpenGL的大多数功能都被库隐藏起来，开发者很少有控制OpenGL如何进行计算的自由。而开发者迫切希望能有更多的灵活性。随着时间推移，规范越来越灵活，开发者对绘图细节有了更多的掌控。立即渲染模式确实容易使用和理解，但是效率太低。因此从OpenGL3.2开始，规范文档开始废弃立即渲染模式，并鼓励开发者在OpenGL的核心模式(Core-profile)下进行开发，这个分支的规范完全移除了旧的特性。
+
+当使用OpenGL的核心模式时，OpenGL迫使我们使用现代的函数。当我们试图使用一个已废弃的函数时，OpenGL会抛出一个错误并终止绘图。现代函数的优势是更高的灵活性和效率，然而也更难于学习。立即渲染模式从OpenGL实际运作中抽象掉了很多细节，因此它在易于学习的同时，也很难让人去把握OpenGL具体是如何运作的。现代函数要求使用者真正理解OpenGL和图形编程，它有一些难度，然而提供了更多的灵活性，更高的效率，更重要的是可以更深入的理解图形编程。
+
+这也是为什么我们的教程面向OpenGL3.3的核心模式。虽然上手更困难，但这份努力是值得的。
+
+现今，更高版本的OpenGL已经发布（写作时最新版本为4.5），你可能会问：既然OpenGL 4.5 都出来了，为什么我们还要学习OpenGL 3.3？答案很简单，所有OpenGL的更高的版本都是在3.3的基础上，引入了额外的功能，并没有改动核心架构。新版本只是引入了一些更有效率或更有用的方式去完成同样的功能。因此，所有的概念和技术在现代OpenGL版本里都保持一致。当你的经验足够，你可以轻松使用来自更高版本OpenGL的新特性。
+
+
+
+### 依赖库
+
+简要来说，GLAD、GLEW都是一个图形库，可以理解为是在显卡驱动上给渲染用户一个统一的API；   
+而GLUT、FreeGLUT、GLFW这三个是用于图形开发的辅助工具库，主要用于创建和管理OpenGL环境、操作窗口等。
+
+OpenGL只是一个标准/规范，具体的实现是由驱动开发商针对特定显卡实现的。但是在你真正能够在程序中使用OpenGL之前，你需要对他进行初始化，但是由于OpenGL是跨平台的，所以也没有一个标准的方式进行初始化。OpenGL初始化分为两个阶段：
+
+- 第一个阶段，你需要创建一个OpenGL上下文环境，这个上下文环境存储了所有与OpenGL相关的状态（OpenGL是一个状态机），上下文位于操作系统中某个进程中，一个进程可以创建多个上下文，每一个上下文都可以描绘一个不同的可视界面，就像应用程序中的窗口；简单来理解就是为了创建一个窗口；而GLUT、FreeGLUT、GLFW库就是用于干这件事的。
+
+- 第二个阶段，你需要定位所有需要在OpenGL中使用的函数(由于OpenGL驱动版本众多，它大多数函数的位置都无法在编译时确定下来，需要在运行时查询。任务就落在了开发者身上，开发者需要在运行时获取函数地址并将其保存在一个函数指针中供以后使用)，而GLEW、GLAD就是干这件事的。
+
+
+
+### GLFW
+
+GLFW是一个专门针对OpenGL的C语言库，它提供了一些渲染物体所需的最低限度的接口。它允许用户创建OpenGL上下文，定义窗口参数以及处理用户输入。       
+简单来说，GLFW负责创建窗口，处理窗口相关的事件（如键盘和鼠标输入），并提供一个OpenGL上下文供你的程序使用。
+这些库节省了我们书写操作系统相关代码的时间，提供给我们一个窗口和一个OpenGL上下文用来渲染。       
+
+
+
+### GLAD
+
+然后，我们有GLAD。由于OpenGL驱动版本众多，它大多数函数的位置都无法在编译时确定下来，需要在运行时查询。所以任务就落在了开发者身上，开发者需要在运行时获取函数地址并将其保存在一个函数指针中供以后使用。取得地址的方法因平台而异,代码非常复杂，而且很繁琐，我们需要对每个可能使用的函数都要重复这个过程。幸运的是，有些库能简化此过程，其中GLAD是目前最新，也是最流行的库。GLAD是用来管理OpenGL的函数指针的，所以在调用任何OpenGL的函数之前我们需要初始化GLAD。GLAD也可以使OpenGL基础渲染变得简单。
+
+
+到了这些感觉不想学了，又是GLFW、又是GLAD，每个都要看，每个都要学，太麻烦了。好在Android上已经帮我们处理好了，我们只要使用GLSurfaceView即可。   
+
 ### 着色器
 
 着色器(shader)是在GPU上运行的小程序。     
diff --git "a/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md" "b/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"
index 675f4d24..e76e826e 100644
--- "a/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"	
+++ "b/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"	
@@ -354,7 +354,8 @@ public class BaseFilter {
 }
 ```
 
-在Render中改变的地方就是onDrawFrame()方法中去调用Filter.onDraw()方法:  
+在Render中改变的地方就是onDrawFrame()方法中去调用Filter.onDraw()方法:      
+
 ```java
     @Override
     public void onDrawFrame(GL10 gl) {
diff --git a/VideoDevelopment/OpenGL/12.FBO.md b/VideoDevelopment/OpenGL/12.FBO.md
index 728b6430..4a9632fb 100644
--- a/VideoDevelopment/OpenGL/12.FBO.md
+++ b/VideoDevelopment/OpenGL/12.FBO.md
@@ -2,22 +2,22 @@
 
 FBO（Frame Buffer Object）即帧缓冲区对象，实际上是一个可添加缓冲区的容器，可以为其添加纹理或渲染缓冲区对象（RBO）。
 
-FBO 本身不能用于渲染，只有添加了纹理或者渲染缓冲区之后才能作为渲染目标，它仅且提供了 3 种附着（Attachment），分别是颜色附着、深度附着和模板附着。
+FBO本身不能用于渲染，只有添加了纹理或者渲染缓冲区之后才能作为渲染目标，它仅且提供了3种附着（Attachment），分别是颜色附着、深度附着和模板附着。
 
-RBO（Render Buffer Object）即渲染缓冲区对象，是一个由应用程序分配的 2D 图像缓冲区。渲染缓冲区可以用于分配和存储颜色、深度或者模板值，可以用作 FBO 中的颜色、深度或者模板附着。
+RBO（Render Buffer Object）即渲染缓冲区对象，是一个由应用程序分配的2D图像缓冲区。渲染缓冲区可以用于分配和存储颜色、深度或者模板值，可以用作FBO中的颜色、深度或者模板附着。
 
-使用 FBO 作为渲染目标时，首先需要为 FBO 的附着添加连接对象，如颜色附着需要连接纹理或者渲染缓冲区对象的颜色缓冲区。
+使用FBO作为渲染目标时，首先需要为FBO的附着添加连接对象，如颜色附着需要连接纹理或者渲染缓冲区对象的颜色缓冲区。
 
 
 #### 为什么用 FBO
 
-默认情况下，OpenGL ES 通过绘制到窗口系统提供的帧缓冲区，然后将帧缓冲区的对应区域复制到纹理来实现渲染到纹理，但是此方法只有在纹理尺寸小于或等于帧缓冲区尺寸才有效。
+默认情况下，OpenGL ES通过绘制到窗口系统提供的帧缓冲区，然后将帧缓冲区的对应区域复制到纹理来实现渲染到纹理，但是此方法只有在纹理尺寸小于或等于帧缓冲区尺寸才有效。       
 
-另一种方式是通过使用连接到纹理的 pbuffer 来实现渲染到纹理，但是与上下文和窗口系统提供的可绘制表面切换开销也很大。因此，引入了帧缓冲区对象 FBO 来解决这个问题。
+另一种方式是通过使用连接到纹理的pbuffer来实现渲染到纹理，但是与上下文和窗口系统提供的可绘制表面切换开销也很大。因此，引入了帧缓冲区对象FBO来解决这个问题。
 
-Android OpenGL ES 开发中，一般使用 GLSurfaceView 将绘制结果显示到屏幕上，然而在实际应用中，也有许多场景不需要渲染到屏幕上，如利用 GPU 在后台完成一些图像转换、缩放等耗时操作，这个时候利用 FBO 可以方便实现类似需求。
+Android OpenGL ES开发中，一般使用GLSurfaceView将绘制结果显示到屏幕上，然而在实际应用中，也有许多场景不需要渲染到屏幕上，如利用GPU在后台完成一些图像转换、缩放等耗时操作，这个时候利用FBO可以方便实现类似需求。
 
-使用 FBO 可以让渲染操作不用再渲染到屏幕上，而是渲染到离屏 Buffer 中，然后可以使用 glReadPixels 或者 HardwareBuffer 将渲染后的图像数据读出来，从而实现在后台利用 GPU 完成对图像的处理。
+使用FBO可以让渲染操作不用再渲染到屏幕上，而是渲染到离屏Buffer中，然后可以使用glReadPixels或者HardwareBuffer将渲染后的图像数据读出来，从而实现在后台利用GPU完成对图像的处理。
 
 
 
diff --git "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md" "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"
index 4b9285ba..18119b7d 100644
--- "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
@@ -2,7 +2,7 @@
 
 OpenGL ES的绘制需要有以下步骤:   
 
-- 顶点输入
+### 1. 顶点输入
 
   开始绘制图形之前，我们必须先给OpenGL输入一些顶点数据。    
   OpenGL是一个3D图形库，所以我们在OpenGL中所指定的所有坐标都是3D坐标(xyz)。OpenGL并不是简单地把所有的3D坐标变换成屏幕上的2D像素。    
@@ -11,7 +11,7 @@ OpenGL ES的绘制需要有以下步骤:
 
 由于我们希望渲染一个三角形，我们一共要指定三个顶点，每个顶点都有一个3D位置。我们会将它们以标准化设备坐标的形式（OpenGL的可见区域）定义为一个float数组。
 
-```glsl
+```java
 float vertices[] = {
     -0.5f, -0.5f, 0.0f,
      0.5f, -0.5f, 0.0f,
@@ -19,7 +19,9 @@ float vertices[] = {
 };
 ```
 定义这样的顶点数据以后，我们会把它作为输入发送给图形渲染管线的第一个处理阶段：顶点着色器。    
-它会在GPU上创建内存用于储存我们的顶点数据，还要配置OpenGL如何解释这些内存，并且指定其如何发送给显卡。顶点着色器接着会处理我们在内存中指定数量的顶点。
+**这里会在GPU上创建内存用于储存我们的顶点数据，还要配置OpenGL如何解释这些内存，并且指定其如何发送给显卡。**      
+
+顶点着色器接着会处理我们在内存中指定数量的顶点。
 
 我们通过顶点缓冲对象(Vertex Buffer Objects, VBO)管理这个内存，它会在GPU内存（通常被称为显存）中储存大量顶点。    
 使用这些缓冲对象的好处是我们可以一次性的发送一大批数据到显卡上，而不是每个顶点发送一次。   
@@ -28,9 +30,9 @@ float vertices[] = {
 顶点缓冲对象是我们在OpenGL教程中第一个出现的OpenGL对象。就像OpenGL中的其它对象一样，这个缓冲有一个独一无二的ID，所以我们可以使用glGenBuffers函数和一个缓冲ID生成一个VBO对象。
 
 
-- 顶点着色器
+### 2.顶点着色器
 
-  着色器都是使用GLSL语言来写的而GLSL版本之间有差异。
+  着色器都是使用GLSL语言来写的，而GLSL不同版本之间会有差异。
 
   ```glsl
   #version 300 es
@@ -44,27 +46,33 @@ float vertices[] = {
 
   每个着色器都起始于一个版本声明，这里声明的是GLSL ES 300版本，在Android中它对应的OpenGL ES版本为3.0，而GLSL ES 100版本则对应的是OpenGL ES 2.0版本。如果不写版本默认的就是100。
 
-  下一步，使用in关键字，在顶点着色器中声明所有的输入顶点属性(Input Vertex Attribute)。现在我们只关心位置(Position)数据，所以我们只需要一个顶点属性。GLSL有一个向量数据类型，它包含1到4个float分量，包含的数量可以从它的后缀数字看出来。    
-  由于每个顶点都有一个3D坐标，我们就创建一个vec3输入变量position。我们同样也通过layout (location = 0)设定了输入变量的位置值(Location)你后面会看到为什么我们会需要这个位置值。
+  下一步，使用in关键字，在顶点着色器中声明所有的输入顶点属性(Input Vertex Attribute)。现在我们只关心位置(Position)数据，所以我们只需要一个顶点属性。        
+    GLSL有一个向量数据类型，它包含1到4个float分量，包含的数量可以从它的后缀数字看出来。    
+  由于每个顶点都有一个3D坐标，我们就创建一个vec3输入变量position。      
+    我们同样也通过layout (location = 0)设定了输入变量的位置值(Location)。        
+    `layout(location = 0);`用于指定着色器中的变量 position 与 OpenGL程序中顶点数组中数据的关联关系，这里表示该位置数据的位置索引为0。以确保在着色器中能正常的接收输入的数据。 
+    你后面会看到为什么我们会需要这个位置值。
+    
 
-向量(Vector)
-
-在图形编程中我们经常会使用向量这个数学概念，因为它简明地表达了任意空间中的位置和方向，并且它有非常有用的数学属性。    
-在GLSL中一个向量有最多4个分量，每个分量值都代表空间中的一个坐标，它们可以通过vec.x、vec.y、vec.z和vec.w来获取。    
-注意vec.w分量不是用作表达空间中的位置的（我们处理的是3D不是4D），而是用在所谓透视除法(Perspective Division)上。我们会在后面的教程中更详细地讨论向量。
+##### 向量(Vector)
 
+在图形编程中我们经常会使用向量这个数学概念，因为它简明地表达了任意空间中的位置和方向，并且它有非常有用的数学属性。      
+在GLSL中一个向量有最多4个分量，每个分量值都代表空间中的一个坐标，它们可以通过vec.x、vec.y、vec.z和vec.w来获取。          
+注意vec.w分量不是用作表达空间中的位置的（我们处理的是3D不是4D），而是用在所谓透视除法(Perspective Division)上。       
 为了设置顶点着色器的输出，我们必须把位置数据赋值给预定义的gl_Position变量，它在幕后是vec4类型的。在main函数中只是将position的值转换后赋值给gl_Position。    
 由于我们的输入是一个3分量的向量，我们必须把它转换为4分量的。我们可以把vec3的数据作为vec4构造器的参数，同时把w分量设置为1.0f（我们会在后面解释为什么）来完成这一任务。
 
-这个position的值是哪里进行赋值的呢？ 是通过后面java代码中的draw函数来进行赋值的。每个顶点着色器都必须在gl_Position变量中输出一个位置。这个变量定义传递给管线下一个阶段的位置。
+这个position的值是哪里进行赋值的呢？       
+是通过后面java代码中的draw函数来进行赋值的。         
+每个顶点着色器都必须在gl_Position变量中输出一个位置。这个变量定义传递给管线下一个阶段的位置。
 
-- 编译着色器
+### 3.编译着色器
 
   写完顶点着色器后，为了能让OpenGL使用它，我们必须在运行时动态编译它。
 
-- 片段着色器
+### 4.片段着色器
 
-  片断着色器全是关于计算你的像素最后的颜色输出。颜色使用RGBA。
+  片段着色器全是关于计算你的像素最后的颜色输出。颜色使用RGBA。
 
   ```glsl
   #version 300 es
@@ -73,21 +81,24 @@ float vertices[] = {
       color = vec4(1.0f, 0.5f, 0.2f, 1.0f);
   }
   ```
-在计算机图形中颜色被表示为有4个元素的数组：红色、绿色、蓝色和alpha(透明度)分量，通常缩写为RGBA。    
+  
+在计算机图形中颜色被表示为有4个元素的数组：红色、绿色、蓝色和alpha(透明度)分量，通常缩写为RGBA。     
 当在OpenGL或GLSL中定义一个颜色的时候，我们把颜色每个分量的强度设置在0.0到1.0之间。比如说我们设置红为1.0f，绿为1.0f，我们会得到两个颜色的混合色，即黄色。    
 这三种颜色分量的不同调配可以生成超过1600万种不同的颜色！
  
 片段着色器只需要一个输出变量，这个变量是一个4分量向量，它表示的是最终的输出颜色，我们应该自己将其计算出来。    
-我们可以用out关键字声明输出变量，这里我们命名为color。下面，我们将一个alpha值为1.0(1.0代表完全不透明)的橘黄色的vec4赋值给颜色输出。    
+我们可以用out关键字声明输出变量，这里我们命名为color。        
+下面，我们将一个alpha值为1.0(1.0代表完全不透明)的橘黄色的vec4赋值给颜色输出。     
 之后也是需要编译着色器。片段着色器声明的这个输出变量color的值会被输出到颜色缓冲区，然后颜色缓冲区再通过EGL窗口显示。
 
-- 着色器程序(Shader Program Object)
+### 5.着色器程序(Shader Program Object)
 
 着色器程序对象(Shader Program Object)是多个着色器合并之后并最终链接完成的版本。    
 如果要使用刚才编译的着色器我们必须把它们链接(Link)为一个着色器程序对象，然后在渲染对象的时候激活这个着色器程序。    
 已激活着色器程序的着色器将在我们发送渲染调用的时候被使用。    
 
-当链接着色器至一个程序的时候，它会把每个着色器的输出链接到下个着色器的输入。当输出和输入不匹配的时候，你会得到一个连接错误。我们需要把之前编译的着色器附加到程序队形上，然后使用glLinkProgram链接他们:
+当链接着色器至一个程序的时候，它会把每个着色器的输出链接到下个着色器的输入。            
+当输出和输入不匹配的时候，你会得到一个连接错误。我们需要把之前编译的着色器附加到程序队形上，然后使用glLinkProgram链接他们:
 
 ```java
 final int shaderProgramId = GLES30.glCreateProgram(); 
@@ -96,7 +107,8 @@ GLES30.glAttachShader(shaderProgramId, fragmentShaderId);
 GLES30.glLinkProgram(shaderProgramId);
 ```
 
-链接完后需要使用glUseProgram方法，用刚创建的程序对象的Id作为参数，以激活这个程序对象。调用glUserProgram方法后，所有后续的渲染将用连接到这个程序对象的顶点和片段着色器进行。
+链接完后需要使用glUseProgram方法，用刚创建的程序对象的id作为参数，以激活这个程序对象。         
+调用glUserProgram方法后，所有后续的渲染将用连接到这个程序对象的顶点和片段着色器进行。           
 
 对了，在把着色器对象链接到程序对象以后，记得删除着色器对象，我们不再需要它们了：
 
@@ -108,14 +120,15 @@ GLES30.glDeleteShader(fragmentShaderId);
 现在，我们已经把输入顶点数据发送给了GPU，并指示了GPU如何在顶点和片段着色器中处理它。    
 就快要完成了，但还没结束，OpenGL还不知道它该如何解释内存中的顶点数据，以及它该如何将顶点数据链接到顶点着色器的属性上。下面我们需要告诉OpenGL怎么做。
 
-- 链接顶点属性
+### 6.链接顶点属性
 
-  顶点着色器允许我们指定任何以顶点属性为形式的输入。这使其具有很强的灵活性的同时，它还意味着我们必须手动指定输入数据的哪一个部分对应顶点着色器的哪一个顶点属性。    
+  顶点着色器允许我们指定任何以顶点属性为形式的输入。这使其具有很强的灵活性的同时，它还意味着我们必须手动指定输入数据的哪一个部分对应顶点着色器的哪一个顶点属性。       
   所以，我们必须在渲染前指定OpenGL该如何解释顶点数据。
 
   我们的顶点缓冲数据会被解析成下面的样子:  
 
   ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/vertex_attribute_pointer.png)
+  
 - 位置数据被储存为32位（4字节）浮点值。
 - 每个位置包含3个这样的值。
 - 在这3个值之间没有空隙（或其他值）。这几个值在数组中紧密排列(Tightly Packed)。
@@ -123,15 +136,15 @@ GLES30.glDeleteShader(fragmentShaderId);
 
 有了这些信息我们就可以使用glVertexAttribPointer函数告诉OpenGL该如何解析顶点数据（应用到逐个顶点属性上）了：
 
-  ```java
+```java
 // glVertexAttribPointer是把顶点位置属性赋值给着色器程序
 // 第一个参数0是上面着色器中写的vPosition的变量位置(location = 0)。意思就是绑定vertex坐标数据，然后将在vertextBuffer中的顶点数据传给vPosition变量。
 // 你肯定会想，如果我在着色器中不写呢？int vposition = glGetAttribLocation(program, "vPosition");就可以获得他的属性位置了
 // 第二个size是3，是因为上面我们triangleCoords声明的属性就是3位，xyz
 GLES30.glVertexAttribPointer(0, 3, GLES30.GL_FLOAT, false, 3 * 4, vertexBuffer);
-//启用顶点变量，参数为数据中第一个值在缓冲开始的位置。 这个0也是vPosition在着色器变量中的位置，和上面一样，在着色器文件中的location=0声明的
+//启用顶点变量，参数为数据中第一个值在缓冲区开始的位置。 这个0也是vPosition在着色器变量中的位置，和上面一样，在着色器文件中的location=0声明的
 GLES30.glEnableVertexAttribArray(0);
-  ```
+```
 
   glVertexAttribPointer函数的参数非常多，所以我会逐一介绍它们：
 
@@ -144,12 +157,13 @@ GLES30.glEnableVertexAttribArray(0);
       一旦我们有更多的顶点属性，我们就必须更小心地定义每个顶点属性之间的间隔，我们在后面会看到更多的例子(译注: 这个参数的意思简单说就是从这个属性第二次出现的地方到整个数组0位置之间有多少字节)。
   - 最后一个参数的类型是数据。
 
-每个顶点属性从一个VBO管理的内存中获得它的数据，而具体是从哪个VBO（程序中可以有多个VBO）获取则是通过在调用glVertexAttribPointer时绑定到GL_ARRAY_BUFFER的VBO决定的。    
+每个顶点属性从一个VBO管理的内存中获得它的数据，而具体是从哪个VBO（程序中可以有多个VBO）获取则是通过在调用glVertexAttribPointer时绑定到GL_ARRAY_BUFFER的VBO决定的。       
 由于在调用glVertexAttribPointer之前绑定的是先前定义的VBO对象，顶点属性现在会链接到它的顶点数据。
 
-现在我们已经定义了OpenGL该如何解释顶点数据，接着应该使用glEnableVertexAttribArray，以顶点属性位置值作为参数，启用顶点属性；顶点属性默认是禁用的。    
+现在我们已经定义了OpenGL该如何解释顶点数据，接着应该使用glEnableVertexAttribArray，以顶点属性位置值作为参数，启用顶点属性；      
+**顶点属性默认是禁用的。**    
 
-自此，所有东西都已经设置好了：我们使用一个顶点缓冲对象将顶点数据初始化至缓冲中，建立了一个顶点和一个片段着色器，并告诉了OpenGL如何把顶点数据链接到顶点着色器的顶点属性上。    
+自此，所有东西都已经设置好了：我们使用一个顶点缓冲对象将顶点数据初始化至缓冲区中，建立了一个顶点和一个片段着色器，并告诉了OpenGL如何把顶点数据链接到顶点着色器的顶点属性上。    
 在OpenGL中绘制一个物体，代码会像是这样：
 
 ```java
@@ -197,6 +211,7 @@ GLES30.glGenVertexArrays(1, arrays);
 当我们打算绘制一个物体的时候，我们只要在绘制物体前简单地把VAO绑定到希望使用的设定上就行了。这段代码应该看起来像这样：
 
 VAO小助理偷偷帮我们记录一切：   
+
 ```java
 // ..:: 初始化代码（只运行一次 (除非你的物体频繁改变)） :: ..
 // 1. 绑定VAO
@@ -275,7 +290,9 @@ void main() {
 } 
 ```
 
-  大体意思：使用OpenGL ES3.0版本，将图形顶点数据采用4分向量的数据结构绑定到着色器的第0个属性上，属性的名字是vPosition，然后再有一个颜色的4分向量绑定到做色器的第1个属性上，属性的名字是aColor，另外还会输出一个vColor，着色器执行的时候，会将vPosition的值传递给用来表示顶点最终位置的内建变量gl_Position，将顶点最终大小的gl_PointSize设置为10，并将aColor的值复制给要输出给vColor。
+  大体意思：使用OpenGL ES3.0版本，将图形顶点数据采用4分向量的数据结构绑定到着色器的第0个属性上，属性的名字是vPosition。       
+  然后再有一个颜色的4分向量绑定到做色器的第1个属性上，属性的名字是aColor。        
+  另外还会输出一个vColor，着色器执行的时候，会将vPosition的值传递给用来表示顶点最终位置的内建变量gl_Position，将顶点最终大小的gl_PointSize设置为10，并将aColor的值复制给要输出给vColor。
 
 - 片段着色器(triangle_fragment_shader.glsl)
 
@@ -293,8 +310,10 @@ void main() {
       fragColor = vColor;
   }
   ```
-precision是精度限定符，它可以使着色器创作者指定着色器变量的计算精度。变量可以声明为低、中或高精度。这些限定符用于提示编译器允许在较低的范围和精度上执行变量的计算。    
-在较低的精度上，有些OpenGL ES实现在运行着色器时可能更快，或者电源效率更高。当然这种效率提升是以精度为代价的，在没有正确使用精度限定符时可能造成伪像。
+precision是精度限定符，它可以使着色器创作者指定着色器变量的计算精度。变量可以声明为低、中或高精度。        
+这些限定符用于提示编译器允许在较低的范围和精度上执行变量的计算。    
+在较低的精度上，有些OpenGL ES实现在运行着色器时可能更快，或者电源效率更高。             
+当然这种效率提升是以精度为代价的，在没有正确使用精度限定符时可能造成伪像。
 
 精度限定符可以用于指定任何浮点数或整数的变量的精度。指定精度的关键字是lowp、mediump和highp。下面是一些带有精度限定符的声明示例: 
 
@@ -308,8 +327,9 @@ mediump float specularExp;
 precision highp float;
 precision mediump int;
 ```
-为float类型指定的精度将用作所有基于浮点值变量的默认精度。同样，为int指定的精度将用作所有基于整数的变量的默认精度。
-在顶点着色器中，如果没有指定默认精度，则int和float的默认精度都是highp。也就是说，顶点着色器中所有没有精度限定符声明的变量都使用最高的精度。
+为float类型指定的精度将用作所有基于浮点值变量的默认精度。同样，为int指定的精度将用作所有基于整数的变量的默认精度。         
+在顶点着色器中，如果没有指定默认精度，则int和float的默认精度都是highp。         
+也就是说，顶点着色器中所有没有精度限定符声明的变量都使用最高的精度。           
 片段着色器的规则与此不同。在片段着色器中，浮点值没有默认的精度值:每个着色器必须声明一个默认的float精度，或者为每个float变量指定精度。
 
 
@@ -611,15 +631,18 @@ public class TriangleRender implements GLSurfaceView.Renderer {
 
 ### 向量（Vector)
 
-具有大小和方向的量。它可以形象化的表示为带箭头的线段。箭头代表方向、长度代表大小。在GLSL中一个向量有最多4个分量，每个分量值都代表空间中的一个坐标，它们可以通过vec.x、vec.y、vec.z和vec.w来获取。vec.w分量不是用作表达空间中的位置(因为我们处理的是3D不是4D)，而是用在所谓透视划分上。
+具有大小和方向的量。它可以形象化的表示为带箭头的线段。箭头代表方向、长度代表大小。            
+在GLSL中一个向量有最多4个分量，每个分量值都代表空间中的一个坐标，它们可以通过vec.x、vec.y、vec.z和vec.w来获取。         
+vec.w分量不是用作表达空间中的位置(因为我们处理的是3D不是4D)，而是用在所谓透视划分上。
 
 ### 矩阵
 
-由m*n个数按照一定顺序排列成m行n列的矩形数表称为矩阵，而向量则是由n个有序数组成的数组。
+由m*n个数按照一定顺序排列成m行n列的矩形数表称为矩阵，而向量则是由n个有序数组成的数组。       
 
-所以矩阵中的每一个行可以看做一个行向量，每一列也可以看成一个列向量，所以说向量是矩阵的一部分。
+所以矩阵中的每一个行可以看做一个行向量，每一列也可以看成一个列向量，所以说向量是矩阵的一部分。         
 
-在三维图形学中，一般使用的是4阶矩阵。在DirectX中使用的是行向量，如[xyzw]，所以与矩阵相乘时，向量在前矩阵在后。OpenGL中使用的是列向量，如[xyzx]T，所以与矩阵相乘时，矩阵在前，向量在后，最终通过变换矩阵得到想要的向量。
+在三维图形学中，一般使用的是4阶矩阵。在DirectX中使用的是行向量，如[xyzw]，所以与矩阵相乘时，向量在前矩阵在后。         
+OpenGL中使用的是列向量，如[xyzx]T，所以与矩阵相乘时，矩阵在前，向量在后，最终通过变换矩阵得到想要的向量。
 
 
 
@@ -732,7 +755,8 @@ Android OpenGL ES的投影分为两种:
 
 ### 变换矩阵
 
-在OpenGL ES中顶点位置信息的表示都是使用的向量，如下每一行是一个顶点的位置向量(x,y,z)。想要使三角形显示为等腰三角形，就需要在虚拟坐标系中完成对各个顶点位置的变换，也就是对三个向量的变换。而想要实现对向量的变换就要用到变换矩阵。
+在OpenGL ES中顶点位置信息的表示都是使用的向量，如下每一行是一个顶点的位置向量(x,y,z)。          
+想要使三角形显示为等腰三角形，就需要在虚拟坐标系中完成对各个顶点位置的变换，也就是对三个向量的变换。而想要实现对向量的变换就要用到变换矩阵。
 
 ```java
 //三个顶点的位置参数
@@ -756,7 +780,7 @@ Matrix.multiplyMM (float[] result, //接收相乘结果
 
 
 
-也就是说为了解决坐标中宽高不一样的问题，我们可以应用OpenGL正确的比例下通过投影模式和相机视图坐标转换图形对象来完成。    
+也就是说为了解决坐标中宽高不一样的问题，我们可以应用OpenGL正确的比例下通过投影模式和相机视图坐标转换图形对象来完成。       
 为了应用投影和相机视图，我们创建一个投影矩阵和一个相机视图矩阵，并把他们应用于OpenGL渲染管道中，投影矩阵重新计算你的图形的坐标，使他们正确的映射到Android设备的屏幕，相机视图矩阵创建一个转换，它将从一个特定的位置显示对象。
 
 ### 绘制等腰三角形
diff --git "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md" "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"
index c73d718e..f9319879 100644
--- "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"	
@@ -152,7 +152,8 @@ public abstract class BaseGLSurfaceViewRenderer implements GLSurfaceView.Rendere
 
 - 索引法
 
-  根据索引序列，在顶点序列中找到对应的顶点，并根据绘制的方式，组成相应的图元绘制，用的是GLES30.glDrawElements()，称为索引法。相对于顶点法在复杂图形的绘制中无法避免大量顶点重复的情况，索引法可以减少很多重复顶点占用的空间，所以复杂的图形下推荐使用索引法。顶点复用情况多，可读性高。
+  根据索引序列，在顶点序列中找到对应的顶点，并根据绘制的方式，组成相应的图元绘制，用的是GLES30.glDrawElements()，称为索引法。       
+ 相对于顶点法在复杂图形的绘制中无法避免大量顶点重复的情况，索引法可以减少很多重复顶点占用的空间，所以复杂的图形下推荐使用索引法。顶点复用情况多，可读性高。
 
 之前说过OpenGL ES提供的的图元单位是三角形，想要绘制其他多边形，就要利用三角形来拼成。 矩形是两个三角形，而圆形则是由很多个三角形组成，个数越多，圆越圆。
 
@@ -208,7 +209,7 @@ int indices[] = {
 
 ```java
 //创建 ebo
-GLES30.glGenBuffers(1,ebo,0)
+GLES30.glGenBuffers(1,ebo[0])
 //绑定 ebo 到上下文
 GLES30.glBindBuffer(GLES30.GL_ELEMENT_ARRAY_BUFFER, ebo[0])
 //设置数据
@@ -219,22 +220,32 @@ GLES30.glBufferData(GLES30.GL_ELEMENT_ARRAY_BUFFER,
 )
 ```
 与VBO类似，我们先绑定EBO然后用glBufferData把索引复制到缓冲里。      
-同样，和VBO类似，我们会把这些函数调用放在绑定和解绑函数调用之间，只不过这次我们把缓冲的类型定义为GL_ELEMENT_ARRAY_BUFFER。       
-注意：我们传递了GL_ELEMENT_ARRAY_BUFFER当作缓冲目标。最后一件要做的事是用glDrawElements来替换glDrawArrays函数，表示我们要从索引缓冲区渲染三角形。使用glDrawElements时，我们会使用当前绑定的索引缓冲对象中的索引进行绘制：
+同样，和VBO类似，我们会把这些函数调用放在绑定和解绑函数调用之间，只不过这次我们把缓冲的类型定义为GL_ELEMENT_ARRAY_BUFFER。          
+注意：我们传递了GL_ELEMENT_ARRAY_BUFFER当作缓冲目标。最后一件要做的事是用glDrawElements来替换glDrawArrays函数，表示我们要从索引缓冲区渲染三角形。         
+使用glDrawElements时，我们会使用当前绑定的索引缓冲对象中的索引进行绘制：
 
 ```java
-GLES30.glDrawElements(GLES30.GL_TRIANGLE_STRIP,6,GLES30.GL_UNSIGNED_INT,0)
+GLES30.glDrawElements(GLES30.GL_TRIANGLE_STRIP, 6,GLES30.GL_UNSIGNED_INT, 0)
 ```
-第一个参数指定了我们绘制的模式，这个和glDrawArrays的一样。第二个参数是我们打算绘制顶点的个数，这里填6，也就是说我们一共需要绘制6个顶点。第三个参数是索引的类型，这里是GL_UNSIGNED_INT。最后一个参数里我们可以指定EBO中的偏移量（或者传递一个索引数组，但是这是当你不在使用索引缓冲对象的时候），但是我们会在这里填写0。
 
-glDrawElements函数从当前绑定到GL_ELEMENT_ARRAY_BUFFER目标的EBO中获取其索引。这意味着我们每次想要使用索引渲染对象时都必须绑定相应的EBO，这又有点麻烦。碰巧顶点数组对象也跟踪元素缓冲区对象绑定。在绑定VAO时，绑定的最后一个元素缓冲区对象存储为VAO的元素缓冲区对象。然后，绑定到VAO也会自动绑定该EBO。
+- 第一个参数指定了我们绘制的模式，这个和glDrawArrays的一样。        
+- 第二个参数是我们打算绘制顶点的个数，这里填6，也就是说我们一共需要绘制6个顶点。      
+- 第三个参数是索引的类型，这里是GL_UNSIGNED_INT。
+- 最后一个参数里我们可以指定EBO中的偏移量（或者传递一个索引数组，但是这是当你不在使用索引缓冲对象的时候），但是我们会在这里填写0。
+
+glDrawElements函数从当前绑定到GL_ELEMENT_ARRAY_BUFFER目标的EBO中获取其索引。       
+这意味着我们每次想要使用索引渲染对象时都必须绑定相应的EBO，这又有点麻烦。        
+碰巧顶点数组对象也跟踪元素缓冲区对象绑定。在绑定VAO时，绑定的最后一个元素缓冲区对象存储为VAO的元素缓冲区对象。然后，绑定到VAO也会自动绑定该EBO。
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/vertex_array_objects_ebo.png?raw=true)
 
-**注意:  EBO的绑定一定要在VAO解绑之前绑定！**
-**当目标是GL_ELEMENT_ARRAY_BUFFER的时候，VAO会储存glBindBuffer的函数调用。这也意味着它也会储存解绑调用，所以确保你没有在解绑VAO之前解绑索引数组缓冲，否则它就没有这个EBO配置了。**
+**注意:  EBO的绑定一定要在VAO解绑之前绑定！**         
+**当目标是GL_ELEMENT_ARRAY_BUFFER的时候，VAO会储存glBindBuffer的函数调用。这也意味着它也会储存解绑调用，所以确保你没有在解绑VAO之前解绑索引数组缓冲，否则它就没有这个EBO配置了。**           
 **OpenGL中会解绑VBO和VAO但是不能解绑EBO)**
 
+到这里我有点懵了，VAO有什么用？ 
+
+简单说就是VBO用于存储顶点数据，而VAO用于封装顶点数组的状态，包括顶点属性指针和VBO的绑定状态。这两者的结合使用可以使OpenGL中管理和切换多个顶点数据配置变得更加方便和高效。 
 
 
 ### 绘制矩形
diff --git "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md" "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
index 90c75bb4..6e1414d8 100644
--- "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
+++ "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
@@ -9,22 +9,6 @@
 GLSL中包含C等其它语言大部分的默认基础数据类型：int、float、double、uint和bool。       
 GLSL也有两种容器类型，它们会在这个教程中使用很多，分别是向量(Vector)和矩阵(Matrix)。
 
-向量(Vector):   
-- vecn : the default vector of n floats
-- bvecn : a vector of n booleans
-- ivecn : a vector of n integers
-- uvecn : a vector of u unsigned integers
-- dvecn : a vector of n double components
-
-与C语言有区别的地方:    
-- 共享命名空间(Shared Namespace)          
-    Shaders操作是相互独立的，但是为了方便Shaders间通信，在链接成一个shader program时会共享变量的名字。 
-- GLSL没有char、char *和string数据类型，也没有字符串操作
-- 不支持隐式类型转换，例如: int(arg)
-- vec数据方位: vec4(r,g,b,a / x,y,z,w / s,t,p,q)。 vec3.xy = vec2
-- 新的变量类型: Attribute、Uniform、Varying
-
-
 
 ### 顶点着色器:
 
@@ -79,13 +63,17 @@ OpenGL ES版本有自己的着色器语言，其中OpenGL ES的版本与GLSL的
 
 - `#version 300 es`这种声明版本的语句，必须放到第一行，并且shader中不能有Tab键，只能用空格替换。
 
-虽然着色器是各自独立的小程序，但是它们都是一个整体的一部分，出于这样的原因，我们希望每个着色器都有输入和输出，这样才能进行数据交流和传递。GLSL定义了in和out关键字专门来实现这个目的。每个着色器使用这两个关键字设定输入和输出，只要一个输出变量与下一个着色器阶段的输入匹配，它就会传递下去。但在顶点和片段着色器中会有点不同。
+虽然着色器是各自独立的小程序，但是它们都是一个整体的一部分，出于这样的原因，我们希望每个着色器都有输入和输出，这样才能进行数据交流和传递。       
+GLSL定义了in和out关键字专门来实现这个目的。     
+**每个着色器使用这两个关键字设定输入和输出，只要一个输出变量与下一个着色器阶段的输入匹配，它就会传递下去。**     
+但在顶点和片段着色器中会有点不同。
 
 
 
 
 
 #### in、out
+
 顶点着色器应该接收的是一种特殊形式的输入，否则就会效率低下。      
 顶点着色器的输入特殊在，它从顶点数据中直接接收输入。       
 为了定义顶点数据该如何管理，我们使用location这一元数据指定输入变量，这样我们才可以在CPU上配置顶点属性。       
@@ -96,7 +84,8 @@ OpenGL ES版本有自己的着色器语言，其中OpenGL ES的版本与GLSL的
 如果我们打算从一个着色器向另一个着色器发送数据，我们必须在发送方着色器中声明一个输出，在接收方着色器中声明一个类似的输入。       
 **当类型和名字都一样的时候，OpenGL就会把两个变量链接到一起，它们之间就能发送数据了（这是在链接程序对象时完成的）。**
 
-顶点着色器
+顶点着色器:   
+
 ```glsl
 #version 330 core
 layout (location = 0) in vec3 aPos; // 位置变量的属性位置值为0
@@ -109,7 +98,9 @@ void main()
     vertexColor = vec4(0.5, 0.0, 0.0, 1.0); // 把输出变量设置为暗红色
 }
 ```
-片段着色器
+
+片段着色器:     
+
 ```glsl
 #version 330 core
 out vec4 FragColor;
@@ -121,7 +112,10 @@ void main()
     FragColor = vertexColor;
 }
 ```
-你可以看到我们在顶点着色器中声明了一个vertexColor变量作为vec4输出，并在片段着色器中声明了一个类似的vertexColor。由于它们名字相同且类型相同，片段着色器中的vertexColor就和顶点着色器中的vertexColor链接了。由于我们在顶点着色器中将颜色设置为深红色，最终的片段也是深红色的。
+
+你可以看到我们在顶点着色器中声明了一个vertexColor变量作为vec4输出，并在片段着色器中声明了一个类似的vertexColor。      
+由于它们名字相同且类型相同，片段着色器中的vertexColor就和顶点着色器中的vertexColor链接了。        
+由于我们在顶点着色器中将颜色设置为深红色，最终的片段也是深红色的。
 
 
 ####  精度限定符
@@ -148,19 +142,20 @@ precision mediump int;
 #### Uniform
 Uniform是一种从CPU中的应用向GPU中的着色器发送数据的方式，但uniform和顶点属性有些不同。     
 
-首先，uniform是全局的(Global)。     
+首先，uniform是全局的(Global)。         
 全局意味着uniform变量必须在每个着色器程序对象中都是独一无二的，而且它可以被着色器程序的任意着色器在任意阶段访问。       
 
 第二，无论你把uniform值设置成什么，uniform会一直保存它们的数据，直到它们被重置或更新。
 
 统一变量通常保存在硬件中，这个区域被称作“常量存储”，是硬件中为存储常量值而分配的特殊空间。    
 
-因为常量存储的大小一般是固定的，所以程序中可以使用的统一变量数量受到限制。      
+因为常量存储的大小一般是固定的，所以程序中可以使用的统一变量数量受到限制。          
 这种限制可以通过读取内建变量gl_MaxVertexUniformVectors和gl_MaxFragmentUniformVectors的值来确定。
-但是对于在编译时已知值的变量应该是常量，而不是统一变量，这样可以提高效率。
+但是对于在编译时已知值的变量应该是常量，而不是统一变量，这样可以提高效率。     
+
 
+我们可以在一个着色器中添加uniform关键字至类型和变量名前来声明一个GLSL的uniform。从此处开始我们就可以在着色器中使用新声明的uniform了。我们来看看这次是否能通过uniform设置三角形的颜色：     
 
-我们可以在一个着色器中添加uniform关键字至类型和变量名前来声明一个GLSL的uniform。从此处开始我们就可以在着色器中使用新声明的uniform了。我们来看看这次是否能通过uniform设置三角形的颜色：
 ```glsl
 #version 330 core
 out vec4 FragColor;
@@ -172,7 +167,10 @@ void main()
     FragColor = ourColor;
 }
 ```
-我们在片段着色器中声明了一个uniform vec4的ourColor，并把片段着色器的输出颜色设置为uniform值的内容。因为uniform是全局变量，我们可以在任何着色器中定义它们，而无需通过顶点着色器作为中介。顶点着色器中不需要这个uniform，所以我们不用在那里定义它。
+
+我们在片段着色器中声明了一个uniform vec4的ourColor，并把片段着色器的输出颜色设置为uniform值的内容。       
+因为uniform是全局变量，我们可以在任何着色器中定义它们，而无需通过顶点着色器作为中介。          
+顶点着色器中不需要这个uniform，所以我们不用在那里定义它。
 
 **如果你声明了一个uniform却在GLSL代码中没用过，编译器会静默移除这个变量，导致最后编译出的版本中并不会包含它，这可能导致几个非常麻烦的错误，记住这点！**
 
@@ -187,9 +185,9 @@ glUniform4f(vertexColorLocation, 0.0f, greenValue, 0.0f, 1.0f);
 ```
 首先我们通过glfwGetTime()获取运行的秒数。然后我们使用sin函数让颜色在0.0到1.0之间改变，最后将结果储存到greenValue里。
 
-接着，我们用glGetUniformLocation查询uniform ourColor的位置值。我们为查询函数提供着色器程序和uniform的名字（这是我们希望获得的位置值的来源）。
-如果glGetUniformLocation返回-1就代表没有找到这个位置值。
-最后，我们可以通过glUniform4f函数设置uniform值。注意，查询uniform地址不要求你之前使用过着色器程序，但是更新一个uniform之前你必须先使用程序（调用glUseProgram)，因为它是在当前激活的着色器程序中设置uniform的。
+接着，我们用glGetUniformLocation查询uniform ourColor的位置值。我们为查询函数提供着色器程序和uniform的名字（这是我们希望获得的位置值的来源）。          
+如果glGetUniformLocation返回-1就代表没有找到这个位置值。          
+最后，我们可以通过glUniform4f函数设置uniform值。注意，查询uniform地址不要求你之前使用过着色器程序，但是更新一个uniform之前你必须先使用程序（调用glUseProgram)，因为它是在当前激活的着色器程序中设置uniform的。         
 
 因为OpenGL在其核心是一个C库，所以它不支持类型重载，在函数参数不同的时候就要为其定义新的函数；glUniform是一个典型例子。这个函数有一个特定的后缀，标识设定的uniform的类型。可能的后缀有：
 
@@ -199,23 +197,31 @@ glUniform4f(vertexColorLocation, 0.0f, greenValue, 0.0f, 1.0f);
 - 3f: 函数需要3个float作为它的值
 - fv: 函数需要一个float向量/数组作为它的值
 
-每当你打算配置一个OpenGL的选项时就可以简单地根据这些规则选择适合你的数据类型的重载函数。在我们的例子里，我们希望分别设定uniform的4个float值，所以我们通过glUniform4f传递我们的数据(注意，我们也可以使用fv版本)。
+每当你打算配置一个OpenGL的选项时就可以简单地根据这些规则选择适合你的数据类型的重载函数。在我们的例子里，我们希望分别设定uniform的4个float值，所以我们通过glUniform4f传递我们的数据(注意，我们也可以使用fv版本)。       
 
-现在你知道如何设置uniform变量的值了，我们可以使用它们来渲染了。如果我们打算让颜色慢慢变化，我们就要在游戏循环的每一次迭代中（所以他会逐帧改变）更新这个uniform，否则三角形就不会改变颜色。
+现在你知道如何设置uniform变量的值了，我们可以使用它们来渲染了。如果我们打算让颜色慢慢变化，我们就要在游戏循环的每一次迭代中（所以他会逐帧改变）更新这个uniform，否则三角形就不会改变颜色。        
 
 
 
 ### GLSL的特点
 
-OpenGLES的着色器语言GLSL是一种高级的图形化编程语言，其源自应用广泛的C语言。与传统的C语言不同的是，它提供了更加丰富的针对于图像处理的原生类型，诸如向量、矩阵之类。GLSL主要包含以下特性：
+OpenGLES的着色器语言GLSL是一种高级的图形化编程语言，其源自应用广泛的C语言。与传统的C语言不同的是，它提供了更加丰富的针对于图像处理的原生类型，诸如向量、矩阵之类。GLSL主要包含以下特性：       
 
-- GLSL是一种面向过程的语言，和c相同
+- GLSL是一种面向过程的语言，和c相同  
 - GLSL的基本语法与C/C++相同
 - 它完美的支持向量和矩阵的操作
 - 它是通过限定符操作来管理输入输出类型的
 - GLSL提供了大量的内置函数来提供丰富的扩展功能
 
 
+与C语言有区别的地方:    
+
+- 共享命名空间(Shared Namespace)          
+    Shaders操作是相互独立的，但是为了方便Shaders间通信，在链接成一个shader program时会共享变量的名字。 
+- GLSL没有char、char *和string数据类型，也没有字符串操作
+- 不支持隐式类型转换，例如: int(arg)
+- vec数据方位: vec4(r,g,b,a / x,y,z,w / s,t,p,q)。 vec3.xy = vec2
+- 新的变量类型: Attribute、Uniform、Varying
 
 ### 基本数据类型
 
@@ -223,12 +229,19 @@ GLSL中的数据类型主要分为标量、向量、矩阵、采样器、结构
 
 - 标量 
 
-标量表示的是只有大小没有方向的量，在GLSL中`标量只有bool、int和float三种`。对于int，和C一样，可以写为十进制（16）、八进制（020）或者十六进制（0x10）。对于标量的运算，我们最需要注意的是`精度`，防止溢出问题。
+标量表示的是只有大小没有方向的量，在GLSL中`标量只有bool、int和float三种`。       
+对于int，和C一样，可以写为十进制（16）、八进制（020）或者十六进制（0x10）。         
+对于标量的运算，我们最需要注意的是`精度`，防止溢出问题。
 
 - 向量
 
-向量我们可以看做是数组，在GLSL通常用于储存颜色、坐标等数据，针对维数，可分为二维、三维和四维向量。    
-针对存储的标量类型，可以分为bool、int和float。共有vec2、vec3、vec4，ivec2、ivec3、ivec4、bvec2、bvec3和bvec4九种类型，数组代表维数、i表示int类型、b表示bool类型。***需要注意的是，GLSL中的向量表示竖向量，所以与矩阵相乘进行变换时，矩阵在前，向量在后（与DirectX正好相反）***。向量在GPU中由硬件支持运算，比CPU快的多。    
+向量我们可以看做是数组，在GLSL通常用于储存颜色、坐标等数据，针对维数，可分为二维、三维和四维向量。         
+针对存储的标量类型，可以分为bool、int和float。       
+共有vec2、vec3、vec4，ivec2、ivec3、ivec4、bvec2、bvec3和bvec4九种类型，数组代表维数、i表示int类型、b表示bool类型。        
+
+***需要注意的是，GLSL中的向量表示竖向量，所以与矩阵相乘进行变换时，矩阵在前，向量在后（与DirectX正好相反）***        
+
+向量在GPU中由硬件支持运算，比CPU快的多。    
 
 作为颜色向量时，用rgba表示分量，就如同取数组的中具体数据的索引值。三维颜色向量就用rgb表示分量。比如对于颜色向量vec4 color，color[0]和color.r都表示color向量的第一个值，也就是红色的分量。其他相同。     
 
@@ -245,7 +258,8 @@ vec4 result = vec4(vect, 0.0, 0.0);
 
 - 矩阵
 
-在GLSL中矩阵拥有2 * 2、3 * 3、4 * 4三种类型的矩阵，分别用mat2、mat3、mat4表示。我们可以把矩阵看做是一个二维数组，也可以用二维数组下表的方式取里面具体位置的值。
+在GLSL中矩阵拥有2 * 2、3 * 3、4 * 4三种类型的矩阵，分别用mat2、mat3、mat4表示。         
+我们可以把矩阵看做是一个二维数组，也可以用二维数组下表的方式取里面具体位置的值。      
 现在我们已经讨论了向量的全部内容，是时候看看矩阵了！简单来说矩阵就是一个矩形的数字、符号或表达式数组。矩阵中每一项叫做矩阵的元素(Element)。下面是一个2×3矩阵的例子：
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/juzhen_0.png?raw=true)
 
@@ -315,7 +329,7 @@ GLSL的类型转换与C不同。在GLSL中类型不可以自动提升，比如fl
 
 在着色器中有一些特殊的变量，不用声明也可以使用，这些变量叫做内建变量。 他们大致可以分为两种，一种是input类型，负责向硬件(渲染管线)发送数据；另一种是output类型，负责向程序回传数据，以便编程时需要。内建变量相当于着色器硬件的输入和输出点，使用者利用这些输入点输入之后，就会看到屏幕上的输出。通过输出点可以知道输出的某些数据内容。
 
- #### 顶点着色器的内建变量
+#### 顶点着色器的内建变量
 
 - 输入变量
   - gl_Position:顶点坐标信息
@@ -383,7 +397,9 @@ GLSL的类型转换与C不同。在GLSL中类型不可以自动提升，比如fl
 
 ### 更多
 
-在前面的教程中，我们了解了如何填充VBO、配置顶点属性指针以及如何把它们都储存到一个VAO里。这次，我们同样打算把颜色数据加进顶点数据中。我们将把颜色数据添加为3个float值至vertices数组。我们将把三角形的三个角分别指定为红色、绿色和蓝色：
+在前面的教程中，我们了解了如何填充VBO、配置顶点属性指针以及如何把它们都储存到一个VAO里。      
+这次，我们同样打算把颜色数据加进顶点数据中。我们将把颜色数据添加为3个float值至vertices数组。我们将把三角形的三个角分别指定为红色、绿色和蓝色：   
+
 ```java
 float vertices[] = {
     // 位置              // 颜色
@@ -392,7 +408,9 @@ float vertices[] = {
      0.0f,  0.5f, 0.0f,  0.0f, 0.0f, 1.0f    // 顶部
 };
 ```
-由于现在有更多的数据要发送到顶点着色器，我们有必要去调整一下顶点着色器，使它能够接收颜色值作为一个顶点属性输入。需要注意的是我们用layout标识符来把aColor属性的位置值设置为1：
+由于现在有更多的数据要发送到顶点着色器，我们有必要去调整一下顶点着色器，使它能够接收颜色值作为一个顶点属性输入。     
+需要注意的是我们用layout标识符来把aColor属性的位置值设置为1：
+
 ```glsl
 #version 330 core
 layout (location = 0) in vec3 aPos;   // 位置变量的属性位置值为 0 
@@ -406,7 +424,8 @@ void main()
     ourColor = aColor; // 将ourColor设置为我们从顶点数据那里得到的输入颜色
 }
 ```
-由于我们不再使用uniform来传递片段的颜色了，现在使用ourColor输出变量，我们必须再修改一下片段着色器：
+由于我们不再使用uniform来传递片段的颜色了，现在使用ourColor输出变量，我们必须再修改一下片段着色器：     
+
 ```glsl
 #version 330 core
 out vec4 FragColor;  
@@ -421,7 +440,8 @@ void main()
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/vertex_attribute_pointer_interleaved.png?raw=true)
 
-知道了现在使用的布局，我们就可以使用glVertexAttribPointer函数更新顶点格式，
+知道了现在使用的布局，我们就可以使用glVertexAttribPointer函数更新顶点格式：     
+
 ```java
 // 位置属性
 GLES30.glVertexAttribPointer(0, 3, GLES30.GL_FLOAT, false, 6 * Float.BYTES, 0);
@@ -431,10 +451,10 @@ GLES30.glVertexAttribPointer(1, 3, GLES30.GL_FLOAT, false, 6 * Float.BYTES, 3* F
 // 1是对应上面着色器代码中的位置： layout (location = 1) in vec3 aColor; 颜色变量的属性位置值为 1
 GLES30.glEnableVertexAttribArray(1);
 ```
-glVertexAttribPointer函数的前几个参数比较明了。这次我们配置属性位置值为1的顶点属性。颜色值有3个float那么大，我们不去标准化这些值。     
-由于我们现在有了两个顶点属性，我们不得不重新计算步长值。为获得数据队列中下一个属性值（比如位置向量的下个x分量）我们必须向右移动6个float，其中3个是位置值，另外3个是颜色值。    
-这使我们的步长值为6乘以float的字节数（=24字节）。    
-同样，这次我们必须指定一个偏移量。对于每个顶点来说，位置顶点属性在前，所以它的偏移量是0。颜色属性紧随位置数据之后，所以偏移量就是Float.BYTES，用字节来计算就是12字节。
+glVertexAttribPointer函数的前几个参数比较明了。这次我们配置属性位置值为1的顶点属性。颜色值有3个float那么大，我们不去标准化这些值。         
+由于我们现在有了两个顶点属性，我们不得不重新计算步长值。为获得数据队列中下一个属性值（比如位置向量的下个x分量）我们必须向右移动6个float，其中3个是位置值，另外3个是颜色值。     
+这使我们的步长值为6乘以float的字节数（=24字节）。        
+同样，这次我们必须指定一个偏移量。对于每个顶点来说，位置顶点属性在前，所以它的偏移量是0。颜色属性紧随位置数据之后，所以偏移量就是Float.BYTES，用字节来计算就是12字节。    
 
 
 
diff --git "a/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md" "b/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
index 2de853ff..01eb63e1 100644
--- "a/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
+++ "b/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
@@ -134,7 +134,9 @@ GLES30.glVertexAttribPointer(1, 4, GLES30.GL_FLOAT, false, 0, colorBuffer);
 
 ### 启用或禁用顶点属性数组
 
-调用GLES30.glEnableVertexAttribArray和GLES30.glDisableVertexAttribArray传入参数index。如果启用，那么当GLES30.glDrawArrays或者GLES30.glDrawElements被调用时，顶点属性数组会被使用。
+调用GLES30.glEnableVertexAttribArray和GLES30.glDisableVertexAttribArray传入参数index。            
+
+如果启用，那么当GLES30.glDrawArrays或者GLES30.glDrawElements被调用时，顶点属性数组会被使用。
 
 ## Matrix
 
@@ -172,12 +174,16 @@ Matrix是专门为处理4*4矩阵和4元素向量设计的，其中的方法都
 
 顶点着色器可赋予程序员一次操作一个顶点（“按顶点”处理）的能力，片段着色器（稍后会看到）可赋予程序员一次操作一个像素（“按片段”处理）的能力，几何着色器可赋予程序员一次操作一个图元（“按图元”处理）的能力。
 
-到目前为止，我们所接触的变换矩阵全都可以在3D空间中操作。但是，我们最终需要将3D空间或它的一部分展示在2D显示器上。为了达成这个目标，我们需要找到一个有利点。正如我们在现实世界通过眼睛从一点观察一样，我们也必须找到一点并确立观察方向作为我们观察虚拟世界的窗口。这个点叫作视图或视觉空间，或“合成相机”（简称相机）。
+到目前为止，我们所接触的变换矩阵全都可以在3D空间中操作。但是，我们最终需要将3D空间或它的一部分展示在2D显示器上。       
+
+为了达成这个目标，我们需要找到一个有利点。       
+正如我们在现实世界通过眼睛从一点观察一样，我们也必须找到一点并确立观察方向作为我们观察虚拟世界的窗口。这个点叫作视图或视觉空间，或“合成相机”（简称相机）。
+
+观察3D世界需要:    
 
-观察3D世界需要：
 - 将相机放入世界的某个位置；
 - 调整相机的角度，通常需要一套它自己的直角坐标轴u、v、n（由向量U，V，N构成）；
-- 定义一个视体(view volume)；(d)将视体内的对象投影到投影平面(projection plane)上。
+- 定义一个视体(view volume)；将视体内的对象投影到投影平面(projection plane)上。
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_eye.jpg?raw=true)
 
@@ -185,17 +191,18 @@ OpenGL有一个固定在原点(0,0,0)并朝向z轴负方向的相机，如下图
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_eye_00.jpg?raw=true)
 
-为了应用OpenGL相机，我们需要将它移动到适合的位置和方向。我们需要先找出在世界中的物体与我们期望的相机位置的相对位置。     
+为了应用OpenGL相机，我们需要将它移动到适合的位置和方向。我们需要先找出在世界中的物体与我们期望的相机位置的相对位置。      
 给定世界空间中的点PW，我们需要通过变换将它转换成相应相机空间中的点，从而让它看起来好像是从我们期望的相机位置CW看到的样子。    
 
 
 当我们设置好相机之后，就可以学习投影矩阵了。我们需要学习的两个重要的投影矩阵：透视投影矩阵和正射投影矩阵。    
-透视投影通过使用透视概念模仿我们看真实世界的方式，尝试让2D图像看起来像是3D的。物体近大远小，3D空间中有的平行线用透视法画出来就不再平行。我们可以通过使用变换矩阵将平行线变为恰当的不平行线来实现这个效果，这个矩阵叫作透视矩阵或者透视变换。
+透视投影通过使用透视概念模仿我们看真实世界的方式，尝试让2D图像看起来像是3D的。物体近大远小，3D空间中有的平行线用透视法画出来就不再平行。我们可以通过使用变换矩阵将平行线变为恰当的不平行线来实现这个效果，这个矩阵叫作透视矩阵或者透视变换。           
 
 在正射投影中，平行线仍然是平行的，即不使用透视，如下图所示。正射与透视相反，在视体中的物体不因其与相机的距离而改变，可以直接投影。正射投影是一种平行投影，其中所有的投影过程都沿与投影平面垂直的方向进行。
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_zheng.jpg?raw=true)
 
-我们最后要学习的变换矩阵是LookAt矩阵。当你想要把相机放在某处并看向一个特定的位置时，就需要用到它了，LookAt矩阵的元素如图3.19所示。当然，用我们已经学到的方法也可以实现LookAt变换，但是这个操作非常频繁，因此为它专门构建一个矩阵通常比较有用。
+我们最后要学习的变换矩阵是LookAt矩阵。当你想要把相机放在某处并看向一个特定的位置时，就需要用到它了，LookAt矩阵的元素如下图所示。        
+当然，用我们已经学到的方法也可以实现LookAt变换，但是这个操作非常频繁，因此为它专门构建一个矩阵通常比较有用。
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_lookat.jpg?raw=true)
 
 - invertM
diff --git "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md" "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"
index e86877ad..3f3fb88b 100644
--- "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
+++ "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
@@ -11,7 +11,9 @@
 
 - 纹理目标:一个纹理单元中包含了多个类型的纹理目标，有GL_TEXTURE_1D、GL_TEXTURE_2D、CUBE_MAP等。本章中，将纹理ID绑定到纹理单元0的GL_TEXTURE_2D纹理目标上，之后对纹理目标的操作都是对纹理Id对应的数据进行操作。
 
-  OpenGL要操作一个纹理，那么是将纹理ID装进纹理单元这个容器里，然后再通过操作纹理单元的方式去实现的。这样的话，我们可以加载出很多很多个纹理ID(但要注意爆内存问题)，但只有16个纹理单元，在Fragment Shader里最多同时能操作16个单元。
+OpenGL要操作一个纹理，那么是将纹理ID装进纹理单元这个容器里，然后再通过操作纹理单元的方式去实现的。      
+
+这样的话，我们可以加载出很多很多个纹理ID(但要注意爆内存问题)，但只有16个纹理单元，在Fragment Shader里最多同时能操作16个单元。
 
   
 
@@ -23,7 +25,9 @@
 
 ### 纹理坐标
 
-OpenGL中，2D纹理也有自己的坐标体系，取值范围在(0,0)到(1,1)内，两个维度分别为S、T，所以一般称为ST纹理坐标。有些时候也叫UV坐标。纹理左边的方向性和Android上的视图坐标系一致，都是顶点在左上角，范围为0到1之间。
+OpenGL中，2D纹理也有自己的坐标体系，取值范围在(0,0)到(1,1)内，两个维度分别为S、T，所以一般称为ST纹理坐标。     
+有些时候也叫UV坐标。      
+纹理左边的方向性和Android上的视图坐标系一致，都是顶点在左上角，范围为0到1之间。
 
 
 纹理上的每个顶点与定点坐标上的顶点一一对应。如下图，左边是顶点坐标，右边是纹理坐标，只要两个坐标的ABCD定义顺序一致，就可以正常地映射出对应的图形。顶点坐标内光栅化后的每个片段，都会在纹理坐标内取得对应的颜色值。
@@ -31,16 +35,16 @@ OpenGL中，2D纹理也有自己的坐标体系，取值范围在(0,0)到(1,1)
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_texture_position.jpg)
 
 
-在 OpenGL 中，纹理实际上是一个可以被采样的复杂数据集合，是 GPU 使用的图像数据结构，纹理分为 2D 纹理、 立方图纹理和 3D 纹理。
+在OpenGL中，纹理实际上是一个可以被采样的复杂数据集合，是GPU使用的图像数据结构，纹理分为2D纹理、立方图纹理和3D纹理。
 
-2D 纹理是 OpenGLES 中最常用和最常见的纹理形式，是一个图像数据的二维数组。纹理中的一个单独数据元素称为纹素或纹理像素。
+2D纹理是OpenGLES中最常用和最常见的纹理形式，是一个图像数据的二维数组。纹理中的一个单独数据元素称为纹素或纹理像素。
 
-立方图纹理是一个由 6 个单独的纹理面组成的纹理。立方图纹理像素的读取通过使用一个三维坐标（s,t,r）作为纹理坐标。
+立方图纹理是一个由6个单独的纹理面组成的纹理。立方图纹理像素的读取通过使用一个三维坐标（s,t,r）作为纹理坐标。
 
-3D 纹理可以看作 2D 纹理作为切面的一个数组，类似于立方图纹理，使用三维坐标对其进行访问。
+3D纹理可以看作2D纹理作为切面的一个数组，类似于立方图纹理，使用三维坐标对其进行访问。
 
 
-在 OpenGLES 中，纹理映射就是通过为图元的顶点坐标指定恰当的纹理坐标，通过纹理坐标在纹理图中选定特定的纹理区域，最后通过纹理坐标与顶点的映射关系，将选定的纹理区域映射到指定图元上。
+在OpenGLES中，纹理映射就是通过为图元的顶点坐标指定恰当的纹理坐标，通过纹理坐标在纹理图中选定特定的纹理区域，最后通过纹理坐标与顶点的映射关系，将选定的纹理区域映射到指定图元上。
 
 纹理映射也称为纹理贴图，简单地说就是将纹理坐标（纹理坐标系）所指定的纹理区域，映射到顶点坐标（渲染坐标系或OpenGLES 坐标系）对应的区域。
 
@@ -48,14 +52,13 @@ OpenGL中，2D纹理也有自己的坐标体系，取值范围在(0,0)到(1,1)
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/texture_st_1.png)
 渲染坐标系或OpenGLES 坐标系:
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/texture_st_2.png)
-4 个纹理坐标分别为
-T0（0，0），T1（0，1），T2（1，1），T3（1，0）。
-4 个纹理坐标对于的顶点坐标分别为
-V0（-1，0.5），V1（-1， -0.5），V2（1，-0.5），V3（1，0.5）
-由于 OpenGLES 绘制是以三角形为单位的，设置绘制的 2 个三角形为 V0V1V2 和 V0V2V3 。
-当我们调整纹理坐标的顺序顶点坐标顺序不变，如 T0T1T2T3 -> T1T2T3T0 ，绘制后将得到一个顺时针旋转 90 度的纹理贴图。所以调整纹理坐标和顶点坐标的对应关系可以实现纹理图简单的旋转。
-
-
+4个纹理坐标分别为:       
+T0（0，0），T1（0，1），T2（1，1），T3（1，0）       
+4个纹理坐标对于的顶点坐标分别为:       
+V0（-1，0.5），V1（-1， -0.5），V2（1，-0.5），V3（1，0.5）      
+由于OpenGLES绘制是以三角形为单位的，设置绘制的2个三角形为V0V1V2和V0V2V3。           
+当我们调整纹理坐标的顺序顶点坐标顺序不变，如T0T1T2T3 -> T1T2T3T0，绘制后将得到一个顺时针旋转90度的纹理贴图。           
+所以调整纹理坐标和顶点坐标的对应关系可以实现纹理图简单的旋转。
 
 
 
@@ -63,15 +66,18 @@ V0（-1，0.5），V1（-1， -0.5），V2（1，-0.5），V3（1，0.5）
 
 ### 文件读取
 
-OpenGL不能直接加载jpg或者png这类被编码的压缩格式，需要加载原始数据，也就是bitmap。我们在内置图片到工程中，应该将图片放到drawable-nodpi中，避免读取时被压缩，通过BitmapFactory解码读取图片时，要设置为非缩放的方式，即options.isScaled=false。
+OpenGL不能直接加载jpg或者png这类被编码的压缩格式，需要加载原始数据，也就是bitmap。        
+我们在内置图片到工程中，应该将图片放到drawable-nodpi中，避免读取时被压缩，通过BitmapFactory解码读取图片时，要设置为非缩放的方式，即options.isScaled=false。
 
 ### 纹理过滤
 
-当我们通过光栅化将图形处理成一个个小片段的时候，再将纹理采样，渲染到指定位置上时，通常会遇到纹理元素和小片段并非一一对应。这时候，会出现纹理的压缩或者放大。那么在这两种情况下，就会有不同的处理方案，这就是纹理过滤了。
+当我们通过光栅化将图形处理成一个个小片段的时候，再将纹理采样，渲染到指定位置上时，通常会遇到纹理元素和小片段并非一一对应。      
+这时候，会出现纹理的压缩或者放大。那么在这两种情况下，就会有不同的处理方案，这就是纹理过滤了。
 
 ### 纹理对象和纹理的加载
 
-纹理应用的第一步是创建一个纹理对象。纹理对象是一个容器对象，保存渲染所需的纹理数据，例如图像数据、过滤模式和包装模式。在OpenGL ES中，纹理对象用一个无符号整数表示，该整数是纹理对象的一个句柄，用于生成纹理对象的函数是glGenTextures。
+纹理应用的第一步是创建一个纹理对象。纹理对象是一个容器对象，保存渲染所需的纹理数据，例如图像数据、过滤模式和包装模式。         
+在OpenGL ES中，纹理对象用一个无符号整数表示，该整数是纹理对象的一个句柄，用于生成纹理对象的函数是glGenTextures。 
 
 - glGenTextures(GLsizei n, GLunit *textures)
 
@@ -93,7 +99,7 @@ OpenGL不能直接加载jpg或者png这类被编码的压缩格式，需要加
 
 下面是一个工具类方法，相对通用，能解决大部分需求，这个方法可以将内置的图片资源加载出对应的纹理ID。
 
- ```java
+```java
 public class TextureUtil {
     private static final String TAG = "TextureHelper";
 
@@ -247,9 +253,12 @@ public class TextureUtil {
 
 - 片段着色器
 
-片段着色器也应该能访问纹理对象，但是我们怎样能把纹理对象传给片段着色器呢？GLSL有一个供纹理对象使用的内建数据类型，叫做采样器(Sampler)，它以纹理类型作为后缀，比如sampler1D、sampler3D，或在我们的例子中的sampler2D。我们可以简单声明一个uniform sampler2D把一个纹理添加到片段着色器中，稍后我们会把纹理赋值给这个uniform。
+片段着色器也应该能访问纹理对象，但是我们怎样能把纹理对象传给片段着色器呢？         
+GLSL有一个供纹理对象使用的内建数据类型，叫做采样器(Sampler)，它以纹理类型作为后缀，比如sampler1D、sampler3D，或在我们的例子中的sampler2D。       
+我们可以简单声明一个uniform sampler2D把一个纹理添加到片段着色器中，稍后我们会把纹理赋值给这个uniform。
 
-我们使用GLSL内建的texture函数来采样纹理的颜色，它第一个参数是纹理采样器，第二个参数是对应的纹理坐标。texture函数会使用之前设置的纹理参数对相应的颜色值进行采样。这个片段着色器的输出就是纹理的（插值）纹理坐标上的(过滤后的)颜色。
+我们使用GLSL内建的texture函数来采样纹理的颜色，它第一个参数是纹理采样器，第二个参数是对应的纹理坐标。           
+texture函数会使用之前设置的纹理参数对相应的颜色值进行采样。这个片段着色器的输出就是纹理的（插值）纹理坐标上的(过滤后的)颜色。
 
 
 之前直接输出顶点着色器来的颜色，现在变为经过纹理处理最终成为输出颜色。
@@ -285,11 +294,12 @@ GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, textureId);
 GLES20.glUniform1i(aTextureLocation, 0);
 ```
 
-这里有没有很奇怪，sampler2D的变量是uniform的，但是我们并不是用glUniform()方法给他赋值，而是使用glUniform1i()。这是因为可以给纹理采样器分配一个位置值，这样我们就能够在一个片段着色器中设置多个纹理单元。一个纹理的话，纹理单元是默认为0，它是默认激活的，纹理单元的主要目的就是给着色器多一个使用的纹理。通过纹理单元赋值给采样器，我们可以一次绑定多个纹理，只要我们在使用的时候激活纹理。
+这里有没有很奇怪，sampler2D的变量是uniform的，但是我们并不是用glUniform()方法给他赋值，而是使用glUniform1i()。         
+这是因为可以给纹理采样器分配一个位置值，这样我们就能够在一个片段着色器中设置多个纹理单元。一个纹理的话，纹理单元是默认为0，它是默认激活的，纹理单元的主要目的就是给着色器多一个使用的纹理。         
+通过纹理单元赋值给采样器，我们可以一次绑定多个纹理，只要我们在使用的时候激活纹理。
 
-  
 
-  ```java
+```java
   public class TextureRender extends BaseGLSurfaceViewRenderer {
       private final FloatBuffer vertextBuffer;
       private final FloatBuffer textureBuffer;
@@ -367,17 +377,18 @@ GLES20.glUniform1i(aTextureLocation, 0);
           glDisableVertexAttribArray(aTextureLocation);
       }
   }
-  ```
+```
 
 
 
 ### 多纹理绘制 
 
 
-
 - 单纹理单元，多次绘制
 
-多次调用glDrawArrays绘制纹理顶点的方式来实现，这样就是一张一张的按先后顺序，一层一层的绘制到当前的一帧画面。着色器与上面的完全一致，唯一不同的是要提供两个顶点位置的坐标，然后分别设置这两个坐标，并绑定两次纹理，然后调用两次glDrawArrays进行绘制。
+多次调用glDrawArrays绘制纹理顶点的方式来实现，这样就是一张一张的按先后顺序，一层一层的绘制到当前的一帧画面。        
+
+着色器与上面的完全一致，唯一不同的是要提供两个顶点位置的坐标，然后分别设置这两个坐标，并绑定两次纹理，然后调用两次glDrawArrays进行绘制。
 
 ```java
 public class MultiTextureRender extends BaseGLSurfaceViewRenderer {

From d3d4dc1c2dd6b5c00f59db66dc5a59fc43bc78dc Mon Sep 17 00:00:00 2001
From: Charon <CharonChui@users.noreply.github.com>
Date: Thu, 30 Nov 2023 14:58:38 +0800
Subject: [PATCH 151/213] Update README.md

---
 README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 01ed8394..5f20491c 100644
--- a/README.md
+++ b/README.md
@@ -11,11 +11,11 @@ Android学习笔记
 目录
 ===  
 
-- [史上最适合Android开发者学习的Go语言教程](https://github.com/CharonChui/GolangStudyNote)
-- [史上最适合Android开发者学习的iOS开发教程](https://github.com/CharonChui/iOSStudyNote)
+- [史上最适合Android开发者学习的Harmony OS Next语言教程](https://github.com/CharonChui/HarmonyOSNextStudyNote)
+
 - [源码解析][43] 
     - [自定义View详解][1]
-    - [Activity界面绘制过程详解][2]
+    - [Activity界面制过程详解][2]
     - [Activity启动过程][3]
     - [Android Touch事件分发详解][4]
     - [AsyncTask详解][5]

From 4cfccf0403cb3194c43f7021d1f94af19db028a4 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Fri, 26 Jan 2024 16:10:08 +0800
Subject: [PATCH 152/213] update android note

---
 AdavancedPart/AOP.md                             | 14 ++++++++++++++
 "Gradle&Maven/Gradle\344\270\223\351\242\230.md" | 10 ++++++++--
 2 files changed, 22 insertions(+), 2 deletions(-)
 create mode 100644 AdavancedPart/AOP.md

diff --git a/AdavancedPart/AOP.md b/AdavancedPart/AOP.md
new file mode 100644
index 00000000..3bcc633b
--- /dev/null
+++ b/AdavancedPart/AOP.md
@@ -0,0 +1,14 @@
+AOP
+---
+
+
+AOP(Aspect Oriented Programing),面向切面编程。
+是OOP(Object Oriented Programing)面向对象编程的延续。
+
+在OOP思想中，我们会把问题划分为各个模块，如语言、表情等。     
+在划分这些模块的过程中，也会出现一些共同特征(如埋点)。它的逻辑被分散到了各个模块，导致了代码复杂度提高，可复用性降低。
+
+而AOP，就是将各个模块中的通用逻辑抽离出来。
+我们将这些逻辑视为Aspect(切面)，然后动态地把代码插入到类的指定方法、指定位置中。 
+
+
diff --git "a/Gradle&Maven/Gradle\344\270\223\351\242\230.md" "b/Gradle&Maven/Gradle\344\270\223\351\242\230.md"
index 79e9314b..7f32fd81 100644
--- "a/Gradle&Maven/Gradle\344\270\223\351\242\230.md"
+++ "b/Gradle&Maven/Gradle\344\270\223\351\242\230.md"
@@ -9,7 +9,13 @@ Gradle专题
 作用
 ---
 
-首先我们要知道它有什么用？ Gradle是一个工具，同时它也是一个编程框架。使用这个工具可以完成app的编译打包等工作。
+Gradle是一个开源的自动化构建工具。现在Android项目构建编译都是通过Gradle进行的，Gradle的版本在`gradle/wrapper/gradle-wrapper.properties`下:   
+```
+
+```
+
+
+使用这个工具可以完成app的编译打包等工作。
 
 
 简介
@@ -1712,4 +1718,4 @@ pizzaPrices.pepperoni
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 

From 252a6aadf3477aa7cde99601cdd6c5559236a482 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Fri, 26 Jan 2024 19:58:21 +0800
Subject: [PATCH 153/213] update gradle part

---
 .../Gradle\344\270\223\351\242\230.md"        | 74 +++++++++++++++----
 1 file changed, 58 insertions(+), 16 deletions(-)

diff --git "a/Gradle&Maven/Gradle\344\270\223\351\242\230.md" "b/Gradle&Maven/Gradle\344\270\223\351\242\230.md"
index 7f32fd81..5968cbbe 100644
--- "a/Gradle&Maven/Gradle\344\270\223\351\242\230.md"
+++ "b/Gradle&Maven/Gradle\344\270\223\351\242\230.md"
@@ -1,31 +1,27 @@
 Gradle专题
 ===
 
-随着`Google`对`Eclipse`的无情抛弃以及`Studio`的不断壮大，`Android`开发者逐渐拜倒在`Studio`的石榴裙下。       
-而作为`Studio`的默认编译方式，`Gradle`已逐渐普及。我最开始是被它的多渠道打包所吸引。关于多渠道打包，请看之前我写的文章[AndroidStudio使用教程(第七弹)][1]
-
-接下来我们就系统的学习一下`Gradle`。    
-
 作用
 ---
 
-Gradle是一个开源的自动化构建工具。现在Android项目构建编译都是通过Gradle进行的，Gradle的版本在`gradle/wrapper/gradle-wrapper.properties`下:   
-```
+[Gradle](https://docs.gradle.org/7.3.3/userguide/what_is_gradle.html)是一个开源的自动化构建工具。现在Android项目构建编译都是通过Gradle进行的，Gradle的版本在`gradle/wrapper/gradle-wrapper.properties`下:   
+![image](https://github.com/CharonChui/Pictures/blob/master/gradle_version.png?raw=true)
 
-```
-
-
-使用这个工具可以完成app的编译打包等工作。
+当前Gradle版本为6.7.1。当我们执行assembleDebug/assembleRelease编译命令的时候，Gradle就会开始进行编译构建流程。
 
 
 简介
 ---
 
-[Gradle](https://gradle.org/releases/)是以`Groovy`语言为基础，面向`Java`应用为主。基于`DSL(Domain Specific Language)`语法的自动化构建工具。
+[Gradle](https://gradle.org/releases/)是以`Groovy`语言为基础，面向`Java`应用为主。       
+基于`DSL(Domain Specific Language)`语法的自动化构建工具。
 
 `Gradle`集合了`Ant`的灵活性和强大功能，同时也集合了`Maven`的依赖管理和约定，从而创造了一个更有效的构建方式。凭借`Groovy`的`DSL`和创新打包方式，`Gradle`提供了一个可声明的方式，并在合理默认值的基础上描述所有类型的构建。 `Gradle`目前已被选作许多开源项目的构建系统。
 
-[Groovy](http://www.groovy-lang.org/api.html)基于Java并拓展了Java。  Java程序员可以无缝切换到使用Groovy开发程序。Groovy说白了就是把写Java程序变得像写脚本一样简单。写完就可以执行，Groovy内部会将其编译成Javaclass然后启动虚拟机来执行。当然，这些底层的渣活不需要你管。*实际上，由于Groovy Code在真正执行的时候已经变成了Java字节码，所以JVM根本不知道自己运行的是Groovy代码*。
+[Groovy](http://www.groovy-lang.org/api.html)基于Java并拓展了Java。       
+Java程序员可以无缝切换到使用Groovy开发程序。Groovy说白了就是把写Java程序变得像写脚本一样简单。写完就可以执行，Groovy内部会将其编译成Javaclass然后启动虚拟机来执行。      
+当然，这些底层的渣活不需要你管。实际上，由于Groovy Code在真正执行的时候已经变成了Java字节码，所以JVM根本不知道自己运行的是Groovy代码。    
+
 
 因为`Gradle`是基于`DSL`语法的，如果想看到`build.gradle`文件中全部可以选项的配置，可以看这里
 [DSL Reference](http://google.github.io/android-gradle-dsl/current/)
@@ -34,15 +30,61 @@ Gradle是一个开源的自动化构建工具。现在Android项目构建编译
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_build_process.png?raw=true)
 
+### Gradle的生命周期
+
+1. Initialization：初始化阶段     
+    - 解析整个工程中所有的Project，构建所有Project对应的project对象。     
+    - 初始化阶段执行项目目录下的settings.gradle脚本，用于判断哪些项目需要被构建，并且为对应项目创建Project对象。    
+
+2. Configuration配置阶段       
+    - 解析所有的project对象中的Task，构建所有Task的括扑图     
+    - 配置阶段的任务是执行各module下的build.gradle脚本，从而完成Project的配置，并且构建Task任务依赖关系图以便在执行阶段按照依赖关系执行Task。
+    - 这个阶段Gradle会拉取remote repo的依赖(如果本地之前没有下载过依赖的话)   
+3. Execution执行阶段     
+    执行具体的task以及其依赖的task
+4. Build Finished
+
+
+
+
+
 Gradle与Android Studio的关系
 ---
 
 Gradle跟Android Studio其实没有关系，但是Gradle官方还是很看重Android开发的，Google在推出AS的时候选中了Gradle作为构建工具，为了支持Gradle
-能在AS上使用，Google做了个AS的插件叫Android Gradle Plugin，所以我们能在AS上使用Gradle完全是因为这个插件的原因。在项目的根目录有个build.gradle文件，里面有这么一句代码:  
+能在AS上使用，Google做了个AS的插件叫Android Gradle Plugin，所以我们能在AS上使用Gradle完全是因为这个插件的原因。
+
+### AGP
+AGP即Android Gradle Plugin，主要用于管理Android编译相关的Gradle插件集合，包括javac，kotlinc，aapt打包资源，D8/R8等都在AGP中。   
+
+AGP的版本是在根目录的build.gradle中配置的:   
+```
+dependencies {
+        classpath 'com.android.tools.build:gradle:4.2.1'
+...
+}
+```
+
+### AGP与Gradle的区别与联系
+
+Gradle是构建工具，而AGP是管理Android构建的插件。可以理解为AGP是Gradle构建流程中重要的一环。    
+
+虽然AGP和Gradle不是一个纬度的事情，但是两者也在一定程度上有所关联：两者的版本号必须匹配上: https://developer.android.com/build/releases/gradle-plugin?hl=zh-cn#updating-gradle
+
+
+![image](https://github.com/CharonChui/Pictures/blob/master/agp_gradle_version.png?raw=true)
+
+
+既然Android编译是通过AGP实现的，AGP就是Gradle的插件，那么这个插件是什么时候被apply的内？     
+因为一个插件如果没有apply的话，那么压根不会执行的。 
 ```
-classpath 'com.android.tools.build:gradle:2.1.2'
+plugins {
+    id 'com.android.application'
+    id 'kotlin-android'
+    id 'kotlin-kapt'
+}
 ```
-这个就是依赖gradle插件的代码，后面的版本号代表的是android gradle plugin的版本，而不是Gradle的版本，这个是Google定的，跟Gradle官方没关系。
+这就是AGP被apply的地方，也是区分一个module究竟是被打包成app还是一个library的地址。 
 
 
 

From 26bdff70b33f399e19c0c1bfb562b7a4a0a50252 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Tue, 9 Apr 2024 19:51:26 +0800
Subject: [PATCH 154/213] update

---
 AdavancedPart/AOP.md                          |  37 +++++++++
 ...71\346\241\210\350\257\246\350\247\243.md" |   2 +-
 .../Gradle\344\270\223\351\242\230.md"        |   7 +-
 ....8.Kotlin_\345\215\217\347\250\213.md.swp" | Bin 0 -> 65536 bytes
 ...&\347\261\273&\346\216\245\345\217\243.md" |  14 ++++
 .../8.Kotlin_\345\215\217\347\250\213.md"     |  78 +++++++++++-------
 README.md                                     |   3 +
 .../ARouter\350\247\243\346\236\220.md"       |  55 ++++++++++++
 ...00\201MediaCodec\343\200\201MediaMuxer.md" |  35 ++++++++
 .../MediaMetadataRetriever.md"                |  33 ++++++++
 10 files changed, 230 insertions(+), 34 deletions(-)
 create mode 100644 "KotlinCourse/.8.Kotlin_\345\215\217\347\250\213.md.swp"
 create mode 100644 "SourceAnalysis/ARouter\350\247\243\346\236\220.md"
 create mode 100644 "VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/MediaMetadataRetriever.md"

diff --git a/AdavancedPart/AOP.md b/AdavancedPart/AOP.md
index 3bcc633b..53c518aa 100644
--- a/AdavancedPart/AOP.md
+++ b/AdavancedPart/AOP.md
@@ -11,4 +11,41 @@ AOP(Aspect Oriented Programing),面向切面编程。
 而AOP，就是将各个模块中的通用逻辑抽离出来。
 我们将这些逻辑视为Aspect(切面)，然后动态地把代码插入到类的指定方法、指定位置中。 
 
+一句话概括: 在运行时，动态的将代码切入到类的指定方法、指定位置上的编程思想就是面相切面的编程。 
+
+
+一般而言，我们管切入到指定类指定方法的代码片段称为切面，而切入到哪些类、哪些方法则叫切入点。有了AOP，我们就可以把几个类共有的代码，抽取到一个切片中，等到需要时再切入对象中去，从而改变其原有的行为。
+
+
+### AOP的实现方式
+
+#### 静态AOP
+
+在编译器，切面直接以字节码的形式编译到目标字节码文件中。
+
+1. AspectJ      
+AspectJ属于静态AOP，它是在编译时进行增强，会在编译时期将AOP逻辑织入到代码中。
+
+由于是在编译器织入，所以它的优点是不影响运行时性能，缺点是不够灵活。
+
+2. AbstractProcessor     
+自定义一个AbstractProcessor，在编译期去解析编译的类，并且根据需求生成一个实现了特定接口的子类(代理类)
+
+#### 动态AOP
+1. JDK动态代理    
+通过实现InvocationHandler接口，可以实现对一个类的动态代理，通过动态代理可以生成代理类，从而在代理类方法中，在执行被代理类方法前后，添加自己的实现内容，从而实现AOP。
+
+2. 动态字节码生成    
+在运行期，目标类加载后，动态构建字节码文件生成目标类的子类，将切面逻辑加入到子类中，没有接口也可以织入，但扩展类的实例方法为final时，则无法进行织入。比如Cglib
+
+CGLIB是一个功能强大，高性能的代码生成包。它为没有实现接口的类提供代理，为JDK的动态代理提供了很好的补充。通常可以使用Java的动态代理创建代理，但当要代理的类没有实现接口或者为了更好的性能，CGLIB是一个好的选择。
+
+3. 自定义类加载器    
+在运行期，目标加载前，将切面逻辑加到目标字节码里。如：Javassist
+
+Javassist是可以动态编辑Java字节码的类库。它可以在Java程序运行时定义一个新的类，并加载到JVM中；还可以在JVM加载时修改一个类文件。
+
+4. ASM    
+ASM可以在编译期直接修改编译出的字节码文件，也可以像Javassit一样，在运行期，类文件加载前，去修改字节码。
+
 
diff --git "a/AdavancedPart/\345\261\217\345\271\225\351\200\202\351\205\215\344\271\213\347\231\276\345\210\206\346\257\224\346\226\271\346\241\210\350\257\246\350\247\243.md" "b/AdavancedPart/\345\261\217\345\271\225\351\200\202\351\205\215\344\271\213\347\231\276\345\210\206\346\257\224\346\226\271\346\241\210\350\257\246\350\247\243.md"
index a64d0fe2..e268531a 100644
--- "a/AdavancedPart/\345\261\217\345\271\225\351\200\202\351\205\215\344\271\213\347\231\276\345\210\206\346\257\224\346\226\271\346\241\210\350\257\246\350\247\243.md"
+++ "b/AdavancedPart/\345\261\217\345\271\225\351\200\202\351\205\215\344\271\213\347\231\276\345\210\206\346\257\224\346\226\271\346\241\210\350\257\246\350\247\243.md"
@@ -557,4 +557,4 @@ public void restoreLayoutParams(ViewGroup.LayoutParams params) {
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/Gradle&Maven/Gradle\344\270\223\351\242\230.md" "b/Gradle&Maven/Gradle\344\270\223\351\242\230.md"
index 5968cbbe..67820a04 100644
--- "a/Gradle&Maven/Gradle\344\270\223\351\242\230.md"
+++ "b/Gradle&Maven/Gradle\344\270\223\351\242\230.md"
@@ -4,12 +4,17 @@ Gradle专题
 作用
 ---
 
-[Gradle](https://docs.gradle.org/7.3.3/userguide/what_is_gradle.html)是一个开源的自动化构建工具。现在Android项目构建编译都是通过Gradle进行的，Gradle的版本在`gradle/wrapper/gradle-wrapper.properties`下:   
+[Gradle](https://docs.gradle.org/7.3.3/userguide/what_is_gradle.html)是一个开源的自动化构建工具。现在Android项目构建编译都是通过Gradle进行的。
+
+Gradle的版本在`gradle/wrapper/gradle-wrapper.properties`下:   
 ![image](https://github.com/CharonChui/Pictures/blob/master/gradle_version.png?raw=true)
 
 当前Gradle版本为6.7.1。当我们执行assembleDebug/assembleRelease编译命令的时候，Gradle就会开始进行编译构建流程。
 
 
+gradle-wrapper是对Gradle的一层包装，便于在团队开发过程中统一Gradle构建的版本号，这样大家都可以使用统一的Gradle版本进行构建。 
+里面的distributionUrl属性是用于配置Gradle发行版压缩包的下载地址。    
+
 简介
 ---
 
diff --git "a/KotlinCourse/.8.Kotlin_\345\215\217\347\250\213.md.swp" "b/KotlinCourse/.8.Kotlin_\345\215\217\347\250\213.md.swp"
new file mode 100644
index 0000000000000000000000000000000000000000..996ab1630d5f280941394ce9a4cbef5c514922e6
GIT binary patch
literal 65536
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

literal 0
HcmV?d00001

diff --git "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md" "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
index 6128245e..5e1b19fa 100644
--- "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
+++ "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
@@ -461,6 +461,20 @@ private var lazyValue: Fragment? = null
 
 当您稍后需要在代码中初始化var时，请选择lateinit，它将被重新分配。当您想要初始化一个val值一次时，特别是当初始化的计算量很大时，请选择by lazy。
 
+```kotlin
+val name: String by lazy {getName()}
+```
+这样，当第一次使用name引用时，getName()函数只会被调用一次。此外，还可以使用函数引用代替lambda表达式:   
+```kotlin
+val name: String by lazy(::getName)
+
+fun getName() : String {
+    println("computing name")
+    return "Mockey"
+}
+```
+
+
 
 ## 类的定义:使用`class`关键字
 
diff --git "a/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md" "b/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
index b1e79261..60f01257 100644
--- "a/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
+++ "b/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
@@ -7,15 +7,22 @@ Kotlin引入了协程（Coroutine）来支持更好的异步操作，利用它
 
 ## 起源
 
-协程是一个无优先级的子程序调用组件，允许子程序在特定的地方挂起恢复。线程包含于进程，协程包含于线程。只要内存足够，
-一个线程中可以有任意多个协程，但某一时刻只能有一个协程在运行，多个协程分享该线程分配到的计算机资源。
-
 线程是由操作系统来进行调度的，当操作系统切换线程的时候，会产生一定的消耗。而协程不一样，协程是包含于线程的，也就是说协程
 是工作在线程之上的，协程的切换可以由程序自己来控制，不需要操作系统进行调度。这样的话就大大降低了开销。
 
 
 
-协程就像一个轻量级的线程在幕后，启动协程就像启动一个单独的执行线程。线程在其他语言中很常见，例如Java，协程和线程可以并行运行，并互相通信。然而，不同点在于使用协程比使用线程更加高效。在性能方面，启动一个线程并使其保持运行是非常昂贵的。处理器通常只能同时运行有限数量的线程，并且运行尽可能少的线程会更高效。而另一方面，协程默认运行在共享的线程池中，同一个线程可以运行多个协程。由于使用的线程较少，当你想要运行异步任务时，使用协程会更加高效。
+协程就像一个轻量级的线程在幕后，启动协程就像启动一个单独的执行线程。线程在其他语言中很常见，例如Java，协程和线程可以并行运行，并互相通信。然而，不同点在于使用协程比使用线程更加高效。在性能方面，启动一个线程并使其保持运行是非常昂贵的。    
+
+处理器通常只能同时运行有限数量的线程，并且运行尽可能少的线程会更高效。     
+
+而另一方面，协程默认运行在共享的线程池中，同一个线程可以运行多个协程。由于使用的线程较少，当你想要运行异步任务时，使用协程会更加高效。
+
+**也就是说本质上Kotlin协程就是创建了一个可以复用的线程池，并且协程的delay是一个特殊的挂起函数，它不会造成线程堵塞，但是会挂起协程，并且只能在协程中使用。**    
+
+协程是语言层面的东西，线程是系统层面的东西。    
+协程就是一段代码块，既然是代码那就离不开CPU的执行，而CPU调度的基本单位是线程。    
+
 
 ## 进程、线程、协程
 进程：一段程序的执行过程，资源分配和调度的基本单位，有其独立地址空间，互相之间不发生干扰
@@ -33,7 +40,15 @@ CPU增加内存管理单元，进行虚拟地址和物理地址的转换
 
 进程是一个实体，包括程序代码以及其相关资源(内存，I/O，文件等)，可被操作系统调度。但想一边操作I/O进行输入输出，一边想进行加减计算，就得两个进程，这样写代码，内存就爆表了。于是又想着能否有一轻量级进程呢，只执行程序，不需要独立的内存，I/O等资源，而是共享已有资源，于是产生了线程。
 
-一个进程可以跑很多个线程处理并发，但是线程进行切换的时候，操作系统会产生中断，线程会切换到相应的内核态，并进行上下文的保存，这个过程不受上层控制，是操作系统进行管理。然而内核态线程会产生性能消耗，因此线程过多，并不一定提升程序执行的效率。正是由于1.线程的调度不能精确控制；2.线程的切换会产生性能消耗。协程出现了。
+一个进程可以跑很多个线程处理并发，但是线程进行切换的时候，操作系统会产生中断，线程会切换到相应的内核态，并进行上下文的保存，这个过程不受上层控制，是操作系统进行管理。    
+然而内核态线程会产生性能消耗，因此线程过多，并不一定提升程序执行的效率。    
+
+正是由于:      
+
+1. 线程的调度不能精确控制；
+2. 线程的切换会产生性能消耗。     
+
+协程出现了。
 
 协程: 
 
@@ -43,17 +58,30 @@ CPU增加内存管理单元，进行虚拟地址和物理地址的转换
 4. 协程是非抢占式调度，当前协程切换到其他协程是由自己控制；线程则是时间片用完抢占时间片调度
 
 优点:   
+
 1. 用户态，语言级别
 2. 无切换性能消耗
 3. 非抢占式
 4. 同步代码思维
 5. 减少同步锁
+
 缺点:  
+
 1. 注意全局变量
 2. 阻塞操作会导致整个线程被阻塞
 
 
-用一句话概括Kotlin Couroutine的特点即是"以同步之名，行异步之实".
+
+简单地讲，Kotlin 的协程就是一个封装在线程上面的线程框架。
+
+它有两个非常关键的亮点：
+
+- 耗时函数自动后台，从而提高性能；
+- 线程的「自动切回」
+
+所以，Kotlin 的协程在 Android 开发上的核心好处就是：消除回调地域。
+
+
 ## 使用
 
 如需在 Android 项目中使用协程，请将以下依赖项添加到应用的build.gradle文件中：
@@ -400,7 +428,6 @@ main: Now I can quit.
 对于回调式的写法，如果并发场景再复杂一些，代码的嵌套可能会更多，这样的话维护起来就非常麻烦。但如果你使用了 Kotlin 协程，多层网络请求只需要这么写：
 
 ```
-🏝️
 coroutineScope.launch(Dispatchers.Main) {       // 开始协程：主线程
     val token = api.getToken()                  // 网络请求：IO 线程
     val user = api.getUser(token)               // 网络请求：IO 线程
@@ -413,8 +440,6 @@ coroutineScope.launch(Dispatchers.Main) {       // 开始协程：主线程
 协程最简单的使用方法，其实在前面章节就已经看到了。我们可以通过一个 `launch` 函数实现线程切换的功能：
 
 ```
-🏝️
-//               👇
 coroutineScope.launch(Dispatchers.IO) {
     ...
 }
@@ -426,24 +451,20 @@ coroutineScope.launch(Dispatchers.IO) {
 所以，什么时候用协程？当你需要切线程或者指定线程的时候。你要在后台执行任务？切！
 
 ```
-🏝️
 launch(Dispatchers.IO) {
     val image = getImage(imageId)
 }
-复制代码
 ```
 
 然后需要在前台更新界面？再切！
 
 ```
-🏝️
 coroutineScope.launch(Dispatchers.IO) {
     val image = getImage(imageId)
     launch(Dispatch.Main) {
         avatarIv.setImageBitmap(image)
     }
 }
-复制代码
 ```
 
 好像有点不对劲？这不还是有嵌套嘛。
@@ -451,20 +472,17 @@ coroutineScope.launch(Dispatchers.IO) {
 如果只是使用 `launch` 函数，协程并不能比线程做更多的事。不过协程中却有一个很实用的函数：`withContext` 。这个函数可以切换到指定的线程，并在闭包内的逻辑执行结束之后，自动把线程切回去继续执行。那么可以将上面的代码写成这样：
 
 ```
-🏝️
 coroutineScope.launch(Dispatchers.Main) {      // 👈 在 UI 线程开始
     val image = withContext(Dispatchers.IO) {  // 👈 切换到 IO 线程，并在执行完成后切回 UI 线程
         getImage(imageId)                      // 👈 将会运行在 IO 线程
     }
     avatarIv.setImageBitmap(image)             // 👈 回到 UI 线程更新 UI
 } 
-复制代码
 ```
 
 这种写法看上去好像和刚才那种区别不大，但如果你需要频繁地进行线程切换，这种写法的优势就会体现出来。可以参考下面的对比：
 
 ```
-🏝️
 // 第一种写法
 coroutineScope.launch(Dispachers.IO) {
     ...
@@ -491,13 +509,11 @@ coroutineScope.launch(Dispachers.Main) {
     }
     ...
 }
-复制代码
 ```
 
 由于可以"自动切回来"，消除了并发代码在协作时的嵌套。由于消除了嵌套关系，我们甚至可以把 `withContext` 放进一个单独的函数里面：
 
 ```
-🏝️
 launch(Dispachers.Main) {              // 👈 在 UI 线程开始
     val image = getImage(imageId)
     avatarIv.setImageBitmap(image)     // 👈 执行结束后，自动切换回 UI 线程
@@ -506,7 +522,6 @@ launch(Dispachers.Main) {              // 👈 在 UI 线程开始
 fun getImage(imageId: Int) = withContext(Dispatchers.IO) {
     ...
 }
-复制代码
 ```
 
 这就是之前说的「用同步的方式写异步的代码」了。
@@ -514,22 +529,14 @@ fun getImage(imageId: Int) = withContext(Dispatchers.IO) {
 不过如果只是这样写，编译器是会报错的：
 
 ```
-🏝️
 fun getImage(imageId: Int) = withContext(Dispatchers.IO) {
     // IDE 报错 Suspend function'withContext' should be called only from a coroutine or another suspend funcion
 }
-复制代码
 ```
 
 意思是说，`withContext` 是一个 `suspend` 函数，它需要在协程或者是另一个 `suspend` 函数中调用。
 
 
-
-
-
-
-
-
 #### 挂起函数
 
 当我们调用标记有特殊修饰符`suspend`的函数时，会发生挂起:    
@@ -539,9 +546,13 @@ suspend fun doSomething(foo: Foo): Bar {
     ……
 }
 ```
-这样的函数称为挂起函数，因为调用它们可能挂起协程(如果相关调用的结果已经可用，库可以决定继续进行而不挂起)。挂起函数能够以与普通函数相同的方式
-获取参数和返回值，但它们只能从协程和其他挂起函数中调用。事实上，要启动协程，
-必须至少有一个挂起函数，它通常是匿名的(即它是一个挂起`lambda`表达式)。让我们来看一个例子，一个简化的`async()`函数
+这样的函数称为挂起函数，因为调用它们可能挂起协程(如果相关调用的结果已经可用，库可以决定继续进行而不挂起)。
+
+挂起函数能够以与普通函数相同的方式获取参数和返回值，但它们只能从协程和其他挂起函数中调用。
+
+事实上，要启动协程，必须至少有一个挂起函数，它通常是匿名的(即它是一个挂起`lambda`表达式)。
+
+让我们来看一个例子，一个简化的`async()`函数
 (源自`kotlinx.coroutines`库):    
 
 ```kotlin
@@ -558,7 +569,8 @@ async {
 }
 ```
 
-`await()`可以是一个挂起函数(因此也可以在一个`async {}`块中调用)，该函数挂起一个协程，直到一些计算完成并返回其结果:   
+`await()`可以是一个挂起函数(因此也可以在一个`async {}`块中调用)，该函数挂起一个协程，直到一些计算完成并返回其结果:  
+ 
 ```kotlin
 async {
     ……
@@ -569,13 +581,15 @@ async {
 ```
 
 
-请注意，挂起函数`await()`和`doSomething()`不能在像`main()`这样的普通函数中调用:    
+请注意，挂起函数`await()`和`doSomething()`不能在像`main()`这样的普通函数中调用:   
+ 
 ```kotlin
 fun main(args: Array<String>) {
     doSomething() // 错误：挂起函数从非协程上下文调用
 }
 ```
 还要注意的是，挂起函数可以是虚拟的，当覆盖它们时，必须指定`suspend`修饰符:    
+
 ```kotlin
 interface Base {
     suspend fun foo()
diff --git a/README.md b/README.md
index 5f20491c..234020ac 100644
--- a/README.md
+++ b/README.md
@@ -58,6 +58,7 @@ Android学习笔记
         - [1.音视频基础知识][328]
         - [2.系统播放器MediaPlayer][329]
         - [11.播放器组件封装][330]
+        - [MediaMetadataRetriever][344]
     - [DNS及HTTPDNS][23]
     - [流媒体协议][224]
         - [流媒体协议][246]
@@ -721,6 +722,8 @@ Android学习笔记
 [341]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E8%A7%86%E9%A2%91%E5%B0%81%E8%A3%85%E6%A0%BC%E5%BC%8F/AVI.md "AVI"
 [342]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/OpenCV "OpenCV"
 [343]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenCV/1.OpenCV%E7%AE%80%E4%BB%8B.md "1.OpenCV简介"
+[344]:     "MediaMetadataRetriever"
+
 
 
 Developed By
diff --git "a/SourceAnalysis/ARouter\350\247\243\346\236\220.md" "b/SourceAnalysis/ARouter\350\247\243\346\236\220.md"
new file mode 100644
index 00000000..3468f729
--- /dev/null
+++ "b/SourceAnalysis/ARouter\350\247\243\346\236\220.md"
@@ -0,0 +1,55 @@
+# ARouter解析
+
+[ARouter](https://github.com/alibaba/ARouter)
+
+> 一个用于帮助 Android App 进行组件化改造的框架 —— 支持模块间的路由、通信、解耦
+
+简单的说: 它是一个路由系统 ——— 给无依赖的组件提供通信和路由的能力。
+
+举个例子： 
+你过节了你想写一个明信片递给远方的朋友，那你就需要通过邮局(ARoter)来把明信片派送给你的朋友(你和你的朋友相当于两个组件)。
+
+使用ARouter在进行Activity跳转非常简单:    
+
+- 初始化ARouter  `ARouter.init(mApplication); // 尽可能早，推荐在Application中初始化`
+- 添加注解@Route  
+	```java
+	// 在支持路由的页面上添加注解(必选)
+	// 这里的路径需要注意的是至少需要有两级，/xx/xx
+	@Route(path = "/test/activity")
+	public class YourActivity extend Activity {
+	    ...
+	}
+	```
+- 发起路由  `ARouter.getInstance().build("/test/activity").navigation();`
+
+
+
+ARouter框架能将多个服务提供者隔离，减少相互之间的依赖。其实现的流程和我们平常的快递物流管理很类似，每一个具体的快递包裹就是一个独立的服务提供者（IProvider），每一个快递信息单就是一个RouteMeta对象，客户端就是快递的接收方，而使用@Route注解中的path就是快递单号。在初始化流程中，主要完成的工作就是将所有注册的快递信息表都在物流中心（LogisticsCenter）注册，并将数据存储到数据仓库中（Warehouse）。
+
+作者：魔焰之
+链接：https://www.jianshu.com/p/11006054f156
+来源：简书
+著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/MediaExtractor\343\200\201MediaCodec\343\200\201MediaMuxer.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/MediaExtractor\343\200\201MediaCodec\343\200\201MediaMuxer.md"
index e69de29b..d2d01f24 100644
--- "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/MediaExtractor\343\200\201MediaCodec\343\200\201MediaMuxer.md"
+++ "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/MediaExtractor\343\200\201MediaCodec\343\200\201MediaMuxer.md"
@@ -0,0 +1,35 @@
+# MediaExtractor、MediaCodec、MediaMuxer
+
+
+## MediaExtractor
+
+MediaExtractor是一个Android系统用于从多媒体文件中提取音频和视频数据的类。   
+
+它可以从本地文件或网络流中读取音频和视频数据，并将其解码为原始的音频和视频帧。它的主要功能就是解封装，也就是从媒体文件中提取出原始的音频和视频数据流。这些数据流可以被送入解码器进行解码，然后进行播放或者其他处理。      
+
+MediaExtractor可以用于开发音视频播放器、视频编辑器、音频处理器等应用程序。
+
+
+## MediaMuxter
+
+MediaMuxter是Android系统提供的一个用于混合音频和视频数据的API。    
+
+它可以将音频和视频的原始数据流混合封装成媒体文件，例如MP4、WebM等。    
+
+MediaMuxter通常与MediaExtractor一起使用，MediaExtractor用于从媒体文件中提取音频和视频数据，MediaMuxter用于将这些数据混合成新的媒体文件。   
+
+简单说就是: MediaExtractor提供了解封装的能力，而MediaMuxer提供了视频封装的能力。   
+
+
+## MediaCodec
+
+MediaCodec是Android提供的用于对音视频进行编码的类，是Android Media基础框架的一部分，一般和MediaExtractor、MediaMuxer、Surface和AudioTrack一起使用。 
+
+
+
+
+MediaExtractor仅仅是解封装数据，不会对数据进行解码。要对媒体数据进行解码，需要使用MediaCodec类。    
+
+而且MediaExtractor只能解封装媒体文件中的音视频等媒体轨道，而不能解析整个媒体文件的结构。如果需要解析整个媒体文件的结构，需要使用其他库或框架。   
+
+ 
diff --git "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/MediaMetadataRetriever.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/MediaMetadataRetriever.md"
new file mode 100644
index 00000000..a57255ab
--- /dev/null
+++ "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/MediaMetadataRetriever.md"
@@ -0,0 +1,33 @@
+# MediaMetadataRetriever
+
+MediaMetadataRetriever是Android中用于从媒体文件中提取元数据的类，可以获取音频、视频和图片文件的各种信息，例如时长、标题、封面等。
+
+```java
+MediaMetadataRetriever mRetriever = new MediaMetadataRetriever();
+
+mRetriever.setDataSource(mContext, mVideoUri);
+```
+
+## 获取元数据
+
+// 获取歌曲标题
+`mRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_TITLE);`
+
+根据key的不同还可以是时长、帧率、分辨率等。
+
+## 获取缩略图
+
+`public Bitmap getFrameAtTime(long timeUs, int option)`
+用于获取音视频文件中的一帧画面，可以用于实现缩略图、视频预览等功能。 
+
+- timeUs:是获取画面对应的时间戳，单位为微妙
+- option:可以设置是获取离指定时间戳最近的一帧画面或者事最近的关键帧画面等。
+
+## 获取专辑封面图
+
+```java
+byte[] bytes = mRetriever.getEmbeddedPicture();
+Bitmap bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length); 
+```
+需要注意的是，MediaMetadataRetriever只能用于读取已经完成的音视频文件，无法用于实时处理音视频数据流。
+

From 33e2505074417bad384f97ccff56bb03d5b501bd Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 11 Apr 2024 10:57:00 +0800
Subject: [PATCH 155/213] update kotlin part

---
 .../12.Navigation\347\256\200\344\273\213.md" |  28 +++-
 .../4.ViewModel\347\256\200\344\273\213.md"   |   5 +
 ....8.Kotlin_\345\215\217\347\250\213.md.swp" | Bin 65536 -> 0 bytes
 ...&\347\261\273&\346\216\245\345\217\243.md" | 139 ++++++++++++++++++
 ...2\344\270\276&\345\247\224\346\211\230.md" |  63 +++++++-
 ...5\345\260\204&\346\211\251\345\261\225.md" |   8 +
 ...10\346\201\257\346\234\272\345\210\266.md" |   5 +
 README.md                                     |   2 +-
 8 files changed, 241 insertions(+), 9 deletions(-)
 delete mode 100644 "KotlinCourse/.8.Kotlin_\345\215\217\347\250\213.md.swp"

diff --git "a/Jetpack/architecture/12.Navigation\347\256\200\344\273\213.md" "b/Jetpack/architecture/12.Navigation\347\256\200\344\273\213.md"
index dac4d75d..38c42a53 100644
--- "a/Jetpack/architecture/12.Navigation\347\256\200\344\273\213.md"
+++ "b/Jetpack/architecture/12.Navigation\347\256\200\344\273\213.md"
@@ -4,6 +4,11 @@
 
 为此，Jetpack提供了一个名为Navigation的组件，旨在方便我们管理页面和App bar。
 
+
+Navigation 是一个框架，用于在 Android 应用中的“目的地”之间导航，该框架提供一致的 API，无论目的地是作为 fragment、activity 还是其他组件实现。
+
+
+
 它具有以下优势: 
 
 - 可视化的页面导航图，类似于Apple Xcode中的StoryBoard，便于我们理清页面间的关系。
@@ -15,6 +20,16 @@
 
 Navigation 组件旨在用于具有一个主 Activity 和多个 Fragment 目的地的应用。主 Activity 与导航图相关联，且包含一个负责根据需要交换目的地的 `NavHostFragment`。在具有多个 Activity 目的地的应用中，每个 Activity 均拥有其自己的导航图。
 
+
+在使用过程中，我们感受到如下的优点。
+
+- 页面跳转性能更好，在单 Activity 的架构下，都是 fragment 的切换，每次 fragment 被压栈之后，View 被销毁，相比之前 Activity 跳转，更加轻量，需要的内存更少。
+- 通过 Viewmodel 进行数据共享更便捷，不需要页面之间来回传数据。
+- 统一的 Navigation API 来更精细的控制跳转逻辑。
+
+
+
+
 ## 依赖
 
 如果想要使用Navigation，需要现在build.gradle文件中添加以下依赖: 
@@ -51,17 +66,20 @@ dependencies {
 
 导航组件由以下三个关键部分组成：
 
-1. Navigation Graph
+1. Navigation Graph ： 图表
 
+    一种数据结果，用于定义应用中的所有导航目的地以及它们如何连接在一起。
     在一个集中位置包含所有导航相关信息的 XML 资源。这包括应用内所有单个内容区域（称为*目标*）以及用户可以通过应用获取的可能路径。
 
-2. NavHost
+
+2. NavHost ： 主机
 
     显示导航图中目标的空白容器。导航组件包含一个默认NavHost实现 (NavHostFragment)，可显示Fragment目标。
 
-3. NavController
+3. NavController ： 控制器
 
-    在NavHost中管理应用导航的对象。当用户在整个应用中移动时，NavController会安排NavHost中目标内容的交换。
+    在NavHost中管理应用导航的对象。当用户在整个应用中移动时，NavController会安排NavHost中目标内容的交换。     
+    该控制器提供了一些方法，可用于在目的地之间导航、处理深层链接、管理返回堆栈等。   
 
 在应用中导航时，您告诉NavController，您想沿导航图中的特定路径导航至特定目标，或直接导航至特定目标。NavController便会在NavHost中显示相应目标。
 
@@ -476,7 +494,9 @@ override fun onCreate(savedInstanceState: Bundle?) {
 
 ```
 
+### 参考
 
+https://mp.weixin.qq.com/s?src=11&timestamp=1712714064&ver=5191&signature=JTMgHGLtMGW*NoSWSrLNVuGzs-KEEDznO-ja7*X*KumZMFAuIRl7WbPYT1gG7AX810nUx6Ftb6nm6Ao92M*GzojPfqBUo1wOFc0gMs1mseTLkUWZ9Q*BIW69MM7ULPDV&new=1
 
 
 - [上一篇:11.Hilt简介](https://github.com/CharonChui/AndroidNote/blob/master/Jetpack/architecture/11.Hilt%E7%AE%80%E4%BB%8B.md)         
diff --git "a/Jetpack/architecture/4.ViewModel\347\256\200\344\273\213.md" "b/Jetpack/architecture/4.ViewModel\347\256\200\344\273\213.md"
index 7c8a3198..5ec5a6bf 100644
--- "a/Jetpack/architecture/4.ViewModel\347\256\200\344\273\213.md"
+++ "b/Jetpack/architecture/4.ViewModel\347\256\200\344\273\213.md"
@@ -11,6 +11,11 @@
 
 `ViewModel`是专门用于存放应用程序页面所需的数据。ViewModel将页面所需的数据从页面中剥离出来，页面只需要处理用户交互和展示数据。
 
+
+ViewModel类是一种业务逻辑或屏幕级状态容器。     
+它用于将状态公开给界面，以及封装相关的业务逻辑。    
+它的主要优点是，它可以缓存状态，并可在配置更改后持久保留相应状态。这意味着在activity之间导航时或进行配置更改后(例如旋转屏幕时)，界面将无需重新提取数据。   
+
 Viewmodel解决两个问题: 
 
 1. 数据的变更与view隔离，也就是解耦
diff --git "a/KotlinCourse/.8.Kotlin_\345\215\217\347\250\213.md.swp" "b/KotlinCourse/.8.Kotlin_\345\215\217\347\250\213.md.swp"
deleted file mode 100644
index 996ab1630d5f280941394ce9a4cbef5c514922e6..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 65536
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

diff --git "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md" "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
index 5e1b19fa..72e4986b 100644
--- "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
+++ "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
@@ -324,10 +324,42 @@ var myProperty: String
     }
 ```
 
+自定义set和get的重点在field，field指代当前参数，类似于java的this关键字。   
+
 这意味着无论何时当你使用点操作符来获取或设置属性值时，实际上你总是调用了属性的getter或是setter。那么，为什么编译器要这么做呢？
 为属性添加getter和setter意味着有访问该属性的标准方法。getter处理获取值的所有请求，而setter处理所有属性值设置的请求。
 因此，如果你想要改变处理这些请求的方式，你可以在不破坏任何人代码的前提下进行。通过将其包装在getter和setter中来输出对属性的直接访问称为数据隐藏。
 
+
+在某些情况下，无参的函数与只读属性可互换通用。虽然语义相似，但在以下情况中，更多的是选择使用属性而不是方法。 
+
+- 不会抛出任何异常。
+- 具有O(1)的复杂度。
+- 容易计算(或者运行一次之后缓存结果)。
+- 每次调用返回同样的结果。 
+
+
+
+## 后端属性(Blocking Property)
+
+它实际上是一个隐含的对属性值的初始化声明。能有效避免空指针问题的产生。 
+
+```kotlin
+var size: Int = 2;
+private var _table: Map<toString, Int>? = null
+
+val table: Map<String, Int> 
+    get() {
+        if (_table == null) {
+            _table = HashMap()
+        }
+        return _table ?: throw AssertionError("Set to null by another thread")
+    }
+```
+
+在Java中，访问private成员变量需要通过getter和setter来实现，此处通过table来获取_table变量，优化了Java中函数调用带来的开销。  
+
+
 ## 延迟初始化
 
 在类内声明的属性必须初始化，如果设置非`null`的属性，应该将此属性在构造器内进行初始化。
@@ -475,6 +507,47 @@ fun getName() : String {
 ```
 
 
+## @操作符
+
+在Kotlin中，@操作符主要有两个作用:  
+
+- 限定this的对象类型
+```kotlin
+class User {
+    inner class State {
+        fun getUser(): User {
+            return this@User   // 返回User
+        }
+
+        fun getState(): State {
+            return this@State // 返回State
+        }
+
+    }
+}
+```
+- 作为标签使用
+当把@操作符作为标签使用时，可以跳出双层for循环和forEach函数。
+例如:   
+```kotlin
+val listA = listOf(1, 2, 3, 4, 5, 6)
+val listB = listOf(2, 3, 4, 5, 6, 7 )
+
+loop@ for(itemA in listA) {
+    var i: Int = 0
+    for (itemB in listB) {
+        i++
+        if (item > 2) {
+            break @loop  // 当itemB > 2时，跳出循环
+        }
+        println("itemB: $itemB")
+    }
+}
+```
+
+
+
+
 
 ## 类的定义:使用`class`关键字
 
@@ -630,6 +703,25 @@ class Person private constructor(name: String) {
 }
 ```
 
+
+
+```kotlin
+open class Base(p: Int)
+class Example(p: Int) : Base(p)
+```
+
+如果该类有一个主构造函数，那么其基类型可以用主构造函数的参数进行初始化。   
+如果该类没有主构造函数，那么每个次构造函数必须使用super关键字初始化其类型，或者委托给另一个构造函数初始化。如：   
+```kotlin
+class Example : View {
+    constructor(ctx: Context) : super(ctx)
+
+    constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
+}
+```
+
+
+
 #### 构造方法默认参数
 
 ```kotlin
@@ -841,6 +933,48 @@ var age = f1.component2()
 对于有些不需要toString()、equals()、hashCode()方法的类如果使用数据类就会导致多生成这些代码，所以在使用数据类的时候不要去为了简单而乱用，
 也要去想想是否需要这些方法？是否需要设计成数据类。
 
+
+#### 获取类中成员函数的对象
+
+```kotlin
+fun main(args: Array<String>) {
+    var user = User::special
+    // 调用invoke函数执行
+    user.invoke(User("Jack", 30))
+
+    // 利用反射机制获取指定方法的内容
+    var method = User::class.java.getMethod("special")
+    method.invoke(User("Tom", 20))
+}
+
+class User(val name: String, val age: Int) {
+    fun special() {
+        println("name:${name") age:${age}");
+    }
+}
+```
+
+在上面的实例中，User类还有一个special函数，使用User::special可以获取成员函数的对象，然后使用invoke函数调用special函数，以获取该函数的内容。   
+
+
+### 构造函数引用
+
+构造函数的引用和属性、方法类似，构造函数可以作用于任何函数类型的对象，该函数的对象与构造函数的参数相同，可以使用::操作符加类名的方式来引用构造函数。 
+
+```kotlin
+class Foo
+
+fun function(factory: () -> Foo) {
+    val x: Foo = factory()
+}
+
+// 使用::Foo方式调用类Foo的无参数构造函数
+fun main() {
+    function(::Foo)
+}
+```
+
+
 ## 继承
 
 在`Kotlin`中所有类都有一个共同的超类`Any`，这对于没有超类型声明的类是默认超类:   
@@ -1214,6 +1348,11 @@ val mList2 = vars(0, *myArray, 6, 7)
 ```
 
 
+在Kotlin中，方法调用也被定义为二元操作运算符，而这些方法往往可以转化为invoke函数。
+例如 a(i)方法的对应转换方法为 a.invoke(i)
+
+
+
 ## 命名风格
 
 如果拿不准的时候，默认使用`Java`的编码规范，比如:   
diff --git "a/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md" "b/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
index 9c91998e..1d1ab9da 100644
--- "a/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
+++ "b/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
@@ -132,6 +132,8 @@ class Outter{
 val outter = Outter()
 outter.Inner().execute()
 
+var v = this@Outer.testVal // 引用外部类的成员
+
 // 输出
 Inner -> execute : can read testVal=test
 ```
@@ -142,6 +144,11 @@ val outter = Outter()
 outter.Inner().execute()
 ```
 
+引用外部类中对象的方式为: var 变量名 = this@外部类名
+
+在类成员中，this指代该类的当前对象。而在扩展函数或者带接受者的函数中，this表示在点左侧传递的接收者参数。   
+
+
 #### 内部类vs嵌套类
 
 在Java中，我们通过在内部类的语法上增加一个static关键词，把它变成一个嵌套类。然而，Kotlin则是相反的思路，默认是一个嵌套类，
@@ -154,6 +161,8 @@ outter.Inner().execute()
 
 #### 匿名内部类
 
+没有名字的内部类被称为匿名内部类，使用匿名内部类必须继承一个父类或实现一个接口，匿名内部类可以简化代码编写。
+
 ```kotlin
 // 通过对象表达式来创建匿名内部类的对象，可以避免重写抽象类的子类和接口的实现类，这和Java中匿名内部类的是接口和抽象类的延伸一致。
 text.setOnClickListener(object : View.OnClickListener{
@@ -179,6 +188,16 @@ mViewPager.addOnPageChangeListener(object : ViewPager.OnPageChangeListener {
 })
 ```
 
+如果对象实例是一个函数接口，还可以使用Lambda表达式来实现。 
+```kotlin
+
+val listener = ActionListener {
+    println("clicked")
+}
+```
+
+
+
 ### 枚举
 
 与Java中的enum语法大体类似，无非多了一个class关键字，表示它是一个枚举类。
@@ -612,12 +631,16 @@ public static Instance getInstance() {
 
     具体的业务逻辑执行者
 
+
+
 ##### 类委托
 
 在委托模式中，有两个对象参与处理同一个请求，接受请求的对象将请求委托给另一个对象来处理。
 `kotlin`中的委托可以算是对委托模式的官方支持。    
 `Kotlin`直接支持委托模式，更加优雅，简洁。`Kotlin`通过关键字`by`实现委托。
 
+委托模式已被证明是类继承模式的一种很好的替代方案。
+
 我们经常会打游戏进行升级，但是有时候因为我们的水平不行，没法升到很高的级别，这就出现了很多的游戏代练，他们帮我们代打，这就是一个委托模式： 
 
 1. 定义约束类，定义具体需要委托的业务，这里的业务: 
@@ -660,6 +683,10 @@ public static Instance getInstance() {
 
 ##### 属性委托
 
+在软件的开发中，属性的getter和setter方法的代码有很多相同或相似的地方，虽然为每个类编写相同的代码是可行的，但这样会造成大量的代码冗余，而委托属性正是为解决这一问题而提出的。  
+
+属性委托是指一个类的某个属性值不是在类中直接定义，而是将其委托给一个代理类，从而实现对该类属性的统一管理。  
+
 在Kotlin中，有一些常见的属性类型，虽然我们可以在每次需要的时候手动实现他们，但是很麻烦，为了解决这些问题，Kotlin标准提供了委托属性。
 
 语法是`val/var <属性名>: <类型> by <表达式>`。在`by`后面的表达式是该委托，因为属性对应的`get()`和`set()`会被委托给它的`getValue()`
@@ -667,12 +694,15 @@ public static Instance getInstance() {
 
 ```kotlin
 class Example {
+    // 语法中，关键词by之后的表达式就是委托的类，而且属性的get()以及set()方法将被委托给这个对象的getValue()和setValue()方法。
+    // 属性委托不必实现相关接口，但必须提供getValue()方法，如果是var类型的属性，还需要提供setValue()方法。  
     var property : String by DelegateProperty()
 }
 
 class DelegateProperty {
     var temp = "old"
     // getValue和setValue方法的参数是固定的
+    // getValue和setValue方法必须用关键字operator标记 
     operator fun getValue(ref: Any?, p: KProperty<*>): String {
         return "DelegateProperty --> ${p.name} --> $temp"
     }
@@ -798,8 +828,10 @@ fun main() {
 
 
 
+### 标准委托 
 
-`Kotlin`通过属性委托的方式，为我们实现了一些常用的功能，包括:   
+
+`Kotlin`通过属性委托的方式在Kotlin标准库中内置了很多工厂方法来实现属性委托，包括:   
 
 - 延迟属性`lazy properties`
 - 可观察属性`observable properties`
@@ -810,6 +842,9 @@ fun main() {
 延迟属性我们应该不陌生，也就是通常说的懒汉，在定义的时候不进行初始化，把初始化的工作延迟到第一次调用的时候。`kotlin`中实现延迟属性很简单，
 来看一下。
 
+lazy()是一个接收Lambda表达式作为参数并返回一个Lazy<T>实例的函数，返回的实例可以作为实现延迟属性的委托。   
+也就是说，延迟属性第一次调用get()时，将会执行传递给lazy()函数的Lambda表达式并记录执行结果，后续所有对get()的调用只会返回记录的结果。   
+
 ```kotlin
 val lazyValue: String by lazy {
     Log.d(JTAG, "Just run when first being used")
@@ -892,7 +927,24 @@ fun <T> later(block: () -> T) = Later(block)
 
 ##### 可观察属性
 
-如果你要观察一个属性的变化过程，那么可以将属性委托给`Delegates.observable`, `observable`函数原型如下：
+
+所谓可观察属性(observable)，就是当属性发生变化时能自动拦截其变化，实现观察属性值变化的委托函数是Delegates.observable()。  
+
+该函数接受两个参数:   
+
+- 初始值
+- 属性值变化时间的响应器(handler)
+
+每当给属性值赋值时都会调用该响应器，该响应器主要有3个参数:   
+
+- 被赋值的属性
+- 赋值前的旧属性值
+- 赋值后的新属性值    
+
+
+如果你要观察一个属性的变化过程，那么可以将属性委托给`Delegates.observable`。
+
+ `observable`函数原型如下：
 
 ```kotlin
 public inline fun <T> observable(initialValue: T, crossinline onChange: (property: KProperty<*>, oldValue: T, newValue: T) -> Unit):
@@ -947,9 +999,10 @@ fun test(){
 
 
 
-##### map映射
+##### map委托
+
+Map委托常常用来将Map中的key-value映射到对象的属性中，这经常出现在解析JSON或者其他动态事情的应用中。 
 
-一个常见的用例是在一个映射`map`里存储属性的值。这经常出现在像解析`JSON`或者做其他“动态”事情的应用中。在这种情况下，你可以使用映射实例自身作为委托来实现委托属性。
 
 ```kotlin
 class User(val map: Map<String, Any?>) {
@@ -975,6 +1028,8 @@ class MutableUser(val map: MutableMap<String, Any?>) {
 
 
 
+委托模式是一种被广泛使用的设计模式，Kotlin的委托主要用来实现代码的重用，Kotlin默认支持委托模式，且不需任何模版方法。   
+
 
 - [上一篇:4.Kotlin_表达式&关键字](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/4.Kotlin_%E8%A1%A8%E8%BE%BE%E5%BC%8F%26%E5%85%B3%E9%94%AE%E5%AD%97.md)       
 - [下一篇:6.Kotlin_多继承问题](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/6.Kotlin_%E5%A4%9A%E7%BB%A7%E6%89%BF%E9%97%AE%E9%A2%98.md)
diff --git "a/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md" "b/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md"
index 50ff4d0a..a800a8d3 100644
--- "a/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md"
+++ "b/KotlinCourse/7.Kotlin_\346\263\250\350\247\243&\345\217\215\345\260\204&\346\211\251\345\261\225.md"
@@ -327,6 +327,8 @@ text.panddingH = 100
 
 扩展属性与扩展函数一样，其本质也是对应Java中的静态方法。由于扩展没有实际的将成员插入类中，因此对扩展属性来说幕后字段是无效的。
 
+扩展属性允许定义在类或者Kotlin文件中，但不允许定义在函数中。 因为扩展属性不能有初始化器，所以只能由显式提供的getter/setter定义，而且扩展属性只能被声明为val。
+
 
 ##### 静态扩展
 
@@ -1205,6 +1207,12 @@ class Group<T>(val name: String) {
 `KDoc`不支持`@deprecated`这个标签。作为替代，请使用`@Deprecated`注解。
 
 
+### 泛型
+
+通配符类型参数 `? extends E`表示该方法接收E类型或者E类型的一些子类型，而不仅仅是E类型本身。
+Kotlin抛弃了通配符类型这一概念，转而引入了生产者和消费者的概念，其中，生产者表示那些只能读取数据的对象，使用表达式`out T`标记。    
+消费者表示那些只能写入数据的对象，使用表达式`in T`标记。      
+为了便于理解，可以简单的将`out T`理解为`? exnteds T`，将`in T`理解为`? super T`。 
 
 
 
diff --git "a/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md" "b/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md"
index 424a31dd..b571b6f3 100644
--- "a/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md"
+++ "b/OperatingSystem/AndroidKernal/2.Android\347\272\277\347\250\213\351\227\264\351\200\232\344\277\241\344\271\213Handler\346\266\210\346\201\257\346\234\272\345\210\266.md"
@@ -544,6 +544,11 @@ public final void removeCallbacksAndMessages(@Nullable Object token) {
 
 
 
+##### postAtFrontOfQueue():将消息插入到队列头部
+
+通过调用sendMessageAtFrontOfQueue计入一个when为0的message到队列，即插入到队列的头部。可以尽量保证快速执行。
+
+
 ## MessageQueue类的常用方法
 
 MessageQueue非常重要，因为quit、next等都最终调用的是MessageQueue类: 
diff --git a/README.md b/README.md
index 234020ac..8604e003 100644
--- a/README.md
+++ b/README.md
@@ -722,7 +722,7 @@ Android学习笔记
 [341]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/%E8%A7%86%E9%A2%91%E5%B0%81%E8%A3%85%E6%A0%BC%E5%BC%8F/AVI.md "AVI"
 [342]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/OpenCV "OpenCV"
 [343]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenCV/1.OpenCV%E7%AE%80%E4%BB%8B.md "1.OpenCV简介"
-[344]:     "MediaMetadataRetriever"
+[344]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/Android%E9%9F%B3%E8%A7%86%E9%A2%91%E5%BC%80%E5%8F%91/MediaMetadataRetriever.md    "MediaMetadataRetriever"
 
 
 

From 05e352e6a78d9b555831c839eb2a9e9d0f73e237 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 11 Apr 2024 13:23:08 +0800
Subject: [PATCH 156/213] update kotlin part

---
 ...05\350\201\224\345\207\275\346\225\260.md" | 59 ++++++++++++++++++-
 .../8.Kotlin_\345\215\217\347\250\213.md"     | 16 +++++
 2 files changed, 73 insertions(+), 2 deletions(-)

diff --git "a/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md" "b/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
index 42440cd9..dba30dbf 100644
--- "a/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
+++ "b/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
@@ -3,6 +3,51 @@
 
 ## 高阶函数
 
+
+高阶函数(Higher Order Function)是一种特殊的函数，它接收函数作为参数，或者返回一个函数。     
+函数的基本格式如下:   
+
+```kotlin
+fun 高阶函数名(参数函数名: 参数函数类型): 高阶函数返回类型 {
+    // 高阶函数体
+}
+```
+
+高阶函数的一个很好的例子就是lock函数，它的参数是一个Lock类型对象和一个函数。 
+
+该函数执行时获取锁，运行函数参数，运行结束后再释放锁。  
+```kotlin
+fun <T> lock(lock: Lock, body: () -> T): T {
+    lock.lock()
+    try {
+        return body()
+    } finally {
+        lock.unlock()
+    }
+}
+```
+在这个例子中，body为函数的类型对象，该函数是一个无参函数，而且返回值类型是T。 
+
+调用lock函数时，可以传入另一个函数作为参数。  
+
+和许多编程语言类似，如果函数的最后一个参数也是函数，则该函数参数还可以定义在括号外面，如:   
+```kotlin
+val result = lock(lock, { sharedResource.operation()})
+// 等同于
+lock(lock) {
+    sharedResource.operation()
+}
+```
+
+
+高阶函数类似C语言的函数指针，它的另一个使用场景是map函数。
+
+如果函数只有一个参数，则可以忽略声明的函数参数，用it来代替。   
+
+```kotlin
+val doubled = mMap.map {it -> it * 2}
+```
+
 Kotlin天然支持了部分函数式特性。函数式语言一个典型的特征就在于函数是头等公民——我们不仅可以像类一样在底层直接定义一个函数，也可以在一个函数内部定义一个局部函数。 
 
 ```kotlin
@@ -225,7 +270,9 @@ countryApp.filterCountries(countries, {
 })
 ```
 
-这就是Lambda表达式，它与匿名函数一样，是一种函数字面量。
+这就是Lambda表达式。
+
+Lambda表达式本质上是一个匿名函数，它是一种函数字面值，即一个没有声明的函数，可以把该函数当做普通表达式进行参数传递，它可以访问自己的闭包函数。   
 
 首先来看一下Lambda的定义，如果用最直白的语言来阐述的话，Lambda就是一小段可以作为参数传递的代码。从定义上看，这个功能就很厉害了，因为正常情况下，我们向某个函数传参时只能传入变量，而借助Lambda却允许传入一小段代码。这里两次使用了“一小段代码”这种描述，那么到底多少代码才算一小段代码呢？Kotlin对此并没有进行限制，但是通常不建议在Lambda表达式中编写太长的代码，否则可能会影响代码的可读性。
 
@@ -373,7 +420,7 @@ add = { x: Int, y: Int -> x + y }
 Lambda类型也被认为是函数类型。
 
 
-当Lambda表达式的参数列表中只有一个参数时，也不必声明参数名，而是可以使用it关键字来代替.
+当Lambda表达式的参数列表中只有一个参数时，那么可以不声明唯一的参数名，而是可以使用it关键字来代替，因为Kotlin会隐含的声明一个名为it的参数.
 ```kotlin
 val list = listOf("Apple", "Bnana", "Orange", "Pear")
 val maxLengthFruit = list.maxBy {it.length}
@@ -472,6 +519,13 @@ listOf(1, 2, 3).forEach{ foo(it)() }
 
 ## 闭包
 
+
+闭包就是能够读取其他函数内部变量的函数。   
+
+它是函数内部和函数外部信息交换的桥梁。   
+
+在Kotlin中，Lambda表达式或匿名函数(局部函数、对象表达式等)都可以访问它的必报。 
+
 在Kotlin中，你会发现匿名函数体、Lambda在语法上都存在“{}"，由这对花括号包裹的代码如果访问了外部环境变量则被称为一个闭包。一个闭包可以被当做参数传递或直接使用，它可以简单的看成”访问外部环境变量的函数“。Lambda是Kotlin中最常见的闭包形式。
 
 与Java不一样的地方在于，Kotlin中的闭包不仅可以访问外部变量，还能够对其进行修改(我有点疑惑，Java为啥不能修改？下面说)，如下： 
@@ -479,6 +533,7 @@ listOf(1, 2, 3).forEach{ foo(it)() }
 ```kotlin
 var sum = 0
 listOf(1, 2, 3).filter { it > 0 }.forEach {
+    // 外部的变量，且可以修改
     sum += it
 }
 println(sum)  // 6
diff --git "a/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md" "b/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
index 60f01257..8fbfda6e 100644
--- "a/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
+++ "b/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
@@ -5,6 +5,11 @@
 
 Kotlin引入了协程（Coroutine）来支持更好的异步操作，利用它我们可以避免在异步编程中使用大量的回调，同时相比传统多线程技术，它更容易提升系统的高并发处理能力。 
 
+
+协程(coroutine)，又称微线程，是一种无优先级的子程序调度组件，由协程构建器(coroutine builder)启动。 
+
+协程本质上是一种用户态的轻量级线程
+
 ## 起源
 
 线程是由操作系统来进行调度的，当操作系统切换线程的时候，会产生一定的消耗。而协程不一样，协程是包含于线程的，也就是说协程
@@ -23,6 +28,7 @@ Kotlin引入了协程（Coroutine）来支持更好的异步操作，利用它
 协程是语言层面的东西，线程是系统层面的东西。    
 协程就是一段代码块，既然是代码那就离不开CPU的执行，而CPU调度的基本单位是线程。    
 
+可以说，只要内存足够，一个线程中可以包含任意多个协程，但某一时刻却只能有一个协程在运行，多个协程分享该线程资源。   
 
 ## 进程、线程、协程
 进程：一段程序的执行过程，资源分配和调度的基本单位，有其独立地址空间，互相之间不发生干扰
@@ -81,6 +87,16 @@ CPU增加内存管理单元，进行虚拟地址和物理地址的转换
 
 所以，Kotlin 的协程在 Android 开发上的核心好处就是：消除回调地域。
 
+线程操作需要VM或OS的支持，通过CPU调度来执行生效。   
+而协程主要通过编译技术来实现，通过参入代码来生效，不需要VM或OS的额外支持。   
+
+简单来说，协程是编译器级的，而线程是操作系统级的。   
+
+协程运行在同一个线程上，没有上下文切换。 
+和线程不同，协程有多个入口点，可以在指定的位置挂起和恢复执行，而线程通常只有一个入口点，且只能返回一次。       
+其次，协程不需要多线程的锁机制，因为协程只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不需要加锁，只需要判断状态即可，因此执行效率比多线程高很多。   
+另外，使用协程后，不再需要像异步编程时那样写很多回调函数，代码结构不再支离破碎，整个代码逻辑看上去和同步代码没有什么区别，代码结构更加优雅简洁。   
+
 
 ## 使用
 

From e7a22a35560ca71f8936d41661967a84854173ca Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Fri, 12 Apr 2024 11:10:43 +0800
Subject: [PATCH 157/213] update

---
 .../\347\256\227\346\263\225.md"                              | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\347\256\227\346\263\225.md" "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\347\256\227\346\263\225.md"
index 7c8a9a26..3347d083 100644
--- "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\347\256\227\346\263\225.md"
+++ "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\347\256\227\346\263\225.md"
@@ -29,7 +29,9 @@
 显然，由此算法时间复杂度的定义可知，我们的三个求和算法的时间复杂度分别为O(n)，O(1)，O(n²)。
 我们分别给它们取了非官方的名称，O(1)叫常数阶、O(n)叫线性阶、O(n²)叫平方阶。
 
-
+- O(1) : 操作所需的时间是常数(n个元素所需的时间与一个元素所需的时间相同)
+- O(n) : n个元素的时间是一个元素时间乘以n
+- O(n²): n个元素的时间是一个元素时间乘以n²
 
 #### 推导大O阶方法
 

From 1e85414eb8f46e746a64a44b460181c32a152147 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 17 Apr 2024 11:03:28 +0800
Subject: [PATCH 158/213] update OpenGL part

---
 .../OpenGL/1.OpenGL\347\256\200\344\273\213.md" | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
index 7578a7eb..ab8a5559 100644
--- "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -588,6 +588,23 @@ Android 通过其框架 API 和原生开发套件 (NDK) 来支持 OpenGL。
 Android 框架中有如下两个基本类，用于通过 OpenGL ES API 来创建和操控图形：`GLSurfaceView` 和 `GLSurfaceView.Renderer`。
 
 
+#### 视频数据流
+
+视频从视频文件到屏幕显示出来，Surface起到了非常重要的作用，在视频解码时，需要一个Surface作为
+已解码数据的载体，保存播放器解码后的数据。       
+
+在显示时，需要另一个Surface作为已渲染数据的载体，保存OpenGL渲染后的数据，最后通过EGL显示在屏幕上。   
+
+数据流如下图所示:   
+
+![image](https://github.com/CharonChui/Pictures/blob/master/video_display_process.webp?raw=true)
+
+- 解码器(MediaCodec或FFmpeg等)将视频文件中的视频编码数据解码成图像流放到Surface中。
+- SurfaceTexture把Surface生成的图像流，转换为纹理
+- OpenGL ES渲染纹理生成图形数据，放到GLSurfaceView中的Surface中
+- EGL从Surface中取出图形数据，显示到屏幕上
+
+
 ### 参考
 
 ---

From e853fbd2a2308deee685abd000fff5b718f5ccc0 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 18 Apr 2024 20:48:34 +0800
Subject: [PATCH 159/213] update OpenGL part

---
 .../OpenGL/1.OpenGL\347\256\200\344\273\213.md"    |  9 +++++++--
 ...262\345\231\250\350\257\255\350\250\200GLSL.md" | 13 ++++++++++++-
 .../OpenGL/9.OpenGL ES\347\272\271\347\220\206.md" | 14 ++++++++++++++
 3 files changed, 33 insertions(+), 3 deletions(-)

diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
index ab8a5559..5544fac7 100644
--- "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -340,8 +340,13 @@ glBufferData是一个专门用来把用户定义的数据复制到当前绑定
     - OpenGL允许我们同时绑定多个缓冲，只要它们是不同的缓冲类型(每一个缓冲类型类似于前面说的子集，每个VBO是一个小助理)。
 
 - 配置OpenGL如何解释这些内存            
-    通过顶点数组对象(Vertex Array Objects, VAO）来管理，数组中的每一个项都对应一个属性的解析。        
-    **注意: VAO并不保存实际数据，而是放顶点结构的定义**
+    通过顶点数组对象(Vertex Array Objects, VAO）来管理，数组中的每一个项都对应一个属性的解析。       
+
+VAO（Vertex Array Object）是指顶点数组对象，主要用于管理 VBO 或 EBO ，减少 glBindBuffer 、glEnableVertexAttribArray、 glVertexAttribPointer 这些调用操作，高效地实现在顶点数组配置之间切换。
+
+ **注意: VAO并不保存实际数据，而是放顶点结构的定义** 
+
+
 
 ![image](https://github.com/CharonChui/Pictures/blob/master/vao_vbo.jpg?raw=true)
 
diff --git "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md" "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
index 6e1414d8..e179b27b 100644
--- "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
+++ "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
@@ -140,7 +140,18 @@ precision mediump int;
 
 
 #### Uniform
-Uniform是一种从CPU中的应用向GPU中的着色器发送数据的方式，但uniform和顶点属性有些不同。     
+
+CPU在处理并行线程的时候，每个线程负责给完整图像的一部分配置颜色。    
+尽管每个线程和其他线程之间不能有数据交换，但我们能从CPU给每个线程输入数据。    
+因为显卡的架构，所有线程的输入值必须统一(uniform)，而且必须设为只读。      
+
+也就是说，每条线程接收相同的数据，并且是不可改变的数据。这些输入值叫做uniform(统一值). 
+
+按业界传统应该在uniform值的名字前加u_，这样一看便知是uniform。    
+
+Uniform是一种从CPU中的应用向GPU中的着色器发送数据的方式，但uniform和顶点属性有些不同。 
+
+你可以把uniform想象成连通CPU和GPU的许多的小桥梁。        
 
 首先，uniform是全局的(Global)。         
 全局意味着uniform变量必须在每个着色器程序对象中都是独一无二的，而且它可以被着色器程序的任意着色器在任意阶段访问。       
diff --git "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md" "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"
index 3f3fb88b..921dcbe4 100644
--- "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
+++ "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
@@ -4,6 +4,20 @@
 
 ### 纹理
 
+
+现实生活中，纹理（Texture）最通常的作用是装饰 3D 物体，它就像贴纸一样贴在物体表面，丰富了物体的表面和细节。 
+
+在 OpenGLES 开发中，纹理除了用于装饰物体表面，还可以用来作为存储数据的容器。
+
+那么在 OpenGLES 中，纹理实际上是一个可以被采样的复杂数据集合，是 GPU 的图像数据结构，纹理分为 2D 纹理、 立方图纹理和 3D 纹理。
+
+2D 纹理是 OpenGLES 中最常用和最常见的纹理形式，是一个图像数据的二维数组。纹理中的一个单独数据元素称为纹素或纹理像素。
+
+立方图纹理是一个由 6 个单独的 2D 纹理面组成的纹理。立方图纹理像素的读取通过使用一个三维坐标（s,t,r）作为纹理坐标。
+
+3D 纹理可以看作 2D 纹理作为切面的一个数组，类似于立方图纹理，使用三维坐标对其进行访问。
+
+
 在OpenGL中简单理解就是一张图片，在学习之前需要明白这几个概念，不然很容易迷糊，不知道为什么要这样去调用api，到底是什么意思.
 
 - 纹理Id:句柄，纹理的直接引用

From 7fa6227b2f8361f157b8d9e430e068a4513a194b Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 24 Apr 2024 09:45:46 +0800
Subject: [PATCH 160/213] update Kotlin part

---
 ...6\236\232\344\270\276&\345\247\224\346\211\230.md" |  5 +++++
 .../OpenGL/1.OpenGL\347\256\200\344\273\213.md"       | 11 +++++++----
 2 files changed, 12 insertions(+), 4 deletions(-)

diff --git "a/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md" "b/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
index 1d1ab9da..f3f9117d 100644
--- "a/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
+++ "b/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
@@ -155,6 +155,9 @@ outter.Inner().execute()
 必须加上inner关键字才是一个内部类，也就是说可以把静态的内部类看成嵌套类。
 
 内部类和嵌套类有明显的差别，具体体现在：
+
+- 嵌套类相当于Java中的静态内部类，不能使用外部类的this。
+- 内部类必须以inner class定义，相当于Java中的私有非静态内部类，可以访问外部类的this。
 - 内部类包含着对其外部类实例的引用，在内部类中我们可以使用外部类中的属性。而在嵌套类中不包含对其外部类实例的引用，所以它无法调用其外部类的属性。
 
 
@@ -466,6 +469,8 @@ public class Prize {
 伴生对象：“伴生”是相较于一个类而言的，意为伴随某个类的对象，它属于这个类所有，因此伴生对象跟Java中static修饰效果性质一样，
 全局只有一个单例。它需要声明在类的内部，在类被装载时会被初始化。 
 
+准确的说是Kotlin使用伴生对象来实现Java静态的效果，但不能说伴生就是静态。   
+
 现在将上面的例子改写成伴生对象的版本:   
 
 ```kotlin
diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
index 5544fac7..7f4585a1 100644
--- "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -9,9 +9,6 @@ OpenGL(Open Graphics Library开放图形库)是用于渲染2D、3D矢量图形
 
 [OpenGL官网](https://www.opengl.org/)
 
-
-OpenGL的前身是硅谷图形功能(SGI)公司为其图形工作站开发的IRIS GL,后来因为IRIS GL的移植性不好，所以在其基础上，开发出了OpenGL。
-
 OpenGL一般用于在图形工作站，PC端使用，由于性能各方面原因，在移动端使用OpenGL基本带不动。       
 为此，Khronos公司就为OpenGL提供了一个子集，OpenGL ES(OpenGL for Embedded System)。
 
@@ -181,9 +178,15 @@ OpenGL ES 3.0实现了具有可编程着色功能的图形管线，有两个规
 
 ### 依赖库
 
+OpenGL实际上并不是把图像直接绘制到计算机屏幕上，而是将之渲染到一个帧缓冲区。    
+然后由计算机来负责把帧缓冲区中的内容绘制到屏幕上的一个窗口中。有不少库都可以支持这一部分工作:     
+
+- 使用操作系统提供的窗口管理功能，比如Microsoft Windows API。但这通常不实用，因为需要很多底层的编码工作。   
+- FreeGLUT、GLOW、GLFW等库
+
+
 简要来说，GLAD、GLEW都是一个图形库，可以理解为是在显卡驱动上给渲染用户一个统一的API；   
 而GLUT、FreeGLUT、GLFW这三个是用于图形开发的辅助工具库，主要用于创建和管理OpenGL环境、操作窗口等。
-
 OpenGL只是一个标准/规范，具体的实现是由驱动开发商针对特定显卡实现的。但是在你真正能够在程序中使用OpenGL之前，你需要对他进行初始化，但是由于OpenGL是跨平台的，所以也没有一个标准的方式进行初始化。OpenGL初始化分为两个阶段：
 
 - 第一个阶段，你需要创建一个OpenGL上下文环境，这个上下文环境存储了所有与OpenGL相关的状态（OpenGL是一个状态机），上下文位于操作系统中某个进程中，一个进程可以创建多个上下文，每一个上下文都可以描绘一个不同的可视界面，就像应用程序中的窗口；简单来理解就是为了创建一个窗口；而GLUT、FreeGLUT、GLFW库就是用于干这件事的。

From 7f8971d27dff0e7ddcd1a0e62b29c29a64c6e028 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 24 Apr 2024 18:56:54 +0800
Subject: [PATCH 161/213] update OpenGL part

---
 .../OpenGL/1.OpenGL\347\256\200\344\273\213.md"    | 12 ++++++++++++
 .../2.GLSurfaceView\347\256\200\344\273\213.md"    | 14 ++++++++++++++
 2 files changed, 26 insertions(+)

diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
index 7f4585a1..75f5aaa5 100644
--- "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -53,6 +53,16 @@ Android中OpenGL ES的版本支持如下:
 - OpenGL ES 3.1 - 此 API 规范受 Android 5.0（API 级别 21）及更高版本的支持。
 
 
+OpenGL ES是一套绘制3D图形的API，OpenGL ES是和平台无关的一套API，主要是为了rendering 2D和3D图形等。    
+OpenGL就是一组函数名，并不能直接用，需要底层硬件GPU的支持。     
+
+OpenGL ES的实现有2中方式：    
+
+- 第一种：是软件实现，用cpu去实现算法模拟GPU渲染、合成工作，就是agl(libGLES_android.so)，路径是frameworks/native/opengl/libagl，即the software OpenGL ES library。  
+
+- 第二种：是硬件厂商根据自己GPU提供的实现，一般都不开放源代码，就是/vendor/lib/egl或/system/lib/egl目录下的库。   
+
+
 
 ### OpenGL状态机(State Machine)
 >>> As long as you keep in mind that OpenGL is basically one large state machine,most of its functionality will make more sense. 
@@ -488,6 +498,8 @@ GLSL(OpenGL Shading Language)是OpenGL着色语言。
   - 顶点着色器(Vertex Shader)
   - 片段着色器(Fragment Shader)
 
+通常在CPU上编译、链接成二进制数据，然后将它拷贝到GPU上运行，在GPU上运行起来的就是渲染、合成的命令。它的编译是通过OpenGL API操作的。     
+
 ### 坐标系
 
 OpenGL ES是一个3D的世界，由x、y、z坐标组成顶点坐标。采用虚拟的右手坐标。
diff --git "a/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
index fa6b2098..cea103bb 100644
--- "a/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
@@ -1,5 +1,19 @@
 ## 2.GLSurfaceView简介
 
+
+### 生产者(Surface)与消费者(SurfaceFlinger)
+
+在Android系统中，无论开发者调用什么渲染API，一切内容都会渲染到Surface上。       
+
+Surface表示缓冲区队列中的生产者，而缓冲区队列会被消费者SurfaceFlinger消耗掉。     
+
+在Android平台上创建的每个窗口都由Surface提供支持。
+用户通过在Surface这张画布上绘制生成图形数据，这些数据会被BufferQueue传输给SurfaceFlinger，所有被渲染的可见Surface都被SurfaceFlinger合成到屏幕。    
+
+
+
+
+
 Android 通过其框架 API 和原生开发套件 (NDK) 来支持 OpenGL。
 
 Android 框架中有如下两个基本类，用于通过 OpenGL ES API 来创建和操控图形：`GLSurfaceView` 和 `GLSurfaceView.Renderer`。也就是说我们想在Android中使用OpenGL ES的最简单的方法就是将我们要显示的图像渲染到GLSurfaceView上，但它只是一个展示类，至于怎么渲染到上面我们就要自己去实现GLSurfaceView.Renderer来生成我们自己的渲染器从而完成渲染操作，这里是不是感觉Android框架提供的类太少了，怎么没有GLTextureView，后面在分析完GLSurfaceView的源码后，可以直接拷贝自己去实现GLTextureView，[有关SurfaceView与TextureView的区别可以看这篇文章](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/SurfaceView%E4%B8%8ETextureView.md)。    

From 9b48142325bea5af9568f13d22d9a9f25c85e8c6 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 24 Apr 2024 19:02:12 +0800
Subject: [PATCH 162/213] update Android Framework part

---
 .../3.Android Framework\346\241\206\346\236\266.md"             | 2 ++
 1 file changed, 2 insertions(+)

diff --git "a/OperatingSystem/AndroidKernal/3.Android Framework\346\241\206\346\236\266.md" "b/OperatingSystem/AndroidKernal/3.Android Framework\346\241\206\346\236\266.md"
index d653e130..bcf041f8 100644
--- "a/OperatingSystem/AndroidKernal/3.Android Framework\346\241\206\346\236\266.md"	
+++ "b/OperatingSystem/AndroidKernal/3.Android Framework\346\241\206\346\236\266.md"	
@@ -64,6 +64,8 @@ Linux驱动和Framework相关的主要包含两部分：
 
 
 
+<img src="https://github.com/CharonChui/Pictures/blob/master/android_architecture.jpg?raw=true" width="70%" height="70%" />
+
 ## APK程序的运行过程
 
 1. 首先，ActivityThread从main()函数开始执行，调用prepareMainLooper()为UI线程创建一个消息队列(MessageQueue)。

From a7cd7835302da863234c0c8c5d99c8e271071ed8 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Fri, 26 Apr 2024 21:38:48 +0800
Subject: [PATCH 163/213] update OpenGL part

---
 .../1.OpenGL\347\256\200\344\273\213.md"      | 16 +++++-
 ...66\344\270\211\350\247\222\345\275\242.md" | 56 +++++++++++++++++++
 ...45\231\250\350\257\255\350\250\200GLSL.md" |  2 +-
 3 files changed, 71 insertions(+), 3 deletions(-)

diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
index 75f5aaa5..d2156032 100644
--- "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -175,6 +175,8 @@ OpenGL ES 3.0实现了具有可编程着色功能的图形管线，有两个规
 而顶点数据是用顶点属性(Vertex Attribute)表示的，它可以包含任何我们想用的数据，但是简单起见，我们还是假定每个顶点只由一个3D位置和一些颜色值组成的吧。
 
 
+
+
 ### 立即渲染模式(Immediate mode) && 核心模式(Core-profile)
 早期的OpenGL使用立即渲染模式（Immediate mode，也就是固定渲染管线），这个模式下绘制图形很方便。OpenGL的大多数功能都被库隐藏起来，开发者很少有控制OpenGL如何进行计算的自由。而开发者迫切希望能有更多的灵活性。随着时间推移，规范越来越灵活，开发者对绘图细节有了更多的掌控。立即渲染模式确实容易使用和理解，但是效率太低。因此从OpenGL3.2开始，规范文档开始废弃立即渲染模式，并鼓励开发者在OpenGL的核心模式(Core-profile)下进行开发，这个分支的规范完全移除了旧的特性。
 
@@ -241,6 +243,8 @@ GLFW是一个专门针对OpenGL的C语言库，它提供了一些渲染物体所
 它把一个单独的顶点作为输入。顶点着色器主要的目的是把3D坐标转为另一种3D坐标（后面会解释）从而生成每个顶点的最终位置，同时顶点着色器允许我们对顶点属性进行一些基本处理。
 
 
+所有顶点着色器的主要目标都是讲顶点发送给管线(正如之前所说的它会对每个顶点进行处理)。
+
 顶点着色器可以操作的属性有: 位置、颜色、纹理坐标，但是不能创建新的顶点。最终产生纹理坐标、颜色、点位置等信息送往后续阶段。
 
 顶点着色器会在GPU上创建内存用于存储我们的顶点数据，还要配置OpenGL如何解释这些内存，并且指定其如何发送给显卡。顶点着色器接着会处理我们在内存中指定数量的顶点。
@@ -441,9 +445,15 @@ OpenGL中最基础且唯一的多边形就是三角形，所有更复杂的图
 
 使用颜色或纹理(texture)渲染图形表面的OpenGLES代码。
 
-主要目的是计算一个像素的最终颜色。         
 
-光栅化操作构造了像素点，这个阶段就是处理这些像素点，根据自己的业务，例如高亮、饱和度调节、高斯模糊等来变化这个片元的颜色。      
+我们3D世界中的点、三角形、颜色等全都需要展现在一个2D显示器上。      
+这个2D屏幕由栅格(即矩形像素阵列)组成。当3D物体栅格化后，OpenGL会将物体中的图元(通常是三角形)转化为片段。    
+片段拥有关于像素的信息。栅格化过程确定了为了显示由3个顶点确定的三角形需要绘制的所有像素的位置。片段着色器用于为栅格化的像素指定颜色。    
+
+主要目的是计算一个像素的最终颜色。      
+所有片段着色器的目的都是给为要展示的像素赋予颜色。              
+
+光栅化操作构造了像素点(图元(点或三角形)转换成了像素的集合)，这个阶段就是处理这些像素点，根据自己的业务，例如高亮、饱和度调节、高斯模糊等来变化这个片元的颜色。      
 为组成点、直线和三角形的每个片元生成最终颜色/纹理，针对每个片元都会执行一次，一个片元是一个小的、单一颜色的长方形区域，类似于计算机屏幕上的一个像素。        
 一旦最终颜色生成，OpenGL就会把它们写到一块成为帧缓冲区的内存块中，然后Android就会把这个帧缓冲区显示到屏幕上。
 
@@ -523,6 +533,8 @@ OpenGL采用的是右手坐标，选取屏幕中心为原点，从原点到屏
 
 如果想要绘制图像，需要至少一个顶点着色器来定义一个图形顶点，以及一个片元着色器为该图形上色。这些着色器必须被编译然后再添加到一个OpenGL Program中，并利用这个Program来绘制形状。
 
+glUseProgram()用于将含有两个已编译着色器的程序载入OpenGL管线阶段(在GPU上)。   
+注意，glUseProgram()并没有运行着色器，它只是将着色器加载进硬件。   
 
 ### EGL
 
diff --git "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md" "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"
index 18119b7d..5f91fcac 100644
--- "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
@@ -1,5 +1,6 @@
 ## 5.OpenGL ES绘制三角形
 
+
 OpenGL ES的绘制需要有以下步骤:   
 
 ### 1. 顶点输入
@@ -628,6 +629,11 @@ public class TriangleRender implements GLSurfaceView.Renderer {
 - 如何将这个矩阵传递给GLSL中。(与获取顶点索引类似，可以在GLSL中声明一个mat4类型的矩阵变量，获取其索引，再传递值给它)
 
 
+## 数学概念
+
+
+
+
 
 ### 向量（Vector)
 
@@ -635,6 +641,18 @@ public class TriangleRender implements GLSurfaceView.Renderer {
 在GLSL中一个向量有最多4个分量，每个分量值都代表空间中的一个坐标，它们可以通过vec.x、vec.y、vec.z和vec.w来获取。         
 vec.w分量不是用作表达空间中的位置(因为我们处理的是3D不是4D)，而是用在所谓透视划分上。
 
+
+3D空间中的点可以通过使用形如(2, 8, −3)的符号列出x、y、z的值来表示。       
+
+不过，如果用齐次坐标—— 一种在19世纪初首次描述的表示法来表示点会更有用。      
+
+在每个点的齐次坐标有4个值，前3个值表示x、y和z，第四个值w总是非零值，通常为1。因此，我们会将之前的点表示为(2, 8, −3, 1)。
+
+用来存储齐次3D坐标的GLSL数据类型是vec4（“vec”代表向量，同时也可以用来表示点）。    
+
+
+
+
 ### 矩阵
 
 由m*n个数按照一定顺序排列成m行n列的矩形数表称为矩阵，而向量则是由n个有序数组成的数组。       
@@ -645,6 +663,44 @@ vec.w分量不是用作表达空间中的位置(因为我们处理的是3D不是
 OpenGL中使用的是列向量，如[xyzx]T，所以与矩阵相乘时，矩阵在前，向量在后，最终通过变换矩阵得到想要的向量。
 
 
+矩阵是矩形的值的阵列，它的元素通常使用下标访问。第一个下标表示行号，第二个下标表示列号，下标从0开始。我们在3D图形计算中要用到的矩阵尺寸常为4×4。    
+
+![image](https://github.com/CharonChui/Pictures/blob/master/opengl_matrix.png?raw=true)
+
+GLSL中的mat4数据类型用来存储4×4矩阵。
+
+单位矩阵中一条对角线的值为1，其余值全为0。任何点或矩阵乘单位矩阵都不会改变。在GLM中，调用构造函数glm::mat4 m(1.0f)可以在变量m中生成单位矩阵。
+
+
+
+**在图形学中，矩阵通常用来进行物体的变换。例如矩阵可以用来将点从一处移动到另一处。**
+
+
+矩阵变换:     
+
+- 平移矩阵
+- 缩放矩阵
+缩放矩阵除了放大缩小之外，还可以用来切换坐标系。       
+例如，我们可以用缩放来在给定右手坐标系的情况下确定左手坐标系中的坐标。 通过反转Z坐标就可以在右手坐标系和左手坐标系中切换。
+
+- 旋转矩阵
+
+数学家欧拉表明，围绕任何轴的旋转都可以表示为绕x轴、y轴、z轴旋转的组合。围绕这3个轴的旋转角度被称为欧拉角。       
+这个被称为欧拉定理的发现对我们很有用，因为对于每个坐标轴的旋转可以用矩阵变换来表示。    
+
+实践中，当在3D空间中旋转轴不穿过原点时，物体使用欧拉角进行旋转需要几个额外的步骤，一般有：    
+
+1. 平移旋转轴以使它经过原点
+2. 绕x轴、y轴、z轴旋转适当的欧拉角
+3. 服用步骤1中的平移
+
+
+- 投影矩阵
+- LookAt矩阵
+
+变换矩阵的重要特性之一就是它们都是4x4的矩阵。这是因为我们决定使用齐次坐标系。 否则，各变换矩阵可能会有不同的纬度并且无法想乘。    
+
+
 
 ### 相机
 
diff --git "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md" "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
index e179b27b..2579b75d 100644
--- "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
+++ "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
@@ -349,7 +349,7 @@ GLSL的类型转换与C不同。在GLSL中类型不可以自动提升，比如fl
 片段着色器的内建变量
 
 - 输入变量
-  - gl_FragCoord:当前片元在framebuffer画面的相对位置
+  - gl_FragCoord:当前片元在framebuffer画面的相对位置(输入片段的坐标)
   - gl_FragFacing:bool型，表示是否为属于光栅化生成此片元的对应图元的正面。
   - gl_PointCoord:经过插值计算后的纹理坐标，点的范围是0.0到1.0
 - 输出变量

From d8b28c6234fd6ad2e9f337a46ab4ed1b13fe7c50 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Sat, 27 Apr 2024 13:32:11 +0800
Subject: [PATCH 164/213] update opengl part

---
 ...3.\345\256\236\344\276\213\345\214\226.md" | 58 +++++++++++++++++++
 ...66\344\270\211\350\247\222\345\275\242.md" | 11 +++-
 ...42\345\217\212\345\234\206\345\275\242.md" |  9 +++
 ...45\231\250\350\257\255\350\250\200GLSL.md" | 45 ++++++++++++++
 .../9.OpenGL ES\347\272\271\347\220\206.md"   | 25 ++++++++
 5 files changed, 146 insertions(+), 2 deletions(-)
 create mode 100644 "VideoDevelopment/OpenGL/13.\345\256\236\344\276\213\345\214\226.md"

diff --git "a/VideoDevelopment/OpenGL/13.\345\256\236\344\276\213\345\214\226.md" "b/VideoDevelopment/OpenGL/13.\345\256\236\344\276\213\345\214\226.md"
new file mode 100644
index 00000000..cf2f5fae
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/13.\345\256\236\344\276\213\345\214\226.md"
@@ -0,0 +1,58 @@
+## 13.实例化
+
+实例化(instancing)提供了一种机制，可以只用一个C++/OpenGL调用就告诉显卡渲染一个对象的多个副本。这可以带来显著的性能优势，特别是在绘制有数千甚至数百万个对象时，例如渲染在场地中的许多花朵。
+
+实例化最常见的应用就是做一些粒子效果，例如一些烟花的效果。。
+
+
+在渲染多个对象时，OpenGL使用Z-buffer算法来进行隐藏面消除。通常情况下，通过选择最接近相机的相应片段的颜色作为像素的颜色，这种方法可决定哪些物体的曲面可见并呈现到屏幕，而位于其他物体后面的曲面不应该被渲染。
+然而，有时候场景中的两个物体表面重叠并位于重合的平面中，这使得深度缓冲区算法难以确定应该渲染两个表面中的哪一个（因为两者都不“最接近”相机）。发生这种情况时，浮点舍入误差可能会导致渲染表面的某些部分使用其中一个对象的颜色，而其他部分则使用另一个对象的颜色。这种不自然的伪影称为Z冲突(Z-fighting)或深度冲突(depth-fighting)，是渲染的片段在深度缓冲区中相互对应的像素条目上“斗争”的结果。
+
+
+![image](https://github.com/CharonChui/Pictures/blob/master/opengl_z_fighting.png?raw=true)
+
+
+
+提高渲染效率的另一种方法是利用OpenGL的背面剔除能力。当3D模型完全“闭合”时，意味着内部永远不可见（例如对于立方体和四棱锥），那么外表面的那些与观察者背离且呈一定角度的部分将始终被同一模型的其他部分遮挡。也就是说，那些背离观察者的三角形不可能被看到（无论如何它们都会在隐藏面消除的过程中被覆盖），因此没有理由栅格化或渲染它们。
+我们可以使用命令glEnable(GL_CULL_FACE)要求OpenGL识别并“剔除”（不渲染）背向的三角形。我们还可以使用glDisable(GL_CULL_FACE)禁用背面剔除。默认情况下，背面剔除是关闭的，因此如果你希望OpenGL剔除背向三角形，必须手动启用它。
+
+
+
+
+[上一篇: 10.GLSurfaceView+MediaPlayer播放视频](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md" "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"
index 5f91fcac..3fbe1436 100644
--- "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
@@ -208,7 +208,7 @@ someOpenGLFunctionThatDrawsOurTriangle();
 IntBuffer arrays = IntBuffer.allocate(1);
 GLES30.glGenVertexArrays(1, arrays);
 ```
-要想使用VAO，要做的只是使用glBindVertexArray绑定VAO。从绑定之后起，我们应该绑定和配置对应的VBO和属性指针，之后解绑VAO供之后使用。    
+要想使用VAO，要做的只是使用glBindVertexArray绑定VAO(glBindVertexArrays()命令的目的是将指定的VAO标记为活跃，这样生成的缓冲区就会和这个VAO相关联)。从绑定之后起，我们应该绑定和配置对应的VBO和属性指针，之后解绑VAO供之后使用。    
 当我们打算绘制一个物体的时候，我们只要在绘制物体前简单地把VAO绑定到希望使用的设定上就行了。这段代码应该看起来像这样：
 
 VAO小助理偷偷帮我们记录一切：   
@@ -272,6 +272,12 @@ Preferences -> Plugins -> 搜GLSL Support安装就可以了。
 
 - 顶点着色器(triangle_vertex_shader.glsl)
 
+关键字in意思是输入(input)，表示这个顶点属性将会从缓冲区(C++或Java代码中的VBO、VAO等)中接收数值。
+顶点属性还可以改为被声明为out，这意味着它们会将值发送到管线中的下一个阶段。    
+
+layout(location=0)称为layout修饰符。也就是我们把顶点属性和特定缓冲区关联起来的方法，这意味着这个顶点属性的识别号是0.
+
+
 ```glsl 
 // 声明着色器的版本 
 #version 300 es 
@@ -445,11 +451,12 @@ public class TriangleRender implements GLSurfaceView.Renderer {
         //把颜色缓冲区设置为我们预设的颜色，绘图设计到多种缓冲区类型:颜色、深度和模板。这里只是向颜色缓冲区中绘制图形
         GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT);
         // glVertexAttribPointer是把顶点位置属性赋值给着色器程序
-        //0是上面着色器中写的vPosition的变量位置(location = 0)。意思就是绑定vertex坐标数据，然后将在vertextBuffer中的顶点数据传给vPosition变量。
+        // 0是上面着色器中写的vPosition的变量位置(location = 0)。意思就是绑定vertex坐标数据，然后将在vertextBuffer中的顶点数据传给vPosition变量。
         // 你肯定会想，如果我在着色器中不写呢？int vposition = glGetAttribLocation(program, "vPosition");就可以获得他的属性位置了
         // 第二个size是3，是因为上面我们triangleCoords声明的属性就是3位，xyz
         GLES30.glVertexAttribPointer(0, 3, GLES30.GL_FLOAT, false, 3 * Float.BYTES, vertexBuffer);
         //启用顶点变量，这个0也是vPosition在着色器变量中的位置，和上面一样，在着色器文件中的location=0声明的
+        // 也就是说由于vPosition在着色器中的位置被指定为0，因此可以简单的通过glVertexAttribPointer()函数调用中的第一个参数和在glEnableVertexAttribArray()函数调用中使用0来引用此变量
         GLES30.glEnableVertexAttribArray(0);
 
         //准备颜色数据
diff --git "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md" "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"
index f9319879..9b9d547d 100644
--- "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"	
@@ -514,6 +514,15 @@ public class CircleRender extends BaseGLSurfaceViewRenderer {
 }
 ```
 
+
+### OpenGL支持的图元
+
+
+![image](https://github.com/CharonChui/Pictures/blob/master/opengl_tuyuan.png?raw=true)
+
+
+
+
 [上一篇: 5.OpenGL ES绘制三角形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/5.OpenGL%20ES%E7%BB%98%E5%88%B6%E4%B8%89%E8%A7%92%E5%BD%A2.md)       
 [下一篇: 7.OpenGL ES着色器语言GLSL](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/7.OpenGL%20ES%E7%9D%80%E8%89%B2%E5%99%A8%E8%AF%AD%E8%A8%80GLSL.md)
 
diff --git "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md" "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
index 2579b75d..d91aa94e 100644
--- "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
+++ "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
@@ -213,6 +213,14 @@ glUniform4f(vertexColorLocation, 0.0f, greenValue, 0.0f, 1.0f);
 现在你知道如何设置uniform变量的值了，我们可以使用它们来渲染了。如果我们打算让颜色慢慢变化，我们就要在游戏循环的每一次迭代中（所以他会逐帧改变）更新这个uniform，否则三角形就不会改变颜色。        
 
 
+顶点着色器中的乘法将矩阵变换应用于顶点，将其转换为相机空间（请注意从右到左的计算顺序）。这些值被放入内置的OpenGL输出变量gl_Position中，然后继续通过管线，并由光栅着色器进行插值。
+插值后的像素位置（称为片段）被发送到片段着色器(fragment shader)。回想一下，片段着色器的主要目的是设置输出像素的颜色。与顶点着色器的方式类似，片段着色器逐个处理像素，并对每个像素单独调用。
+
+
+![image](https://github.com/CharonChui/Pictures/blob/master/opengl_progress_11.png?raw=true)
+
+
+
 
 ### GLSL的特点
 
@@ -468,6 +476,43 @@ glVertexAttribPointer函数的前几个参数比较明了。这次我们配置
 同样，这次我们必须指定一个偏移量。对于每个顶点来说，位置顶点属性在前，所以它的偏移量是0。颜色属性紧随位置数据之后，所以偏移量就是Float.BYTES，用字节来计算就是12字节。    
 
 
+### 着色器示例
+
+```
+顶点着色器如下：
+#version 430
+
+layout (location=0) in vec3 position;
+uniform mat4 mv_matrix;
+uniform mat4 proj_matrix;
+
+out vec4 varyingColor;
+
+void main(void)
+{  gl_Position = proj_matrix * mv_matrix * vec4(position,1.0);
+    varyingColor = vec4(position,1.0) * 0.5 + vec4(0.5, 0.5, 0.5, 0.5);
+}
+
+
+着色器如下：
+#version 430
+
+in vec4 varyingColor;
+
+out vec4 color;
+uniform mat4 mv_matrix;
+uniform mat4 proj_matrix;
+
+void main(void)
+{  color = varyingColor;
+}
+请注意，因为颜色是从顶点着色器的顶点属性varyingColor中发出的，所以它们也由光栅着色器进行插值！
+```
+
+请注意，代码中将位置坐标乘1/2，然后加1/2，以将取值区间从[−1, +1]转换为[0, 1]。此外，由程序员定义的插值顶点属性变量名称中通常包含单词“varying”，这是一种约定俗成的做法。修改的具体位置已突出显示。
+
+
+
 
 [上一篇: 6.OpenGL ES绘制矩形及圆形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/6.OpenGL%20ES%E7%BB%98%E5%88%B6%E7%9F%A9%E5%BD%A2%E5%8F%8A%E5%9C%86%E5%BD%A2.md)  
 [下一篇: 8.GLES类及Matrix类](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/8.GLES%E7%B1%BB%E5%8F%8AMatrix%E7%B1%BB.md)
diff --git "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md" "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"
index 921dcbe4..45764527 100644
--- "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
+++ "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
@@ -31,6 +31,17 @@ OpenGL要操作一个纹理，那么是将纹理ID装进纹理单元这个容器
 
   
 
+纹理贴图是在栅格化的模型表面上覆盖图像的技术。它是为渲染场景添加真实感的最基本和最重要的方法之一。
+纹理贴图非常重要，因此硬件也为它提供了支持，使得它具备实现实时的照片级真实感的超高性能。纹理单元是专为纹理设计的硬件组件，现代显卡通常带有数个纹理单元。
+为了在OpenGL/GLSL中有效地完成纹理贴图，需要协调好以下几个不同的数据集和机制：
+·用于保存纹理图像的纹理对象（在本章中我们仅考虑2D图像）；
+·特殊的统一采样器变量，以便顶点着色器访问纹理；
+·用于保存纹理坐标的缓冲区；
+·用于将纹理坐标传递给管线的顶点属性；
+·显卡上的纹理单元。
+
+
+
 ### 纹理与渐变色的区别
 
 渐变色:光栅化过程中计算出颜色值，然后在使用片段着色器的时候可以直接赋值。
@@ -77,6 +88,12 @@ V0（-1，0.5），V1（-1， -0.5），V2（1，-0.5），V3（1，0.5）
 
 
 
+纹理坐标是对纹理图像（通常是2D图像）中的像素的引用。纹理图像中的像素被称为纹元(texel)，以便将它们与在屏幕上呈现的像素区分开。纹理坐标用于将3D模型上的点映射到纹理中的位置。除了将它定位在3D空间中的坐标(x,y,z)之外，模型表面上的每个点还具有纹理坐标(s,t)，用来指定纹理图像中的哪个纹元为它提供颜色。这样，物体的表面被按照纹理图像“涂画”。纹理在对象表面上的朝向由分配给对象顶点的纹理坐标确定。
+要使用纹理贴图，必须为要添加纹理的对象中的每个顶点提供纹理坐标。OpenGL将使用这些纹理坐标，查找存储在纹理图像中的引用的纹元的颜色，来确定模型中每个栅格化像素的颜色。为了确保渲染模型中的每个像素都使用纹理图像中的适当纹元进行绘制，纹理坐标也需要被放入顶点属性中，以便由光栅着色器进行插值。
+
+
+
+
 
 ### 文件读取
 
@@ -291,6 +308,14 @@ void main() {
 }
 ```
 
+
+为了最大限度地提高性能，我们希望在硬件中执行纹理处理。这意味着片段着色器需要一种访问我们在C++/OpenGL应用程序中创建的纹理对象的方法。它的实现机制是通过一个叫作统一采样器变量的特殊GLSL工具。这是一个变量，用于指示显卡上的纹理单元，从加载的纹理对象中提取或“采样”纹元。
+要实际执行纹理处理，我们需要修改片段着色器输出颜色的方式。以前，我们的片段着色器要么输出一个固定的颜色常量，要么从顶点属性获取颜色，而这次我们需要使用从顶点着色器（通过光栅着色器）接收的插值纹理坐标来对纹理对象进行采样。调用texture()函数如下：
+```
+in vec2 tc;            // 纹理坐标
+...
+color = texture(samp, tc);
+```
   
 
 - render实现类

From f7fbe08e4c454044ac88c3db8e88fc23dcbc32d1 Mon Sep 17 00:00:00 2001
From: xuchuanren <charon.chui@gmail.com>
Date: Sun, 28 Apr 2024 11:35:53 +0800
Subject: [PATCH 165/213] update OpenGL part

---
 .../OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"       | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md" "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"
index 45764527..37eb449f 100644
--- "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
+++ "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
@@ -563,6 +563,15 @@ void main() {
 - 纹理，texture：存储描述信息
 - 画布，surface：内存中的一块地址，存储像素数据
 
+
+
+- 几何着色器
+
+几何着色器阶段位于曲面细分着色器和栅格化之间，位于用于图元处理的管线内。
+顶点着色器允许一次操作一个顶点，而片段着色器一次可以操作一个片段（实际上是一个像素），但几何着色器却可以一次操作一个图元。
+
+
+
 [上一篇: 8.GLES类及Matrix类](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/8.GLES%E7%B1%BB%E5%8F%8AMatrix%E7%B1%BB.md)  
 [下一篇: 10.GLSurfaceView+MediaPlayer播放视频](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md)
 

From b87f35344290121a56803ef5765eb19d9ab4009e Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Tue, 30 Apr 2024 17:28:55 +0800
Subject: [PATCH 166/213] add python part

---
 .../python3\345\205\245\351\227\250.md"       | 291 ++++++++++++++++++
 .../11.OpenGL ES\346\273\244\351\225\234.md"  |   1 +
 VideoDevelopment/OpenGL/12.FBO.md             |   3 +-
 .../OpenGL/13.LUT\346\273\244\351\225\234.md" |  43 +++
 4 files changed, 337 insertions(+), 1 deletion(-)
 create mode 100644 "JavaKnowledge/python3\345\205\245\351\227\250.md"
 create mode 100644 "VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md"

diff --git "a/JavaKnowledge/python3\345\205\245\351\227\250.md" "b/JavaKnowledge/python3\345\205\245\351\227\250.md"
new file mode 100644
index 00000000..908e7d8f
--- /dev/null
+++ "b/JavaKnowledge/python3\345\205\245\351\227\250.md"
@@ -0,0 +1,291 @@
+# python3入门
+
+## 变量
+
+```python
+message = "Hello World"
+print(message)
+```
+
+## 字符串
+
+
+
+字符串就是一系列字符。在Python中，用引号括起来的都是字符串，其中的引号可以是单引号，也可以是双引号。例如:     
+```python
+message = 'Hello World'
+print(message)
+message = "Hello World"
+print(message)
+```
+
+### 大小写
+修改单词中的大小写:     
+
+title()方法是以首字母大写的方式显示每个单词，即将每个单词的首字母都改为大写。   
+upper()方法将字符串改为全部大写。
+lower()方法将字符串改为全部小写。   
+```python
+message = 'hello world'
+print(message.title())
+# 输出结果为Hello World
+```
+
+注意上面方法lower、upper、title等不会修改存储在变量message中的值。
+
+### 拼接
+
+合并: Python使用加号(+)来合并字符串。这种合并字符串的方法称为拼接。   
+```python
+first_name = "ada"
+last_name = "lovelace"
+full_name = first_name + " " + last_name
+print(full_name)
+# 输出： ada lovelace
+```
+
+### 空格
+
+rstrip(): 去除字符串末尾空白。注意去除只是暂时的，等你再次访问该变量是，你会发现这个字符串仍然包含末尾空白。      
+要永久删除这个字符串中的空白，必须将删除的结果存回到变量中:   
+
+
+first_name = "ada  "
+print(first_name)
+first_name = first_name.rstrip()
+print(first_name)
+
+lstrip(): 去除字符串开头空白       
+strip(): 同时去除字符串两端的空白      
+
+
+## 整数
+
+
+可对整数执行加(+)、减(-)、乘(`*`)、除(/)运算。     
+
+Python使用两个乘号表示乘方运算。
+
+
+## 浮点数
+
+在Python中将带小数点的数字都称为浮点数。          
+但是要注意的是，结果包含小数位数可能是不确定的，例如:     
+```python
+>>> 0.2 + 0.1
+0.30000000000000004
+```
+
+命令行执行python后执行exit()或quit()可退出。     
+
+## 类型转换
+
+```python
+age = 23
+message = "Happy" + age + "Birthday"
+print(message)
+```
+
+执行时会报错：  
+```python
+message = "Happy" + age + "Birthday"
+              ~~~~~~~~^~~~~
+TypeError: can only concatenate str (not "int") to str
+```
+
+类型错误，这个时候需要显式的指定希望Python将这个整数用作字符串。      
+为此，可调用函数str()，它让Python将非字符串值表示为字符串： 
+
+```python
+age = 23
+message = "Happy" + str(age) + "Birthday"
+print(message)
+```
+
+
+## 注释
+
+使用井号(#)标识注释
+
+
+## 列表
+
+在Python中，用方括号[]来表示列表，并用逗号来分割其中的元素。   
+```python
+bicycles = ['trek', 'cannondale', 'redline', 'specialized']
+print(bicycles)
+print(bicycles[0])
+print(bicycles[-1])
+# 设置最后一个元素
+bicycles[-1] = 'honda'
+# 在列表最后添加元素
+bicycles.append('ducati')
+# 在某个位置添加元素
+bicycles.insert(0, 'a')
+print(bicycles)
+# 删除某个位置的元素
+del bicycles[0]
+# 删除最后一个元素，并返回删除的值
+popValue = bicycles.pop()
+print(popValue)
+# 通过值删除元素，如果列表中有多个重复的元素，那该方法只会删除第一个指定的值
+bicycles.remove('trek')
+# 排序
+bicycles.sort()
+# 反序排序
+bicycles.sort(reverse=True)
+```
+Python为访问最后一个列表元素提供了一种特殊的语法，通过将索引指定为-1，可让Python返回最后一个列表元素。      
+这是为了方便在不知道列表长度的情况下访问最后的元素。     
+这种约定也适用于其他负数索引，例如，索引-2返回倒数第二个列表元素，索引-3返回倒数第三个列表元素，以此类推。   
+
+### 临时排序
+
+要保留列表元素原来的排列顺序，同时以特定的顺序呈现它们，可使用函数sorted()。       
+函数sorted()让你能够按特定顺序显示列表元素，同时不影响它们在列表中的原始排列顺序。   
+
+```python
+bicycles = ['trek', 'cannondale', 'redline', 'specialized']
+bicycles.sort(reverse=True)
+# ['trek', 'specialized', 'redline', 'cannondale']
+print(bicycles)
+# ['cannondale', 'redline', 'specialized', 'trek']
+print(sorted(bicycles))
+# ['trek', 'specialized', 'redline', 'cannondale']
+print(bicycles)
+```
+
+
+### 反转列表
+
+```python
+bicycles = ['trek', 'cannondale', 'redline', 'specialized']
+bicycles.reverse()
+print(bicycles)
+# 列表长度
+size = len(bicycles)
+print(size)
+```
+
+### 遍历
+
+**Python根据缩进来判断代码行与前一个代码行的关系，在较长的Python程序中，你将看到缩进程度各不相同的代码块，这让你对程序的组织结构有大致的认识**
+
+
+注意:    
+
+- for in 后有个冒号`:`，for语句末尾的冒号告诉Python，下一行是循环的第一行。    
+- 前面缩进的代码才是for循环中的部分
+- 没有缩进的是for循环之外的
+
+
+- 
+```python
+bicycles = ['trek', 'cannondale', 'redline', 'specialized']
+for bcy in bicycles:
+    print(bcy)
+    print(bcy.title())
+print('end')
+```
+
+
+### 切片
+
+你还可以处理列表的部分元素——Python称之为切片。
+要创建切片，可指定要使用的第一个元素和最后一个元素的索引。
+你可以生成列表的任何子集，例如，如果你要提取列表的第2～4个元素，可将起始索引指定为1，并将终止索引指定为4：
+
+```python
+players = ['charles','martina','michael','florence','eli']
+print(players[1:4])
+```
+
+例如，如果要提取从第3个元素到列表末尾的所有元素，可将起始索引指定为2，并省略终止索引
+
+
+### range函数
+
+range()函数能够生成一系列的数字，例如range(1, 5)会生成1  2  3  4。     
+要创建数字列表，可使用函数list()将range()的结果直接转换为列表:    
+```ptyhon
+numbers = list(range(1, 5))
+print(numbers)
+
+# 
+print(min(numbers))
+print(max(numbers))
+print(sum(numbers))
+
+```
+
+
+## 元组(不可变的列表)
+
+有时候你需要创建一系列不可修改的元素，元组可以满足这种需求。Python将不能修改的值称为不可变的，而不可变的列表被称为元组。
+元组看起来犹如列表，但使用圆括号而不是方括号来标识。定义元组后，就可以使用索引来访问其元素，就像访问列表元素一样。
+元组中的元素不能修改，访问和遍历都和列表一样。
+
+
+相对于列表，元组是更简单的数据结构。       
+如果需要存储的一组值在程序的整个生命周期内都不变，可使用元组。    
+
+
+
+## if语句
+
+```python
+cars = ['audi', 'bmd', 'toyota']
+for car in cars:
+    if car == 'toyota':
+        print(car.upper())
+    else:
+        print(car.title())
+```
+每条if语句的核心都是一个值为True或False的表达式，这种表达式被称为条件测试。 
+
+
+```python
+age = 12
+if age < 4:
+    print("cost $0")
+elif age < 18:
+    print("cost $5")
+else:
+    print("cost $10")
+```
+
+### 相等判断
+```python
+car = 'Audi'
+# False
+car == 'audi'
+```
+
+Python中使用两个等号(==)检测值是否相等，在Python中检测是否相等时区分大小写。   
+
+判断两个值不相等，可结合使用惊叹号和等号(!=)来判断。   
+
+条件语句中可包含各种数学比较，如小于<、小于等于<=、大于>、大于等于>=。   
+
+### 多条件检测
+
+有时候需要判断两个条件都为True或只要求一个条件为True时就执行相应的操作。     
+
+在这些情况下，可以使用关键字and和or。    
+
+### 值是否包含在列表中
+
+要判断特定的值是否已包含在列表中，可使用关键字in。       
+```python
+cars = ['audi', 'bmd', 'toyota']
+# True
+print('audi' in cars)
+
+# False
+print('audi' not in cars)
+```
+
+
+## 字典(Map)
+
+
diff --git "a/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md" "b/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"
index e76e826e..f7b28a1c 100644
--- "a/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"	
+++ "b/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"	
@@ -402,6 +402,7 @@ public class BaseFilter {
 
 
 [上一篇: 10.GLSurfaceView+MediaPlayer播放视频](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md)
+[下一篇: 12.FBO12.FBO](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md)
 
 ---
 
diff --git a/VideoDevelopment/OpenGL/12.FBO.md b/VideoDevelopment/OpenGL/12.FBO.md
index 4a9632fb..8f83daf4 100644
--- a/VideoDevelopment/OpenGL/12.FBO.md
+++ b/VideoDevelopment/OpenGL/12.FBO.md
@@ -22,7 +22,8 @@ Android OpenGL ES开发中，一般使用GLSurfaceView将绘制结果显示到
 
 
 
-[上一篇: 10.GLSurfaceView+MediaPlayer播放视频](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md)
+[上一篇: 11.OpenGL ES滤镜](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md)
+[下一篇: 13.LUT滤镜]()
 
 ---
 
diff --git "a/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md" "b/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md"
new file mode 100644
index 00000000..851e25da
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md"
@@ -0,0 +1,43 @@
+# 13.LUT滤镜
+
+
+
+
+
+[上一篇: 12.FBO](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md)
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

From cf4c9a1bafe49daff7eee0acce95ea212d93912b Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Tue, 30 Apr 2024 17:37:05 +0800
Subject: [PATCH 167/213] update opengl part

---
 JavaKnowledge/.DS_Store                          | Bin 6148 -> 0 bytes
 README.md                                        |   7 ++++++-
 .../11.OpenGL ES\346\273\244\351\225\234.md"     |   2 +-
 VideoDevelopment/OpenGL/12.FBO.md                |   4 ++--
 .../OpenGL/13.LUT\346\273\244\351\225\234.md"    |   4 +++-
 .../14.\345\256\236\344\276\213\345\214\226.md"  |   0
 6 files changed, 12 insertions(+), 5 deletions(-)
 delete mode 100644 JavaKnowledge/.DS_Store
 rename "VideoDevelopment/OpenGL/13.\345\256\236\344\276\213\345\214\226.md" => "VideoDevelopment/OpenGL/14.\345\256\236\344\276\213\345\214\226.md" (100%)

diff --git a/JavaKnowledge/.DS_Store b/JavaKnowledge/.DS_Store
deleted file mode 100644
index 1e695797205fc3a8c581396873b3ebfb6bf032c3..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6148
zcmeHK%}N6?5Kh|Krijpkg2#Z@f^8K+ysWjpK)2{YrFOfeUEFS#{#c|`_TWjq`vN|M
z58xY!9(@)kKb2}LdQntnVDe2SGs))LCD|c_&|=@s6Oti>Fi?rHG&D0rj!T`AnDHb5
zshp#7J-qQBok2Hr{HbVk{6+@kyGu2~dT{>GyqJ7{!hw-HC-l8;FPD3wv3O!GnPMq6
z&yMVt7}&j9uiq`!ItQ{>5yE%IcFo!I8iQ(PaYqEbnin)WD#3Fb5OTQh1+EwrML%%6
zD%aKnEX~r@%<^zp$mg@Xuvr*o`Eaw4%kuTLjnOF0mR44`%GDFU9f(U!C55j}$%4T#
zT!Ha!SAH{Z*F`%VhfGJbMXBWYYTv9J?wmc}-fz!}a=#E2wmw_!)b0en2%50Mco!3o
zh9)wA3?KvF%78g{*!;Jyf|DZy$iQD@K%NgARH9`t(x{FOXjBORm;kpDuw^YFbGSjv
zV5AX7K&Vay)Tz{z7*wZ&pPM+#V5Cu}6KaYNYF4JELZNDPn4ha~LM@HhA_K_4TL$8~
zo00eb?#K22+a&BE1IWO?Vt^(}cBu$kGI#6L=Hy+=L61SD$hb)3YYG_ZDu!5j6)%G-
Z0Y8@ppk*-92p$mp5l}Q>gADvA124mDhn)Zb

diff --git a/README.md b/README.md
index 8604e003..57ce5f8e 100644
--- a/README.md
+++ b/README.md
@@ -109,6 +109,8 @@ Android学习笔记
         - [10.GLSurfaceView+MediaPlayer播放视频][241]
         - [11.OpenGL ES滤镜][242]
         - [12.FBO][332]
+        - [13.LUT滤镜][346]
+        - [14.实例化][347]
     - [弹幕][243]
         - [Android弹幕实现][244]
     - [FFmpeg][322]    
@@ -297,6 +299,7 @@ Android学习笔记
     - [Top-K问题][196]
     - [Java内存模型][285]
     - [JVM架构][286]
+    - [python3入门][345]
 - [基础部分][54] 
     - [安全退出应用程序][110]
     - [病毒][111]
@@ -723,7 +726,9 @@ Android学习笔记
 [342]: https://github.com/CharonChui/AndroidNote/tree/master/VideoDevelopment/OpenCV "OpenCV"
 [343]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenCV/1.OpenCV%E7%AE%80%E4%BB%8B.md "1.OpenCV简介"
 [344]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/Android%E9%9F%B3%E8%A7%86%E9%A2%91%E5%BC%80%E5%8F%91/MediaMetadataRetriever.md    "MediaMetadataRetriever"
-
+[345]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/python3%E5%85%A5%E9%97%A8.md    "python3入门"
+[346]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/13.LUT%E6%BB%A4%E9%95%9C.md  "13.LUT滤镜"
+[347]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/13.LUT%E6%BB%A4%E9%95%9C.md  "14.实例化"
 
 
 Developed By
diff --git "a/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md" "b/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"
index f7b28a1c..366ebbb3 100644
--- "a/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"	
+++ "b/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"	
@@ -402,7 +402,7 @@ public class BaseFilter {
 
 
 [上一篇: 10.GLSurfaceView+MediaPlayer播放视频](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md)
-[下一篇: 12.FBO12.FBO](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md)
+[下一篇: 12.FBO](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/12.FBO.md)
 
 ---
 
diff --git a/VideoDevelopment/OpenGL/12.FBO.md b/VideoDevelopment/OpenGL/12.FBO.md
index 8f83daf4..dc4d71bc 100644
--- a/VideoDevelopment/OpenGL/12.FBO.md
+++ b/VideoDevelopment/OpenGL/12.FBO.md
@@ -22,8 +22,8 @@ Android OpenGL ES开发中，一般使用GLSurfaceView将绘制结果显示到
 
 
 
-[上一篇: 11.OpenGL ES滤镜](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md)
-[下一篇: 13.LUT滤镜]()
+[上一篇: 11.OpenGL ES滤镜](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/11.OpenGL%20ES%E6%BB%A4%E9%95%9C.md)
+[下一篇: 13.LUT滤镜](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/13.LUT%E6%BB%A4%E9%95%9C.md)
 
 ---
 
diff --git "a/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md" "b/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md"
index 851e25da..0c6eddae 100644
--- "a/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md"
+++ "b/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md"
@@ -4,7 +4,9 @@
 
 
 
-[上一篇: 12.FBO](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md)
+[上一篇: 12.FBO](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/12.FBO.md)
+[下一篇: 14.实例化](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/12.FBO.md)
+
 
 ---
 
diff --git "a/VideoDevelopment/OpenGL/13.\345\256\236\344\276\213\345\214\226.md" "b/VideoDevelopment/OpenGL/14.\345\256\236\344\276\213\345\214\226.md"
similarity index 100%
rename from "VideoDevelopment/OpenGL/13.\345\256\236\344\276\213\345\214\226.md"
rename to "VideoDevelopment/OpenGL/14.\345\256\236\344\276\213\345\214\226.md"

From 5dafb43ef788ccf545dceabed0d0c1b32e81ba05 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Tue, 30 Apr 2024 18:32:21 +0800
Subject: [PATCH 168/213] update README

---
 .../python3\345\205\245\351\227\250.md"           | 15 ++++++++++++++-
 README.md                                         |  2 +-
 .../OpenGL/13.LUT\346\273\244\351\225\234.md"     |  2 +-
 3 files changed, 16 insertions(+), 3 deletions(-)

diff --git "a/JavaKnowledge/python3\345\205\245\351\227\250.md" "b/JavaKnowledge/python3\345\205\245\351\227\250.md"
index 908e7d8f..eb897476 100644
--- "a/JavaKnowledge/python3\345\205\245\351\227\250.md"
+++ "b/JavaKnowledge/python3\345\205\245\351\227\250.md"
@@ -286,6 +286,19 @@ print('audi' not in cars)
 ```
 
 
-## 字典(Map)
+## 字典(Key-Value)
 
+在Python中，字典是一系列键-值对。字典用放在花括号{}中的一些列键-值对表示。           
+每个键都与一个值相关联，你可以使用键来访问与之相关联的值。      
+与键相关联的值可以是数字、字符串、列表乃至字典。事实上，可将任何Python对象用作字典中的值。     
 
+```python
+alien = {'color': 'blue', 'points': 5}
+# 取值
+print(alien['color'])
+print(alien['points'])
+# 添加值
+alien['xPos'] = 10
+alien['yPos'] = 20
+print(alien['xPos'])
+```
diff --git a/README.md b/README.md
index 57ce5f8e..e7e3e4f7 100644
--- a/README.md
+++ b/README.md
@@ -728,7 +728,7 @@ Android学习笔记
 [344]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/Android%E9%9F%B3%E8%A7%86%E9%A2%91%E5%BC%80%E5%8F%91/MediaMetadataRetriever.md    "MediaMetadataRetriever"
 [345]: https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/python3%E5%85%A5%E9%97%A8.md    "python3入门"
 [346]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/13.LUT%E6%BB%A4%E9%95%9C.md  "13.LUT滤镜"
-[347]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/13.LUT%E6%BB%A4%E9%95%9C.md  "14.实例化"
+[347]: https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/14.%E5%AE%9E%E4%BE%8B%E5%8C%96.md  "14.实例化"
 
 
 Developed By
diff --git "a/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md" "b/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md"
index 0c6eddae..9c15dc6c 100644
--- "a/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md"
+++ "b/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md"
@@ -5,7 +5,7 @@
 
 
 [上一篇: 12.FBO](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/12.FBO.md)
-[下一篇: 14.实例化](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/12.FBO.md)
+[下一篇: 14.实例化](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/14.%E5%AE%9E%E4%BE%8B%E5%8C%96.md)
 
 
 ---

From de9f5e114e6014552ba97efe300b37fe5ec09c1f Mon Sep 17 00:00:00 2001
From: xuchuanren <charon.chui@gmail.com>
Date: Tue, 30 Apr 2024 18:36:44 +0800
Subject: [PATCH 169/213] update

---
 VideoDevelopment/.DS_Store                    | Bin 0 -> 6148 bytes
 .../.1.OpenGL\347\256\200\344\273\213.md.swp" | Bin 0 -> 69632 bytes
 .../1.OpenGL\347\256\200\344\273\213.md"      |  28 ++++++++----------
 ....GLSurfaceView\347\256\200\344\273\213.md" |  24 +++++++++++----
 4 files changed, 31 insertions(+), 21 deletions(-)
 create mode 100644 VideoDevelopment/.DS_Store
 create mode 100644 "VideoDevelopment/OpenGL/.1.OpenGL\347\256\200\344\273\213.md.swp"

diff --git a/VideoDevelopment/.DS_Store b/VideoDevelopment/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..a4c639de123dfb29e6f4f862ffdadea92d776a31
GIT binary patch
literal 6148
zcmeHK%}T>S5Z<-5O({YS3OxqA7ObrlikA>8UIf929#m>Vf(B!@G^sh1LeBa^K8erc
z%<kq840sc<GqC&3&d+Y<gX|Auj62KVkTH`nW<W#asMH9WYh7D97?I04&e*x1r*l6R
ze$7OG(S+aLVi#=ALYA=V_kZ~FI7+j@;FE7Pn%k|m(Kfoqz566`H}kS(>UfJ=99;<!
z`=##r*HM_y%-s`_WL}hn3z-lFA%xuBL`fiWM=X;dmAS5R7#*WCGkdGma6IT+qv2%T
zw^oxO=traRdfhSh_79FPXV39VBHk2{95|P<qp^f{P%1UOx{D+h$s^dyoHCY>7$63S
z0b*eD7|>^d(cQe#sbXS)82Et!+#f7xh_=Q;q1-y4!|OBpn}{f&<68pJ(r9Ze6oLnY
zt5iUh%Jmb2t8}niI?mQuC{*c;%avgsy>j_@;c|7bTQZz+TOswt05MQyprM8)p8u!t
z%hW#dt0^=h28e-w#sF_l-Khgb>9h4)d3e@Z&>o<nU|fL;2<Vkd01R*+=}D*ZTc|^v
Yt+7yuv!Gq31JXr65<(p@@Cyul0VuaiB>(^b

literal 0
HcmV?d00001

diff --git "a/VideoDevelopment/OpenGL/.1.OpenGL\347\256\200\344\273\213.md.swp" "b/VideoDevelopment/OpenGL/.1.OpenGL\347\256\200\344\273\213.md.swp"
new file mode 100644
index 0000000000000000000000000000000000000000..ec4ff252dcbbc9f4474238143addba1def69c816
GIT binary patch
literal 69632
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
K{Eh!``hNw5CD)Sx

literal 0
HcmV?d00001

diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
index d2156032..61803e2e 100644
--- "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -89,7 +89,9 @@ OpenGL是个状态机，有很多状态变量，是个标准的过程式操作
 OpenGL采用Client-Server模型来解释OpenGL程序，即Server存储OpenGL Context，Client提出渲染请求，Server给予响应。之后的渲染工作就要依赖这些渲染状态信息来完成，当一个上下文被销毁时，它所对应的OpenGL渲染工作也将结束。
 
 
-OpenGL ES API没有提及如何创建渲染上下文，或者渲染上下文如何连接到原生窗口系统。EGL是Khronos渲染API(如OpenGL ES)和原生窗口系统之间的接口。
+OpenGL ES API没有提及如何创建渲染上下文，或者渲染上下文如何连接到原生窗口系统。    
+
+EGL是Khronos渲染API(如OpenGL ES)和原生窗口系统之间的接口。
 
 ### 对象
 OpenGL在开发的时候引入了一些抽象层，对象(Object)就是其中的一个。 
@@ -102,8 +104,8 @@ OpenGL在开发的时候引入了一些抽象层，对象(Object)就是其中的
 ```	C
 struct object_Window_Target {
     float set_window_size;    // 这里调用的是OpenGL提供的设置窗口大小的某个方法
-    float set_window_color;   // 这里调用的事OpenGL提供的设置窗口颜色位数的某个方法
-        ....
+    float set_window_color;   // 这里调用的是OpenGL提供的设置窗口颜色位数的某个方法
+    ....
 }
 ```
 
@@ -123,7 +125,7 @@ struct OpenGL_Context {
 - 当前状态只有一份，如果每次显示不同的效果，都重新配置会很麻烦。 
 - 这时候我们就需要一些小助理(对象)，来帮忙记录某些状态信息，以便复用。  
 
-如果我们有10中子集，那就需要10个小助理(对象)，而当前状态(Context，只有一份)，可以通过装配这些对象来完成。 
+如果我们有10种子集，那就需要10个小助理(对象)，而当前状态(Context，只有一份)可以通过装配这些对象来完成。 
 
 ![image](https://github.com/CharonChui/Pictures/blob/master/opengl_zhuli.jpg?raw=true)
 
@@ -303,7 +305,7 @@ Java使用:
 ```java
 GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, vbo.get(0));
 ```
-从这一刻起，我们使用的任何(在GL_ARRAY_BUFFER目标上的)缓冲调用都会用来配置当前绑定的缓冲(VBO)。      
+从调用glBindBuffer()这一刻起，我们使用的任何(在GL_ARRAY_BUFFER目标上的)缓冲调用都会用来配置当前绑定的缓冲(VBO)。      
 然后我们可以调用glBufferData()函数，它会把之前定义的顶点数据复制到缓冲的内存中(小助理把对应的数据单独记录下来了)。   
       
 ```C
@@ -357,7 +359,9 @@ glBufferData是一个专门用来把用户定义的数据复制到当前绑定
     - OpenGL允许我们同时绑定多个缓冲，只要它们是不同的缓冲类型(每一个缓冲类型类似于前面说的子集，每个VBO是一个小助理)。
 
 - 配置OpenGL如何解释这些内存            
-    通过顶点数组对象(Vertex Array Objects, VAO）来管理，数组中的每一个项都对应一个属性的解析。       
+
+
+通过顶点数组对象(Vertex Array Objects, VAO）来管理，数组中的每一个项都对应一个属性的解析。       
 
 VAO（Vertex Array Object）是指顶点数组对象，主要用于管理 VBO 或 EBO ，减少 glBindBuffer 、glEnableVertexAttribArray、 glVertexAttribPointer 这些调用操作，高效地实现在顶点数组配置之间切换。
 
@@ -455,7 +459,7 @@ OpenGL中最基础且唯一的多边形就是三角形，所有更复杂的图
 
 光栅化操作构造了像素点(图元(点或三角形)转换成了像素的集合)，这个阶段就是处理这些像素点，根据自己的业务，例如高亮、饱和度调节、高斯模糊等来变化这个片元的颜色。      
 为组成点、直线和三角形的每个片元生成最终颜色/纹理，针对每个片元都会执行一次，一个片元是一个小的、单一颜色的长方形区域，类似于计算机屏幕上的一个像素。        
-一旦最终颜色生成，OpenGL就会把它们写到一块成为帧缓冲区的内存块中，然后Android就会把这个帧缓冲区显示到屏幕上。
+一旦最终颜色生成，OpenGL就会把它们写到一块称为帧缓冲区的内存块中，然后Android就会把这个帧缓冲区显示到屏幕上。
 
 通常在这里对片段进行处理(纹理采样、颜色汇总等)，将每个片段的颜色等属性计算出来并送给后续阶段。
 
@@ -551,7 +555,7 @@ EGL是OpenGL和本地窗口系统（Native Window System）之间的通信接口
 - 创建绘图表面；
 - 在OpenGL ES 和其他图形渲染API之间同步渲染；
 - 管理纹理贴图等渲染资源。
-OpenGL ES 的平台无关性正是借助 EGL 实现的，EGL 屏蔽了不同平台的差异（Apple 提供了自己的 EGL API 的 iOS 实现，自称 EAGL）。
+OpenGL ES 的平台无关性正是借助 EGL 实现的，EGL 屏蔽了不同平台的差异。
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/egl_interface_1.png?raw=true)
 
@@ -615,15 +619,9 @@ Pbuffer最常用于生成纹理贴图。如果你想要做的是渲染到一个
 纹理(Texture)是一个2D图片(也有1D和3D纹理)，他可以用来添加物体的细节，你可以想象纹理是一张绘有砖块的纸，无缝折叠贴合到你的3D房子上，这样你的房子看起来就有砖墙的外表了。
 
 
-Android 通过其框架 API 和原生开发套件 (NDK) 来支持 OpenGL。
-
-Android 框架中有如下两个基本类，用于通过 OpenGL ES API 来创建和操控图形：`GLSurfaceView` 和 `GLSurfaceView.Renderer`。
-
-
 #### 视频数据流
 
-视频从视频文件到屏幕显示出来，Surface起到了非常重要的作用，在视频解码时，需要一个Surface作为
-已解码数据的载体，保存播放器解码后的数据。       
+视频从视频文件到屏幕显示出来，Surface起到了非常重要的作用，在视频解码时，需要一个Surface作为已解码数据的载体，保存播放器解码后的数据。       
 
 在显示时，需要另一个Surface作为已渲染数据的载体，保存OpenGL渲染后的数据，最后通过EGL显示在屏幕上。   
 
diff --git "a/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
index cea103bb..7a17ce67 100644
--- "a/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
@@ -20,7 +20,7 @@ Android 框架中有如下两个基本类，用于通过 OpenGL ES API 来创建
 
 ### GLSurfaceView(使用OpenGL绘制的图形的视图容器)
 
-SurfaceView在View的基础上创建了独立的Surface，拥有SurfaceHolder来管理它的Surface，渲染的工作可以不再主线程中做。可以通过SurfaceHolder得到Canvas，在单独的线程中，利用Canvas绘制需要显示的内容，然后更新到Surface上。
+SurfaceView在View的基础上创建了独立的Surface，拥有SurfaceHolder来管理它的Surface，渲染的工作可以不在主线程中做。可以通过SurfaceHolder得到Canvas，在单独的线程中，利用Canvas绘制需要显示的内容，然后更新到Surface上。
 
 GLSurfaceView继承自SurfaceView，它主要是在SurfaceView的基础上加入了EGL的管理，并自带了一个GLThread的绘制线程，绘制的工作直接通过OpenGL在绘制线程进行，不会堵塞主线程，绘制的结果输出到SurfaceView所提供的Surface上，这使得GLSurfaceView也拥有了OpenGLES所提供的图形处理能力，通过它定义的Render接口，使更改具体的Render的行为非常灵活，只需要将实现了渲染函数的Renderer的实现类设置给GLSurfaceView既可。也就是说它是对SurfaceView的再次封装，为了方便我们在安卓中使用OpenGL。
 
@@ -128,7 +128,8 @@ class MyGLRenderer implements GLSurfaceView.Renderer {
 ```
 
 效果图就不贴了，就是一个纯绿色的Activity。
-上面glClearColor函数是一个状态设置函数，而glClear函数则是一个状态使用的函数，它使用了当前的状态来获取应该清除为的颜色
+上面glClearColor函数是一个状态设置函数，而glClear函数则是一个状态使用的函数，它使用了当前的状态来获取应该清除为的颜色    
+
 Render接口重写的三个方法中调用了GLES31的API方法:   
 
 - glClearColor()：设置清空屏幕用的颜色，参数为RGBA。
@@ -190,11 +191,22 @@ GLSurfaceView默认采用的是RENDERMODE_CONTINUOUSLY连续渲染的方式，
 
 说到GLSurfaceView就一定要提一下SurfaceTexture。
 
-和SurfaceView功能类似，区别是，SurfaceTexure可以不显示在界面中。使用OpenGl对图片流进行美化，添加水印，滤镜这些操作的时候我们都是通过SurfaceTexre去处理，处理完之后再通过GlSurfaceView显示。缺点，可能会导致个别帧的延迟。本身管理着BufferQueue,所以内存消耗会多一点。
-SurfaceTexture从图像流（来自Camera预览，视频解码，GL绘制场景等）中获得帧数据，当调用updateTexImage()时，根据内容流中最近的图像更新SurfaceTexture对应的GL纹理对象，接下来，就可以像操作普通GL纹理一样操作它了。  SurfaceTexture 可以将 Surface 中最近的图像数据更新到 GL Texture 中。通过 GL Texture 我们就可以拿到视频帧，然后直接渲染到 GLSurfaceView 中。
+和SurfaceView功能类似，区别是，SurfaceTexure可以不显示在界面中。使用OpenGl对图片流进行美化，添加水印，滤镜这些操作的时候我们都是通过SurfaceTexre去处理，处理完之后再通过GlSurfaceView显示。
+
+缺点，可能会导致个别帧的延迟。本身管理着BufferQueue,所以内存消耗会多一点。  
+
+
+SurfaceTexture从图像流（来自Camera预览，视频解码，GL绘制场景等）中获得帧数据，当调用updateTexImage()时，根据内容流中最近的图像更新SurfaceTexture对应的GL纹理对象，接下来，就可以像操作普通GL纹理一样操作它了。
+
+SurfaceTexture可以将Surface中最近的图像数据更新到GL Texture中。通过GL Texture我们就可以拿到视频帧，然后直接渲染到GLSurfaceView中。       
+
+通过 **setOnFrameAvailableListener(listener)** 可以向 SurfaceTexture 注册监听事件，当Surface有新的图像可用时，调用SurfaceTexture的**updateTexImage()**方法将图像内容更新到GL Texture中，然后做绘制操作。
+
+SurfaceTexture中的attachToGLContext()和detachToGLContext()可以让多个GL context共享同一个内容源。      
+
+SurfaceTexture对象可以在任何线程上创建。      
 
-通过 **setOnFrameAvailableListener(listener)** 可以向 SurfaceTexture 注册监听事件，当 Surface 有新的图像可用时，调用 SurfaceTexture 的 **updateTexImage()** 方法将图像内容更新到 GL Texture 中，然后做绘制操作。SurfaceTexture中的attachToGLContext()和detachToGLContext()可以让多个GL context共享同一个内容源。
-SurfaceTexture对象可以在任何线程上创建。 updateTexImage()只能在包含纹理对象的OpenGL ES上下文的线程上调用。 在任意线程上调用frame-available回调函数，不与updateTexImage()在同一线程上出现。
+updateTexImage()只能在包含纹理对象的OpenGL ES上下文的线程上调用。 在任意线程上调用frame-available回调函数，不与updateTexImage()在同一线程上出现。
 
 
 

From 36fa9dabe32769803b8fde2ca707d1103c86ca5a Mon Sep 17 00:00:00 2001
From: xuchuanren <charon.chui@gmail.com>
Date: Tue, 30 Apr 2024 19:39:34 +0800
Subject: [PATCH 170/213] add python part

---
 .../python3\345\205\245\351\227\250.md"       | 194 ++++++++++++++++++
 1 file changed, 194 insertions(+)

diff --git "a/JavaKnowledge/python3\345\205\245\351\227\250.md" "b/JavaKnowledge/python3\345\205\245\351\227\250.md"
index eb897476..d0da679a 100644
--- "a/JavaKnowledge/python3\345\205\245\351\227\250.md"
+++ "b/JavaKnowledge/python3\345\205\245\351\227\250.md"
@@ -301,4 +301,198 @@ print(alien['points'])
 alien['xPos'] = 10
 alien['yPos'] = 20
 print(alien['xPos'])
+del alien['points']
 ```
+
+### 遍历字典
+
+- keys()方法返回所有的键列表。
+- items()方法返回一个键-值对列表。    
+- values()方法返回一个值列表。  
+
+```ptyhon
+alien = {'color': 'blue', 'points': 5}
+
+for key,value in alien.items(): 
+    print("key: " + key)
+    print("value: " + str(value))
+
+
+for key in alien.keys(): 
+    print("key: " + key)    
+```
+字典总是明确地记录键和值之间的关联关系，但获取字典的元素时，获取顺序是不可预测的。      
+
+这不是问题，因为通常你想要的只是获取与键相关联的正确的值。     
+
+要以特定的顺序返回元素，一种方法是在for循环中对返回的键进行排序。。    
+
+为此，可使用函数sorted()来获得特定顺序排列的键列表的副本:     
+```python
+favorite_languages = {
+    'jen':'python',
+    'sarah':'c',
+    'edward':'ruby',
+    'phil':'python',
+    }
+for name in sorted(favorite_languages.keys()):
+    print(name.title()+",thank you for taking the poll.")
+```
+
+```python
+favorite_languages = {
+    'jen':'python',
+    'sarah':'c',
+    'edward':'ruby',
+    'phil':'python',
+    }
+print("The following languages have been mentioned:")
+for language in favorite_languages.values():
+    print(language.title())
+```
+
+这种做法提取字典中所有的值，而没有考虑是否重复。涉及的值很少时，这也许不是问题，但如果被调查者很多，最终的列表可能包含大量的重复项。为剔除重复项，可使用集合(set)。集合类似于列表，但每个元素都必须是独一无二的：
+```python
+favorite_languages = {
+    'jen':'python',
+    'sarah':'c',
+    'edward':'ruby',
+    'phil':'python',
+    }
+print("The following languages have been mentioned:")
+for language in set(favorite_languages.values()):❶
+    print(language.title())
+```
+通过对包含重复元素的列表调用set()，可让Python找出列表中独一无二的元素，并使用这些元素来创建一个集合。
+
+## 用户输入
+
+函数input()让程序暂停运行，等待用户输入一些文本。     
+
+获取用户输入后，Python将其村村在一个变量中，以方便你使用。   
+```python3
+age = input("How old are you?")
+print(age)
+```
+用户输入的是数字21，但我们请求Python提供age的值时，它返回的是`'21'`(用户输入的数值的字符串表示)。    
+
+为了解决这个问题，可以使用函数int()：将数字的字符串表示转换为数值表示，如:  
+```python
+age = input("Please Input")
+print(age)
+# print(age >= 18)  报错
+age = int(age)
+print(age >= 18)
+```
+
+## while
+
+```python
+current_number = 1
+while current_number <= 5:
+    print(current_number)
+    current_number+= 1
+```
+
+同样while中也可以结合使用break、continue等，和Java基本一样。  
+
+
+## 函数
+
+使用关键字def来定义一个函数，定义以冒号结尾。      
+跟在def xxx:后面的所有缩进行构成了函数体。   
+
+```python
+def greet_user(username): 
+    # 返回值
+    return 'Hello ' + username 
+
+# 调用函数    
+print(greet_user('jack')) 
+print(greet_user(username='lili'))
+```
+同样，在Python中函数也支持参数的默认值。   
+
+### 函数列表参数副本
+
+将列表传递给函数后，函数就可对其进行修改。在函数中对这个列表所做的任何修改都是永久性的，这让你能够高效地处理大量的数据。
+
+但是有些时候我们并不想让函数修改原始的列表。  
+
+为解决这个问题，可向函数传递列表的副本而不是原件；这样函数所做的任何修改都只影响副本，而丝毫不影响原件。
+
+要将列表的副本传递给函数，可以像下面这样做：
+```
+function_name(list_name[:])
+```
+
+切片表示法[:]创建列表的副本。
+
+### 函数不定参数
+
+有时候，你预先不知道函数需要接受多少个实参，Python允许函数从调用语句中收集任意数量的实参。  
+```python
+def make_pizza(*toppings):
+    """打印顾客点的所有配料"""
+    print(toppings)
+make_pizza('pepperoni')
+make_pizza('mushrooms','green peppers','extra cheese')
+```
+形参名`*toppings`中的星号让Python创建一个名为toppings的空元组，并将收到的所有值都封装到这个元组中。
+
+现在，我们可以将这条print语句替换为一个循环，对配料列表进行遍历，并对顾客点的比萨进行描述：
+
+```python
+def make_pizza(*toppings):
+    """概述要制作的比萨"""
+    print("\nMaking a pizza with the following toppings:")
+    for topping in toppings:
+        print("- "+topping)
+make_pizza('pepperoni')
+make_pizza('mushrooms','green peppers','extra cheese')
+```
+
+### 将函数存储在模块中
+
+函数的优点之一是，使用它们可将代码块与主程序分离。通过给函数指定描述性名称，可让主程序容易理解得多。你还可以更进一步，将函数存储在被称为模块的独立文件中，再将模块导入到主程序中。import语句允许在当前运行的程序文件中使用模块中的代码。
+
+
+要让函数是可导入的，得先创建模块。模块是扩展名为.py的文件，包含要导入到程序中的代码。下面来创建一个包含函数make_pizza()的模块。为此，我们将文件pizza.py中除函数make_pizza()之外的其他代码都删除：
+
+```python
+# pizza.py
+
+def make_pizza(size,*toppings):
+    """概述要制作的比萨"""
+    print("\nMaking a "+str(size)+
+          "-inch pizza with the following toppings:")
+    for topping in toppings:
+        print("- "+topping)
+```
+
+接下来，我们在pizza.py所在的目录中创建另一个名为making_pizzas.py的文件，这个文件导入刚创建的模块，再调用make_pizza()两次：
+
+```python
+# making_pizzas.py
+import pizza
+pizza.make_pizza(16,'pepperoni') ❶
+pizza.make_pizza(12,'mushrooms','green peppers','extra cheese')
+
+```
+Python读取这个文件时，代码行import pizza让Python打开文件pizza.py，并将其中的所有函数都复制到这个程序中。你看不到复制的代码，因为这个程序运行时，Python在幕后复制这些代码。你只需知道，在making_pizzas.py中，可以使用pizza.py中定义的所有函数。
+
+你还可以导入模块中的特定函数，这种导入方法的语法如下：
+`from modulname import funcxx`
+
+```python
+from pizza import make_pizza
+make_pizza(16,'pepperoni')
+make_pizza(12,'mushrooms','green peppers','extra cheese')
+```
+若使用这种语法，调用函数时就无需使用句点。由于我们在import语句中显式地导入了函数make_pizza()，因此调用它时只需指定其名称。
+
+
+
+
+
+

From 25830ce253b27250b165bd15dbd4a2029da5d656 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Tue, 30 Apr 2024 20:28:15 +0800
Subject: [PATCH 171/213] add python

---
 .../python3\345\205\245\351\227\250.md"       | 107 ++++++++++++++++++
 VideoDevelopment/.DS_Store                    | Bin 6148 -> 0 bytes
 2 files changed, 107 insertions(+)
 delete mode 100644 VideoDevelopment/.DS_Store

diff --git "a/JavaKnowledge/python3\345\205\245\351\227\250.md" "b/JavaKnowledge/python3\345\205\245\351\227\250.md"
index d0da679a..18b87df7 100644
--- "a/JavaKnowledge/python3\345\205\245\351\227\250.md"
+++ "b/JavaKnowledge/python3\345\205\245\351\227\250.md"
@@ -404,6 +404,7 @@ while current_number <= 5:
 
 ```python
 def greet_user(username): 
+    """函数功能的注释"""
     # 返回值
     return 'Hello ' + username 
 
@@ -413,6 +414,8 @@ print(greet_user(username='lili'))
 ```
 同样，在Python中函数也支持参数的默认值。   
 
+上面三个引号的部分是文档字符串格式，用于简要的阐述其功能的注释。     
+
 ### 函数列表参数副本
 
 将列表传递给函数后，函数就可对其进行修改。在函数中对这个列表所做的任何修改都是永久性的，这让你能够高效地处理大量的数据。
@@ -491,8 +494,112 @@ make_pizza(12,'mushrooms','green peppers','extra cheese')
 ```
 若使用这种语法，调用函数时就无需使用句点。由于我们在import语句中显式地导入了函数make_pizza()，因此调用它时只需指定其名称。
 
+还可以使用星号(`*`)导入模块中的所有函数:     
+
+```python
+from pizza import *
+make_pizza(16,'pepperoni')
+make_pizza(12,'mushrooms','green peppers','extra cheese')
+```
+`import *`会将模块pizza中的每个函数都复制到这个程序文件中。      
+由于导入了每个函数，可通过名称来调用每个函数，而无需使用句点表示法。      
+然而，使用并非自己编写的大型模块时，最好不要采用这种导入方法： 如果模块中有函数的名称与你的项目中使用的名称相同，可能导致意想不到的结果，因为Python可能遇到多个名称相同的函数或变量，进而覆盖函数，而不是分别导入所有的函数。   
+
+
+### 别名
+
+如果要导入的函数的名称与现有的名称冲突，或者函数的名称太长，可以通过别名的方式进行指定。
+
+```python
+from pizza import make_pizza as mp
+mp(16,'pepperoni')
+mp(12,'mushrooms','green peppers','extra cheese')
+```
+
+同样也可以通过as给模块指定别名:   
+
+```python
+import pizza as p
+
+p.make_pizza(16,'pepperoni')
+p.make_pizza(12,'mushrooms','green peppers','extra cheese')
+```
+
+
+## 类 
+
+在Python中，首字母大写的名称指的是类。  
+根据类来创建对象叫实例化。   
+
+dog.py
+```python
+class Dog:
+    def __init__(self, name, age):
+        self.name = name
+        self.age = age
+
+    def sit(self):
+        print(self.name + " Sitting")
+
+    def roll(self):
+        print(self.name + " Rolling")
+```
+
+__init__()是一个特殊的方法，每当你根据Dog类创建新实例时，Python都会自动运行它。在这个方法中形参self必不可少，还必须位于其他形参的前面。        
+
+为什么必须在方法定义中包含形参self呢？因为Python调用这个__init__()方法来创建Dog实例时，将自动传入实参self。    
+
+每个与类相关联的方法调用都自动传入实参self，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。         
+
+```python
+import dog
+
+dog = dog.Dog("xiaohei", 1)
+# 属性
+print(dog.name)
+# 方法
+dog.sit()
+```
 
 
+### 继承
 
+一个类继承另一个类时，它将自动获得另一个类的所有属性和方法。       
+
+创建子类实例时，Python首先需要完成的任务是给父类的所有属性赋值。因此，子类的__init__()方法需要调用父类的方法。   
+
+```python
+class Car:
+    def __init__(self, make, model, year):
+        self.make = make
+        self.model = model
+        self.year = year
+
+    def get_des(self):
+        name = str(self.year) + str(self.make) + str(self.model)
+        return name.title()
+
+
+class ElectricCar(Car):
+    def __init__(self, make, model, year, battery):
+        super().__init__(make, model, year)
+        self.battery = battery
+
+    # 重写父类方法
+    def get_des(self):
+        name = str(self.year) + str(self.make) + str(self.model) + str(self.battery)
+        return name.title()
+    def get_battery(self):
+        print("battery : " + str(self.battery))
+
+
+tesla = ElectricCar('Tesla', 'Model S', 2021, 80)
+print(tesla.get_des())
+tesla.get_battery()
+```
 
+- 创建子类时，父类必须包含在当前文件中，且位于子类前面。        
+- 定义子类时，必须在括号内指定父类的名称
+- 方法__init__()接受创建子类实例所需的信息
 
+super()是一个特殊函数，帮助Python将父类和子类关联起来。这行代码让子类包含父类的所有属性。 
diff --git a/VideoDevelopment/.DS_Store b/VideoDevelopment/.DS_Store
deleted file mode 100644
index a4c639de123dfb29e6f4f862ffdadea92d776a31..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6148
zcmeHK%}T>S5Z<-5O({YS3OxqA7ObrlikA>8UIf929#m>Vf(B!@G^sh1LeBa^K8erc
z%<kq840sc<GqC&3&d+Y<gX|Auj62KVkTH`nW<W#asMH9WYh7D97?I04&e*x1r*l6R
ze$7OG(S+aLVi#=ALYA=V_kZ~FI7+j@;FE7Pn%k|m(Kfoqz566`H}kS(>UfJ=99;<!
z`=##r*HM_y%-s`_WL}hn3z-lFA%xuBL`fiWM=X;dmAS5R7#*WCGkdGma6IT+qv2%T
zw^oxO=traRdfhSh_79FPXV39VBHk2{95|P<qp^f{P%1UOx{D+h$s^dyoHCY>7$63S
z0b*eD7|>^d(cQe#sbXS)82Et!+#f7xh_=Q;q1-y4!|OBpn}{f&<68pJ(r9Ze6oLnY
zt5iUh%Jmb2t8}niI?mQuC{*c;%avgsy>j_@;c|7bTQZz+TOswt05MQyprM8)p8u!t
z%hW#dt0^=h28e-w#sF_l-Khgb>9h4)d3e@Z&>o<nU|fL;2<Vkd01R*+=}D*ZTc|^v
Yt+7yuv!Gq31JXr65<(p@@Cyul0VuaiB>(^b


From a902bd854b861f5fd9a53d8d90a3edd02c993154 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 6 May 2024 13:59:51 +0800
Subject: [PATCH 172/213] update python part

---
 .../python3\345\205\245\351\227\250.md"       | 131 +++++++++++++
 .../OpenGL/13.LUT\346\273\244\351\225\234.md" | 182 ++++++++++++++++++
 2 files changed, 313 insertions(+)

diff --git "a/JavaKnowledge/python3\345\205\245\351\227\250.md" "b/JavaKnowledge/python3\345\205\245\351\227\250.md"
index 18b87df7..b3d4ae5f 100644
--- "a/JavaKnowledge/python3\345\205\245\351\227\250.md"
+++ "b/JavaKnowledge/python3\345\205\245\351\227\250.md"
@@ -603,3 +603,134 @@ tesla.get_battery()
 - 方法__init__()接受创建子类实例所需的信息
 
 super()是一个特殊函数，帮助Python将父类和子类关联起来。这行代码让子类包含父类的所有属性。 
+
+
+## 标准库
+
+Python标准库是一组模块，安装的Python都包含它。
+类名应采用驼峰命名法，即将类名中的每个单词的首字母都大写，而不使用下划线。实例名和模块名都采用小写格式，并在单词之间加上下划线。
+每个模块也都应包含一个文档字符串，对其中的类可用于做什么进行描述。
+
+
+### 读取文件
+
+一次性读取整个文件:          
+```python
+with open('test.txt') as file_object:
+    contents = file_object.read()
+    print(contents)
+```
+
+要以每次一行的方式检查文件，可对文件对象使用for循环:     
+
+```python
+filename = 'test.txt'
+with open(filename) as file_object:
+    for line in file_object:
+    print(line)
+```    
+这里使用了关键字with，让Python负责妥善地打开和关闭文件。       
+使用关键字with时，open()返回的文件对象只在with代码块内可用。
+
+
+要将文本写入文件，你在调用open()时需要提供另一个实参，告诉Python你要写入打开的文件。
+
+```python
+filename = 'test.txt'
+
+with open(filename, 'w') as fo:
+    fo.write("Hello World")
+```    
+调用open()时提供了两个实参:       
+
+- 第一个实参是要打开的文件的名称
+- 第二个实参('w')告诉Python，我们要以写入模式打开这个文件。
+
+打开文件时，可指定读取模式('r')、写入模式('w')、附加模式('a')或让你能够读取和写入文件的模式('r+')。如果你省略了模式实参，Python将以默认的只读模式打开文件。      
+如果你要写入的文件不存在，函数open()将自动创建它。然而，以写入('w')模式打开文件时千万要小心，因为如果指定的文件已经存在，Python将在返回文件对象前清空该文件。    
+注意　Python只能将字符串写入文本文件。要将数值数据存储到文本文件中，必须先使用函数str()将其转换为字符串格式。
+
+如果你要给文件添加内容，而不是覆盖原有的内容，可以附加模式打开文件。你以附加模式打开文件时，Python不会在返回文件对象前清空文件，而你写入到文件的行都将添加到文件末尾。如果指定的文件不存在，Python将为你创建一个空文件。   
+
+
+### 异常
+
+异常是使用try-except代码块处理的。try-except代码块让Python执行指定的操作，同时告诉Python发生异常时怎么办。使用了try-except代码块时，即便出现异常，程序也将继续运行：显示你编写的友好的错误消息，而不是令用户迷惑的traceback。
+
+
+### 分割字符串
+
+方法split()以空格为分隔符将字符串分拆成多个部分，并将这些部分都存储到一个列表中。
+
+```python
+title = "Alice in Wonderland"
+title.split()
+```
+
+['Alice','in','Wonderland']
+
+
+### pass
+
+Python有一个pass语句，可在代码块中使用它来让Python什么都不要做。    
+
+
+### json
+
+函数json.dump()接受两个实参：要存储的数据以及可用于存储数据的文件对象。下面演示了如何使用json.dump()来存储数字列表：
+
+```python
+import json
+numbers = [2,3,5,7,11,13]
+filename = 'numbers.json'
+with open(filename,'w') as f_obj:
+    json.dump(numbers,f_obj) 
+```
+
+使用json.load()将这个列表读取到内存中：
+```python
+import json
+filename = 'numbers.json'
+with open(filename) as f_obj:
+    numbers = json.load(f_obj) 
+print(numbers)
+```
+
+### 网络请求
+
+Web API是网站的一部分，用于与使用非常具体的URL请求特定信息的程序交互。这种请求称为API调用。请求的数据将以易于处理的格式（如JSON或CSV）返回。依赖于外部数据源的大多数应用程序都依赖于API调用，如集成社交媒体网站的应用程序。
+
+
+
+requests包让Python程序能够轻松地向网站请求信息以及检查返回的响应。要安装requests，请执行类似于下面的命令：
+
+$pip install --user requests
+或者直接在ide中点击修复安装就可以:  
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/python_install_requests.png)
+
+```python
+import requests
+# 执行API调用并存储响应
+url = 'https://api.github.com/search/repositories?q=language:python&sort=stars'
+r = requests.get(url)
+print("Status code:",r.status_code)
+# 将API响应存储在一个变量中
+response_dict = r.json()
+# 处理结果
+print(response_dict.keys())
+```
+
+执行结果为:    
+```
+Status code: 200
+dict_keys(['total_count', 'incomplete_results', 'items'])
+```
+
+这个API返回JSON格式的信息，因此我们使用方法json()将这些信息转换为一个Python字典。我们将转换得到的字典存储在response_dict中。
+最后，我们打印response_dict中的键。
+
+
+
+
+
diff --git "a/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md" "b/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md"
index 9c15dc6c..0bea9e77 100644
--- "a/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md"
+++ "b/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md"
@@ -1,6 +1,188 @@
 # 13.LUT滤镜
 
 
+LUT全称LookUpTable，也称为颜色查找表，它代表的是一种映射关系，通过LUT可以将输入的像素数组通过映射关系转换输出成另外的像素数组。     
+
+比如一个像素的颜色值分别是R1 G1 B1，经过一次LUT操作后变为R2 G2 B2。    
+
+通过这个映射关系就可以将一个像素的颜色转换为另外一种颜色。
+
+
+LUT从查找方式上可以分为1D LUT和3D LUT:     
+
+- 1D LUT
+
+对于一张RGB图像，每个通道都可以作为一个输入，用公式可以描述如下：
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/lut_1d.jpg)
+
+
+由于颜色值的范围是（0～255），我们可以用`256*3` 的表来表示一个1D LUT，在实际操作中，我们通常以一张`256*3*1`的图片来存储这个映射表，如下，这是一张1D LUT在Mac访达中文件信息图:    
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/lut_1d_map.jpg)
+
+
+由于1D LUT各个通道都是相互独立的，无法对其他通道产生影响，因此1D LUT 只能用来调节亮度/伽马/饱和度/色彩平衡等，如果我们希望对其他通道产生影响，就需要了解另一种滤镜查找方式--3D LUT。
+
+
+
+
+- 3D LUT
+
+ 3D LUT在滤镜中的影响比1D LUT更为深刻，下面我们用一张图（图是网上找的，参考“参考资料”）来说面3D LUT，假设下图的红色平面发生移动，其中对应的绿色和蓝色分量也会发生改变，也就是说，一个颜色通道改变可以影响其他的颜色通道，理论上 3D LUT 可以在立体色彩空间中描述所有颜色调整行为，所以它可以处理任何显示的非线性属性，从简单的 gamma 值、颜色范围和追踪错误，到修正高级的非线性属性、颜色串扰（去耦）、色相、饱和度、亮度等，3D LUT都可以胜任。
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/lut_3d.webp)
+
+常见的3D LUT滤镜文件与.cube或者.3dl都是把3D坐标二维化后的数据表现，如下图
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/3d_lut.jpg)
+
+
+
+
+
+
+
+  我们看到的这些方格子里面的蓝色是固定的，然后每个格子横坐标是红色，纵坐标是绿色，最左上角的格子因为蓝色全无，所以红色和绿色就很明显，而最右下角的那个格子，蓝色色值达到最大，因此整体看上去就非常的蓝。
+
+    对于RGB颜色，每种颜色可以有256种取值，因此一个3D LUT 如果全量表示的话，大小为256*256*256，如果我们有一个大小为256*256*256的3D LUT文件，那么颜色映射将非常简单，只要根据RGB的像素值按照用蓝色找到对应的格子，然后用红色和绿色找到对应格子的横列就可以找到映射的颜色值。但是通常情况下，我们不会这么干，因为一张256*256*256的图实在是太大了，至少需要48MB的存储空间，因此，通常会通过降低采样的方式来减少数据量。
+
+
+
+
+我们看到的这些方格子里面的蓝色是固定的，然后每个格子横坐标是红色，纵坐标是绿色，最左上角的格子因为蓝色全无，所以红色和绿色就很明显，而最右下角的那个格子，蓝色色值达到最大，因此整体看上去就非常的蓝。
+    对于RGB颜色，每种颜色可以有256种取值，因此一个3D LUT 如果全量表示的话，大小为256*256*256，如果我们有一个大小为256*256*256的3D LUT文件，那么颜色映射将非常简单，只要根据RGB的像素值按照用蓝色找到对应的格子，然后用红色和绿色找到对应格子的横列就可以找到映射的颜色值。但是通常情况下，我们不会这么干，因为一张256*256*256的图实在是太大了，至少需要48MB的存储空间，因此，通常会通过降低采样的方式来减少数据量。在专业领域一般认为17x17x17的3D LUT足够适用于预览和监看；65x65x65或者更大的3D LUT更适合渲染和调色。3D LUT的实现在计算机环境会相对容易，在嵌入式环境就意味着成本的提高，越大的LUT需要越昂贵的硬件支持。所以行内比较常用的LUT box一般都不是很大，比如说BMD的HDLink Pro采用了17x17x17的3D LUT（495美元）；Fujifilm的IS-Mini则采用了26x26x26的3D LUT(865英镑)。
+    下面我们就以一个64*64*64的3D LUT为例，来说明一下3D LUT如何查找和使用的（用glsl来实现），一张3D LUT如下：
+
+
+
+
+
+肉眼可见的有8*8个方格，假设整个图的范围我们定义为0.0~1.0 ，也就是说每个格子所表示的范围是1./8. = 0.125, 我们首先通过蓝色来查找我们在哪个方格，由于涉及到插值，因此通过蓝色进行查找的时候，可能不会那么幸运一定映射到整数的格子上面，因此我们需要通过向下取整和向上进位两种方式来获取蓝色所对应的方格，然后通过蓝色的颜色值来mix这两种的颜色值，从而获取最终的颜色值，glsl实现如下：
+
+
+## 为什么使用LUT滤镜
+
+
+
+在正常情况下，8位的RGB颜色模式可以表示的颜色数量为256X256X256种，如果要完全记录这种映射关系，设备需要耗费大量的内存，并且可能在计算时因为计算量大而产生性能问题， 为了简化计算量，降低内存占用，可以将相近的n种颜色采用一条映射记录并存储，(n通常为4)这样只需要64X64X64种就可以表示原来256X256X256的颜色数量，我们也将4称为采样步长。
+要想熟练使用LUT滤镜，我们首先要了解它是怎么建立颜色映射关系的， 我们看下以下这张图，这张图展示了在LUT中RBG颜色是如何实现映射关系的：
+lut映射关系图
+首先这张图的大小是512X512，在横竖方向上这张图都被分成了8个小方格，每个小方格的大小是64X64，也就是一张512X512的图被分割成64个小方格，每个小方格的大小是64X64，这64个小方格就代表了64种B通道的颜色映射， 然后每个B通道的小方格上又是一个64X64像素大小的图像，这个小图像的横坐标代表R分量的64种映射情况，纵坐标代表了G分量的64种映射情况，这样就刚好这就和采样步长是4的映射表对应上了。
+在使用上面这张LUT表的时候首选需要找对B分量对应的小格子，然后在找到的小个子上再计算出R分量和G分量的映射结果即可得到完整的RGB映射结果。
+
+
+
+对输入图颜色转换时，以颜色(rgb)的b值作为索引，找到所属于的小格。
+最后根据r和g的值在小格中定位到映射的目标值上（两个格子上对应的像素进行插值）。
+
+最后根据r和g的值在小格中定位到映射的目标值上（两个格子上对应的像素进行插值）。
+
+
+每个小方格的横向有512 / 8 = 64个像素，表示间距为4的R通道，即R色值序列为0, 4, 8, .....251, 255；纵向同样有64个像素，表示间距为4的G通道；B通道被巧妙的放在大格子中（从左到右，从上到下共64个小方格，表示B通道的64个数值）
+
+
+
+
+整张图从左到右和从上到下为蓝色的渐变，每个小格子从左到右为红色渐变，从上到下为绿色渐变
+
+64只是一种颜色粒度的划分，可以是其它数值，具体的看设计师给出查找表是怎么规划的，此处的粒度为64，也就是将RGB的分量划分为64份，颜色[0.0, 1.0] -> [0.0, 63.0]
+
+
+以一个具体的颜色Color(r = 30.0,  g = 30.0,  b = 25.4)为例子来说明是如何通过LUT来做映射的。
+
+
+
+蓝色值用来定位两个相邻的小格子
+
+第一个小格子：
+
+float blueColor = textureColor.b * 63.0;
+vec2 quad1;
+// blueColor = 25.4, 第3行的第1个小格子
+// floor:向下取整
+quad1.y = floor(floor(blueColor) / 8.0);
+quad1.x = floor(blueColor) - (quad1.y * 8.0);
+
+第二个小格子：
+
+
+vec2 quad2;
+// blueColor = 25.4，第3行的第2个小格子
+// ceil：向上取整
+quad2.y = floor(ceil(blueColor) / 8.0);
+quad2.x = ceil(blueColor) - (quad2.y * 8.0);
+
+红色值和绿色值用来确定相对于整个LUT的纹理坐标:   
+
+vec2 texPos1;
+texPos1.x = (quad1.x * 1.0 / 8.0) + (63.0 / 512.0) * textureColor.r);
+texPos1.y = (quad1.y * 1.0 / 8.0) + (63.0 / 512.0) * textureColor.g);
+
+vec2 texPos2;
+texPos2.x = (quad2.x * 1.0 / 8.0) + (63.0 / 512.0) * textureColor.r);
+texPos2.y = (quad2.y * 1.0 / 8.0) + (63.0 / 512.0) * textureColor.g);
+
+通过纹理坐标获取两个新的颜色:   
+
+vec4 newColor1 = texture2D(u_LookupTable, texPos1);
+vec4 newColor2 = texture2D(u_LookupTable, texPos2);
+
+然后根据蓝色值小数部分作为权重做线性混合，获取最终的颜色输出:   
+
+// mix(x, y, a) -> x * (1 - a) + y * a
+vec4 newColor = mix(newColor1, newColor2, fract(blueColor));
+
+完整的顶点着色器:   
+
+
+attribute vec4 a_Position;
+attribute vec4 a_TextureCoordinate;
+
+varying vec2 vTextureUnitCoordinate;
+
+void main() {
+    gl_Position = a_Position;
+    vTextureUnitCoordinate = a_TextureCoordinate.xy;
+}
+
+
+片元着色器代码
+
+precision mediump float;
+
+uniform sampler2D u_TextureSampler;
+uniform sampler2D u_LookupTable;
+uniform float u_Intensity;
+
+varying vec2 vTextureUnitCoordinate;
+
+void main() {
+    vec4 textureColor = texture2D(u_TextureSampler, vTextureUnitCoordinate);
+    float blueColor = textureColor.b * 63.0;
+    vec2 quad1;
+    quad1.y = floor(floor(blueColor) / 8.0);
+    quad1.x = floor(blueColor) - (quad1.y * 8.0);
+
+    vec2 quad2;
+    quad2.y = floor(ceil(blueColor) / 8.0);
+    quad2.x = ceil(blueColor) - (quad2.y * 8.0);
+
+    vec2 texPos1;
+    texPos1.x = (quad1.x * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * textureColor.r);
+    texPos1.y = (quad1.y * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * textureColor.g);
+
+    vec2 texPos2;
+    texPos2.x = (quad2.x * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * textureColor.r);
+    texPos2.y = (quad2.y * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * textureColor.g);
+
+    vec4 newColor1 = texture2D(u_LookupTable, texPos1);
+    vec4 newColor2 = texture2D(u_LookupTable, texPos2);
+
+    vec4 newColor = mix(newColor1, newColor2, fract(blueColor));
+    gl_FragColor = mix(textureColor, vec4(newColor.rgb, textureColor.w), u_Intensity);
+}
+
+
 
 
 

From 65a5f1438f0c569ef573a98f0d214dfec0f3b4ba Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 6 May 2024 14:11:57 +0800
Subject: [PATCH 173/213] update

---
 .../OpenGL/13.LUT\346\273\244\351\225\234.md" | 21 +++++++++----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git "a/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md" "b/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md"
index 0bea9e77..d97b22b1 100644
--- "a/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md"
+++ "b/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md"
@@ -1,36 +1,35 @@
 # 13.LUT滤镜
 
 
-LUT全称LookUpTable，也称为颜色查找表，它代表的是一种映射关系，通过LUT可以将输入的像素数组通过映射关系转换输出成另外的像素数组。     
+LUT全称Look Up Table，也称为颜色查找表。       
 
-比如一个像素的颜色值分别是R1 G1 B1，经过一次LUT操作后变为R2 G2 B2。    
+它代表的是一种映射关系，通过LUT可以将输入的像素数组通过映射关系转换输出成另外的像素数组。     
 
-通过这个映射关系就可以将一个像素的颜色转换为另外一种颜色。
+比如一个像素的颜色值分别是R1 G1 B1，经过一次LUT操作后变为R2 G2 B2。    
 
 
 LUT从查找方式上可以分为1D LUT和3D LUT:     
 
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/lut_1dvs3d.webp)
+
 - 1D LUT
 
-对于一张RGB图像，每个通道都可以作为一个输入，用公式可以描述如下：
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/lut_1d.jpg)
+对于一张RGB图像，每个通道都可以作为一个输入，用公式可以描述如下:     
 
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/lut_1d.jpg)
 
 由于颜色值的范围是（0～255），我们可以用`256*3` 的表来表示一个1D LUT，在实际操作中，我们通常以一张`256*3*1`的图片来存储这个映射表，如下，这是一张1D LUT在Mac访达中文件信息图:    
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/lut_1d_map.jpg)
 
-
-由于1D LUT各个通道都是相互独立的，无法对其他通道产生影响，因此1D LUT 只能用来调节亮度/伽马/饱和度/色彩平衡等，如果我们希望对其他通道产生影响，就需要了解另一种滤镜查找方式--3D LUT。
-
-
+由于1D LUT各个通道都是相互独立的，无法对其他通道产生影响，因此1D LUT只能用来调节亮度/伽马/饱和度/色彩平衡等，如果我们希望对其他通道产生影响，就需要了解另一种滤镜查找方式--3D LUT。    
 
 
 - 3D LUT
 
- 3D LUT在滤镜中的影响比1D LUT更为深刻，下面我们用一张图（图是网上找的，参考“参考资料”）来说面3D LUT，假设下图的红色平面发生移动，其中对应的绿色和蓝色分量也会发生改变，也就是说，一个颜色通道改变可以影响其他的颜色通道，理论上 3D LUT 可以在立体色彩空间中描述所有颜色调整行为，所以它可以处理任何显示的非线性属性，从简单的 gamma 值、颜色范围和追踪错误，到修正高级的非线性属性、颜色串扰（去耦）、色相、饱和度、亮度等，3D LUT都可以胜任。
+3D LUT在滤镜中的影响比1D LUT更为深刻，假设上图3D中的红色平面发生移动，其中对应的绿色和蓝色分量也会发生改变，也就是说，一个颜色通道改变可以影响其他的颜色通道。      
 
+理论上3D LUT可以在立体色彩空间中描述所有颜色调整行为，所以它可以处理任何显示的非线性属性，从简单的gamma值、颜色范围和追踪错误，到修正高级的非线性属性、颜色串扰（去耦）、色相、饱和度、亮度等，3D LUT都可以胜任。
 
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/lut_3d.webp)
 
 常见的3D LUT滤镜文件与.cube或者.3dl都是把3D坐标二维化后的数据表现，如下图
 

From 2e70e73040908ed779ff54489ad28b1c269e72e2 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 6 May 2024 15:32:30 +0800
Subject: [PATCH 174/213] update LUT

---
 .../OpenGL/13.LUT\346\273\244\351\225\234.md" | 88 ++++++++++---------
 1 file changed, 45 insertions(+), 43 deletions(-)

diff --git "a/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md" "b/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md"
index d97b22b1..2653ce59 100644
--- "a/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md"
+++ "b/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md"
@@ -36,83 +36,78 @@ LUT从查找方式上可以分为1D LUT和3D LUT:
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/3d_lut.jpg)
 
 
+我们看到的这些方格子里面的蓝色是固定的，然后每个格子横坐标是红色，纵坐标是绿色，最左上角的格子因为蓝色全无，所以红色和绿色就很明显，而最右下角的那个格子，蓝色色值达到最大，因此整体看上去就非常的蓝(从左上角的格子到右下角的格子，一共是8行8列，正好是64个格子)。
 
 
+### 为什么是64x64
 
+对于RGB颜色，每种颜色可以有256种取值，因此一个3D LUT 如果全量表示的话，大小为`256*256*256`，如果我们有一个大小为`256*256*256`的3D LUT文件，那么颜色映射将非常简单，只要根据RGB的像素值按照用蓝色找到对应的格子，然后用红色和绿色找到对应格子的横列就可以找到映射的颜色值。但是通常情况下，我们不会这么干，因为一张`256*256*256`的图实在是太大了，至少需要48MB的存储空间。
 
+如果要完全记录这种映射关系，设备需要耗费大量的内存，并且可能在计算时因为计算量大而产生性能问题， 为了简化计算量，降低内存占用，可以将相近的n种颜色采用一条映射记录并存储，(n通常为4)这样只需要64X64X64种就可以表示原来256X256X256的颜色数量，我们也将4称为采样步长。
 
-  我们看到的这些方格子里面的蓝色是固定的，然后每个格子横坐标是红色，纵坐标是绿色，最左上角的格子因为蓝色全无，所以红色和绿色就很明显，而最右下角的那个格子，蓝色色值达到最大，因此整体看上去就非常的蓝。
+在专业领域一般认为17x17x17的3D LUT足够适用于预览和监看；65x65x65或者更大的3D LUT更适合渲染和调色。     
 
-    对于RGB颜色，每种颜色可以有256种取值，因此一个3D LUT 如果全量表示的话，大小为256*256*256，如果我们有一个大小为256*256*256的3D LUT文件，那么颜色映射将非常简单，只要根据RGB的像素值按照用蓝色找到对应的格子，然后用红色和绿色找到对应格子的横列就可以找到映射的颜色值。但是通常情况下，我们不会这么干，因为一张256*256*256的图实在是太大了，至少需要48MB的存储空间，因此，通常会通过降低采样的方式来减少数据量。
 
+### 3D LUT映射
 
+要想熟练使用LUT滤镜，我们首先要了解它是怎么建立颜色映射关系的， 我们看下以下这张图，这张图展示了在LUT中RBG颜色是如何实现映射关系的:       
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/lut.png)
 
+首先这张图的大小是512X512，在横竖方向上这张图都被分成了8个小方格(64只是一种颜色粒度的划分，可以是其它数值，具体的看设计师给出查找表是怎么规划的，此处的粒度为64，也就是将RGB的分量划分为64份，颜色[0.0, 1.0] -> [0.0, 63.0]):      
 
-我们看到的这些方格子里面的蓝色是固定的，然后每个格子横坐标是红色，纵坐标是绿色，最左上角的格子因为蓝色全无，所以红色和绿色就很明显，而最右下角的那个格子，蓝色色值达到最大，因此整体看上去就非常的蓝。
-    对于RGB颜色，每种颜色可以有256种取值，因此一个3D LUT 如果全量表示的话，大小为256*256*256，如果我们有一个大小为256*256*256的3D LUT文件，那么颜色映射将非常简单，只要根据RGB的像素值按照用蓝色找到对应的格子，然后用红色和绿色找到对应格子的横列就可以找到映射的颜色值。但是通常情况下，我们不会这么干，因为一张256*256*256的图实在是太大了，至少需要48MB的存储空间，因此，通常会通过降低采样的方式来减少数据量。在专业领域一般认为17x17x17的3D LUT足够适用于预览和监看；65x65x65或者更大的3D LUT更适合渲染和调色。3D LUT的实现在计算机环境会相对容易，在嵌入式环境就意味着成本的提高，越大的LUT需要越昂贵的硬件支持。所以行内比较常用的LUT box一般都不是很大，比如说BMD的HDLink Pro采用了17x17x17的3D LUT（495美元）；Fujifilm的IS-Mini则采用了26x26x26的3D LUT(865英镑)。
-    下面我们就以一个64*64*64的3D LUT为例，来说明一下3D LUT如何查找和使用的（用glsl来实现），一张3D LUT如下：
+- 每个小方格的大小是64X64，也就是一张512X512的图被分割成64个小方格
+- 每个小方格的大小是64X64，这64个小方格就代表了64种B通道的颜色映射
+- 然后每个B通道的小方格上又是一个64X64像素大小的图像，这个小图像的横坐标代表R分量的64种映射情况，纵坐标代表了G分量的64种映射情况
 
+这样就刚好这就和采样步长是4的映射表对应上了。
 
+**在使用上面这张LUT表的时候首选需要找对B分量对应的小格子，然后在找到的小个子上再计算出R分量和G分量的映射结果即可得到完整的RGB映射结果。**
 
 
 
-肉眼可见的有8*8个方格，假设整个图的范围我们定义为0.0~1.0 ，也就是说每个格子所表示的范围是1./8. = 0.125, 我们首先通过蓝色来查找我们在哪个方格，由于涉及到插值，因此通过蓝色进行查找的时候，可能不会那么幸运一定映射到整数的格子上面，因此我们需要通过向下取整和向上进位两种方式来获取蓝色所对应的方格，然后通过蓝色的颜色值来mix这两种的颜色值，从而获取最终的颜色值，glsl实现如下：
+下面我们就以一个`64*64*64`的3D LUT为例，来说明一下3D LUT如何查找和使用的（用glsl来实现）:     
 
+- 整张图从左到右和从上到下为蓝色的渐变，每个小格子从左到右为红色渐变，从上到下为绿色渐变
+- 肉眼可见的有8*8个方格，假设整个图的范围我们定义为0.0~1.0 ，也就是说每个格子所表示的范围是1./8. = 0.125
+- 我们首先通过蓝色来查找我们在哪个方格，由于涉及到插值，因此通过蓝色进行查找的时候，可能不会那么幸运一定映射到整数的格子上面，因此我们需要通过向下取整和向上进位两种方式来获取蓝色所对应的方格，然后通过蓝色的颜色值来mix这两种的颜色值，从而获取最终的颜色值。   
 
-## 为什么使用LUT滤镜
 
+### 映射示例
 
+以一个具体的颜色Color(r=30.0, g=30.0, b=25.4)为例子来说明是如何通过LUT来做映射的。
 
-在正常情况下，8位的RGB颜色模式可以表示的颜色数量为256X256X256种，如果要完全记录这种映射关系，设备需要耗费大量的内存，并且可能在计算时因为计算量大而产生性能问题， 为了简化计算量，降低内存占用，可以将相近的n种颜色采用一条映射记录并存储，(n通常为4)这样只需要64X64X64种就可以表示原来256X256X256的颜色数量，我们也将4称为采样步长。
-要想熟练使用LUT滤镜，我们首先要了解它是怎么建立颜色映射关系的， 我们看下以下这张图，这张图展示了在LUT中RBG颜色是如何实现映射关系的：
-lut映射关系图
-首先这张图的大小是512X512，在横竖方向上这张图都被分成了8个小方格，每个小方格的大小是64X64，也就是一张512X512的图被分割成64个小方格，每个小方格的大小是64X64，这64个小方格就代表了64种B通道的颜色映射， 然后每个B通道的小方格上又是一个64X64像素大小的图像，这个小图像的横坐标代表R分量的64种映射情况，纵坐标代表了G分量的64种映射情况，这样就刚好这就和采样步长是4的映射表对应上了。
-在使用上面这张LUT表的时候首选需要找对B分量对应的小格子，然后在找到的小个子上再计算出R分量和G分量的映射结果即可得到完整的RGB映射结果。
+#### 1.1 寻找B值的两个格子
 
+B值对应的是0 ~ 63，共64个格子，在计算时，并不一定会是一个整数，对应到某一个格子，大概率会是一个小数，为了能够更精确的进行映射，需要使用两个格子，然后根据小数(因子)进行插值计算，从而能够更精确。    
 
+##### 蓝色值用来定位两个相邻的小格子
 
-对输入图颜色转换时，以颜色(rgb)的b值作为索引，找到所属于的小格。
-最后根据r和g的值在小格中定位到映射的目标值上（两个格子上对应的像素进行插值）。
-
-最后根据r和g的值在小格中定位到映射的目标值上（两个格子上对应的像素进行插值）。
-
-
-每个小方格的横向有512 / 8 = 64个像素，表示间距为4的R通道，即R色值序列为0, 4, 8, .....251, 255；纵向同样有64个像素，表示间距为4的G通道；B通道被巧妙的放在大格子中（从左到右，从上到下共64个小方格，表示B通道的64个数值）
-
-
-
-
-整张图从左到右和从上到下为蓝色的渐变，每个小格子从左到右为红色渐变，从上到下为绿色渐变
-
-64只是一种颜色粒度的划分，可以是其它数值，具体的看设计师给出查找表是怎么规划的，此处的粒度为64，也就是将RGB的分量划分为64份，颜色[0.0, 1.0] -> [0.0, 63.0]
-
-
-以一个具体的颜色Color(r = 30.0,  g = 30.0,  b = 25.4)为例子来说明是如何通过LUT来做映射的。
-
-
-
-蓝色值用来定位两个相邻的小格子
-
-第一个小格子：
+- 第一个小格子:         
 
+```python
 float blueColor = textureColor.b * 63.0;
 vec2 quad1;
 // blueColor = 25.4, 第3行的第1个小格子
 // floor:向下取整
 quad1.y = floor(floor(blueColor) / 8.0);
 quad1.x = floor(blueColor) - (quad1.y * 8.0);
+```
 
-第二个小格子：
-
+- 第二个小格子:     
 
+```python
 vec2 quad2;
 // blueColor = 25.4，第3行的第2个小格子
 // ceil：向上取整
 quad2.y = floor(ceil(blueColor) / 8.0);
 quad2.x = ceil(blueColor) - (quad2.y * 8.0);
+```
+
+##### 确定每个格子对应的R G值
 
 红色值和绿色值用来确定相对于整个LUT的纹理坐标:   
 
+```python
 vec2 texPos1;
 texPos1.x = (quad1.x * 1.0 / 8.0) + (63.0 / 512.0) * textureColor.r);
 texPos1.y = (quad1.y * 1.0 / 8.0) + (63.0 / 512.0) * textureColor.g);
@@ -120,20 +115,26 @@ texPos1.y = (quad1.y * 1.0 / 8.0) + (63.0 / 512.0) * textureColor.g);
 vec2 texPos2;
 texPos2.x = (quad2.x * 1.0 / 8.0) + (63.0 / 512.0) * textureColor.r);
 texPos2.y = (quad2.y * 1.0 / 8.0) + (63.0 / 512.0) * textureColor.g);
+```
 
-通过纹理坐标获取两个新的颜色:   
+##### 通过纹理坐标获取两个新的颜色   
 
+```python
 vec4 newColor1 = texture2D(u_LookupTable, texPos1);
 vec4 newColor2 = texture2D(u_LookupTable, texPos2);
+```
+
+##### 然后根据蓝色值小数部分作为权重做线性混合，获取最终的颜色输出
 
-然后根据蓝色值小数部分作为权重做线性混合，获取最终的颜色输出:   
 
+```python
 // mix(x, y, a) -> x * (1 - a) + y * a
 vec4 newColor = mix(newColor1, newColor2, fract(blueColor));
+```
 
 完整的顶点着色器:   
 
-
+```python
 attribute vec4 a_Position;
 attribute vec4 a_TextureCoordinate;
 
@@ -143,10 +144,11 @@ void main() {
     gl_Position = a_Position;
     vTextureUnitCoordinate = a_TextureCoordinate.xy;
 }
+```
 
+片元着色器代码:     
 
-片元着色器代码
-
+```python
 precision mediump float;
 
 uniform sampler2D u_TextureSampler;
@@ -180,7 +182,7 @@ void main() {
     vec4 newColor = mix(newColor1, newColor2, fract(blueColor));
     gl_FragColor = mix(textureColor, vec4(newColor.rgb, textureColor.w), u_Intensity);
 }
-
+```
 
 
 

From 13a341266ec8d2a02ca421136dc2bf6eb5e5a47a Mon Sep 17 00:00:00 2001
From: xuchuanren <charon.chui@gmail.com>
Date: Tue, 7 May 2024 19:59:32 +0800
Subject: [PATCH 175/213] update Lut

---
 .../OpenGL/13.LUT\346\273\244\351\225\234.md" | 91 +++++++++++++++----
 1 file changed, 74 insertions(+), 17 deletions(-)

diff --git "a/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md" "b/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md"
index 2653ce59..ed005e2e 100644
--- "a/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md"
+++ "b/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md"
@@ -41,27 +41,34 @@ LUT从查找方式上可以分为1D LUT和3D LUT:
 
 ### 为什么是64x64
 
-对于RGB颜色，每种颜色可以有256种取值，因此一个3D LUT 如果全量表示的话，大小为`256*256*256`，如果我们有一个大小为`256*256*256`的3D LUT文件，那么颜色映射将非常简单，只要根据RGB的像素值按照用蓝色找到对应的格子，然后用红色和绿色找到对应格子的横列就可以找到映射的颜色值。但是通常情况下，我们不会这么干，因为一张`256*256*256`的图实在是太大了，至少需要48MB的存储空间。
+对于RGB颜色，每种颜色可以有256(0 ~ 255)种取值，而每个颜色占用3个字节，因此一个3D LUT如果全量表示的话，大小为`256*256*256*3`个字节，即48M内存空间。      
 
-如果要完全记录这种映射关系，设备需要耗费大量的内存，并且可能在计算时因为计算量大而产生性能问题， 为了简化计算量，降低内存占用，可以将相近的n种颜色采用一条映射记录并存储，(n通常为4)这样只需要64X64X64种就可以表示原来256X256X256的颜色数量，我们也将4称为采样步长。
+如果我们有一个大小为`256*256*256*3`的3D LUT文件，那么颜色映射将非常简单，只要根据RGB的像素值按照用蓝色找到对应的格子，然后用红色和绿色找到对应格子的横列就可以找到映射的颜色值。
 
-在专业领域一般认为17x17x17的3D LUT足够适用于预览和监看；65x65x65或者更大的3D LUT更适合渲染和调色。     
+但是通常情况下，我们不会这么干，因为一张图48M存储空间实在是太大了。
+
+如果要完全记录这种映射关系，设备需要耗费大量的内存，并且可能在计算时因为计算量大而产生性能问题， 为了简化计算量，降低内存占用，可以将相近的n种颜色采用一条映射记录并存储，(采样步长，n通常为4)，这样只需要`64 * 64 * 64 * 3`个字节就可以表示原来`256 * 256 * 256 * 3`的颜色数量，我们也将4称为采样步长。
+
+对于忽略的颜色值可以进行插值获得其相似结果。    
+
+在专业领域一般认为`16 * 16 * 16`的3D LUT足够适用于预览和监看。     
+`64 * 64 * 64`或者更大的3D LUT更适合渲染和调色。     
 
 
 ### 3D LUT映射
 
-要想熟练使用LUT滤镜，我们首先要了解它是怎么建立颜色映射关系的， 我们看下以下这张图，这张图展示了在LUT中RBG颜色是如何实现映射关系的:       
-![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/lut.png)
+要想熟练使用LUT滤镜，我们首先要了解它是怎么建立颜色映射关系的， 我们看下以下这张图，这张图展示了在LUT中RBG颜色是如何实现映射关系的:  
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/3d_lut_convert_1.png)     
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/lut.jpg)
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/lut_rg.jpg)
+
 
-首先这张图的大小是512X512，在横竖方向上这张图都被分成了8个小方格(64只是一种颜色粒度的划分，可以是其它数值，具体的看设计师给出查找表是怎么规划的，此处的粒度为64，也就是将RGB的分量划分为64份，颜色[0.0, 1.0] -> [0.0, 63.0]):      
+- LUT图在横竖方向上被分成了8 X 8一共64个小方格，每一个小方格内的B（Blue）分量为一个定值，64 个小方格一共表示了B分量的64种取值。
 
-- 每个小方格的大小是64X64，也就是一张512X512的图被分割成64个小方格
-- 每个小方格的大小是64X64，这64个小方格就代表了64种B通道的颜色映射
-- 然后每个B通道的小方格上又是一个64X64像素大小的图像，这个小图像的横坐标代表R分量的64种映射情况，纵坐标代表了G分量的64种映射情况
+- 对于每一个小方格，横竖方向又各自分为64个小格:以左上角为原点，横向小格的 R（Red）分量依次增加，纵向小格的 G（Green）分量依次增加
 
-这样就刚好这就和采样步长是4的映射表对应上了。
 
-**在使用上面这张LUT表的时候首选需要找对B分量对应的小格子，然后在找到的小个子上再计算出R分量和G分量的映射结果即可得到完整的RGB映射结果。**
+**在使用上面这张LUT表的时候首选需要找对B分量对应的小格子，然后在找到的小格子上再计算出R分量和G分量的映射结果即可得到完整的RGB映射结果。**
 
 
 
@@ -82,6 +89,16 @@ B值对应的是0 ~ 63，共64个格子，在计算时，并不一定会是一
 
 ##### 蓝色值用来定位两个相邻的小格子
 
+- 首先是对原图进行像素采样
+
+```glsl`
+vec4 textureColor = texture2D(vTexture, v_TextureCoord);
+```
+
+textureColor.b是一个0 - 1之间的浮点数，乘以63用来确定B分量所在的格子.      
+因为会出现浮点误差，所以才需要取两个B分量，也就是下一步的取与B分量值最接近的2个小方格的坐标，最后根据小数点进行插值运算。
+
+
 - 第一个小格子:         
 
 ```python
@@ -105,18 +122,51 @@ quad2.x = ceil(blueColor) - (quad2.y * 8.0);
 
 ##### 确定每个格子对应的R G值
 
+每个B格子代表的纹理坐标长度是 1/8 = 0.125
+63 * textureColor.r是将当前实际像素的r值映射到0 ~ 63，再除以512是转化为纹理坐标中实际的点，LUT图的分辨率为`512*512`
+
 红色值和绿色值用来确定相对于整个LUT的纹理坐标:   
 
-```python
+```glsl
+
 vec2 texPos1;
-texPos1.x = (quad1.x * 1.0 / 8.0) + (63.0 / 512.0) * textureColor.r);
-texPos1.y = (quad1.y * 1.0 / 8.0) + (63.0 / 512.0) * textureColor.g);
+texPos1.x = (quad1.x * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * textureColor.r);
+texPos1.y = (quad1.y * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * textureColor.g);
+
 
 vec2 texPos2;
-texPos2.x = (quad2.x * 1.0 / 8.0) + (63.0 / 512.0) * textureColor.r);
-texPos2.y = (quad2.y * 1.0 / 8.0) + (63.0 / 512.0) * textureColor.g);
+texPos2.x = (quad2.x * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * textureColor.r);
+texPos2.y = (quad2.y * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * textureColor.g);
 ```
 
+- 上面texPos1.x，texPos1.y代表的是在0-1的纹理坐标中改点(texPos1)的具体坐标。  
+- `(quad1.x * 0.125)`指的是在纹理坐标中的左上角的归一化坐标
+    - quad1.x代表当前格子在`8*8`的格子中横坐标的第几个，这个`8*8`的格子构成了0-1的纹理空间，所以一个格子代表的纹理坐标长度就是 1/8 = 0.125
+    - 所以第几个格子就代表了具有几个0.125这样的纹理长度
+    - 所以`(quad1.x * 0.125)`指的就是当前格子的**左上角**在纹理坐标系中的横坐标的具体坐标点。
+
+    ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/3dlut_zuoshangjiao.jpg)
+
+- `((0.125 - 1.0/512.0) * textureColor.r)`
+
+这段代码可能是最看不懂的一段了，其实是这里是一个计算步骤的省略如下:      
+`((0.125 - 1.0/512.0) * textureColor.r) = （（64-1）* textureColor.r）/512`这样就可以理解了，
+`（64-1）* textureColor.r`意思是首先将当前实际像素的r值映射到0-63的范围内。       
+除以512是转化为纹理坐标中实际的点。（`纹理的分辨率为512*512`）
+
+这个步骤结束就在这一个小方格中根据R分量和G分量又确定了更小的一个方格的左上角的坐标点。如下图
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/3dlut_2.jpg)    
+
+- 0.5/512.0
+
+这个就很好理解了，因为上面算出来的结果都是小方格的左上角坐标，加上小方格横纵的一半坐标就是将该点移动到了小方格中心。   
+
+
+
+
+    
+
 ##### 通过纹理坐标获取两个新的颜色   
 
 ```python
@@ -127,11 +177,18 @@ vec4 newColor2 = texture2D(u_LookupTable, texPos2);
 ##### 然后根据蓝色值小数部分作为权重做线性混合，获取最终的颜色输出
 
 
-```python
+```glsl
 // mix(x, y, a) -> x * (1 - a) + y * a
+// 使用mix方法对2个边界像素值进行插值混合
+// 根据浮点数到整点的距离来计算其对应的颜色值，fract函数是指小数部分。
 vec4 newColor = mix(newColor1, newColor2, fract(blueColor));
+
+// 将原图与映射后的图进行插值混合
+// 这次的插值混合是实现我们常见的滤镜调节功能，adjust调节的范围是(0-1)，取0时完全使用原图，取1时完全使用映射后的滤镜图
+gl_FragColor = mix(textureColor, vec4(newColor.rgb, textureColor.w), adjust);
 ```
 
+
 完整的顶点着色器:   
 
 ```python

From 6d20d9562333beb6e3d0160adf22c9da50fe6ece Mon Sep 17 00:00:00 2001
From: xuchuanren <charon.chui@gmail.com>
Date: Tue, 7 May 2024 20:00:55 +0800
Subject: [PATCH 176/213] remove swp file

---
 .../.1.OpenGL\347\256\200\344\273\213.md.swp"   | Bin 69632 -> 0 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 delete mode 100644 "VideoDevelopment/OpenGL/.1.OpenGL\347\256\200\344\273\213.md.swp"

diff --git "a/VideoDevelopment/OpenGL/.1.OpenGL\347\256\200\344\273\213.md.swp" "b/VideoDevelopment/OpenGL/.1.OpenGL\347\256\200\344\273\213.md.swp"
deleted file mode 100644
index ec4ff252dcbbc9f4474238143addba1def69c816..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 69632
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
K{Eh!``hNw5CD)Sx


From 30c5e78bfd1f4806956daaf382fa877ba3e3d70d Mon Sep 17 00:00:00 2001
From: xuchuanren <charon.chui@gmail.com>
Date: Wed, 8 May 2024 13:41:56 +0800
Subject: [PATCH 177/213] update opengl part

---
 .../1.OpenGL\347\256\200\344\273\213.md"      |   4 +-
 ...55\346\224\276\350\247\206\351\242\221.md" |   5 +-
 .../11.OpenGL ES\346\273\244\351\225\234.md"  |   6 +-
 VideoDevelopment/OpenGL/12.FBO.md             |   5 +-
 .../OpenGL/13.LUT\346\273\244\351\225\234.md" | 106 +++++++-----------
 ...4.\345\256\236\344\276\213\345\214\226.md" |   3 +-
 ....GLSurfaceView\347\256\200\344\273\213.md" |   6 +-
 ...20\347\240\201\350\247\243\346\236\220.md" |   6 +-
 ....GLTextureView\345\256\236\347\216\260.md" |   7 +-
 ...66\344\270\211\350\247\222\345\275\242.md" |   6 +-
 ...42\345\217\212\345\234\206\345\275\242.md" |   5 +-
 ...45\231\250\350\257\255\350\250\200GLSL.md" |   5 +-
 ...\261\273\345\217\212Matrix\347\261\273.md" |   6 +-
 .../9.OpenGL ES\347\272\271\347\220\206.md"   |   5 +-
 14 files changed, 83 insertions(+), 92 deletions(-)

diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
index 61803e2e..5f45c5d2 100644
--- "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -645,9 +645,9 @@ Pbuffer最常用于生成纹理贴图。如果你想要做的是渲染到一个
 
 
 
+--- 
 
-
-[下一篇: 2.GLSurfaceView简介](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/2.GLSurfaceView%E7%AE%80%E4%BB%8B.md)
+- [下一篇: 2.GLSurfaceView简介](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/2.GLSurfaceView%E7%AE%80%E4%BB%8B.md)
 
 ---
 
diff --git "a/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md" "b/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
index c1c347da..0eb4f1b9 100644
--- "a/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
+++ "b/VideoDevelopment/OpenGL/10.GLSurfaceView+MediaPlayer\346\222\255\346\224\276\350\247\206\351\242\221.md"
@@ -325,9 +325,10 @@ public class VideoPlayerRender extends BaseGLSurfaceViewRenderer {
 
 
 
+---
+- [上一篇: 9.OpenGL ES纹理](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/9.OpenGL%20ES%E7%BA%B9%E7%90%86.md)  
 
-[上一篇: 9.OpenGL ES纹理](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/9.OpenGL%20ES%E7%BA%B9%E7%90%86.md)  
-[下一篇: 11.OpenGL ES滤镜](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/11.OpenGL%20ES%E6%BB%A4%E9%95%9C.md)
+- [下一篇: 11.OpenGL ES滤镜](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/11.OpenGL%20ES%E6%BB%A4%E9%95%9C.md)
 
 ---
 
diff --git "a/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md" "b/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"
index 366ebbb3..ac2ff34d 100644
--- "a/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"	
+++ "b/VideoDevelopment/OpenGL/11.OpenGL ES\346\273\244\351\225\234.md"	
@@ -401,8 +401,10 @@ public class BaseFilter {
 
 
 
-[上一篇: 10.GLSurfaceView+MediaPlayer播放视频](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md)
-[下一篇: 12.FBO](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/12.FBO.md)
+---
+- [上一篇: 10.GLSurfaceView+MediaPlayer播放视频](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md)
+
+- [下一篇: 12.FBO](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/12.FBO.md)
 
 ---
 
diff --git a/VideoDevelopment/OpenGL/12.FBO.md b/VideoDevelopment/OpenGL/12.FBO.md
index dc4d71bc..736c7f9c 100644
--- a/VideoDevelopment/OpenGL/12.FBO.md
+++ b/VideoDevelopment/OpenGL/12.FBO.md
@@ -21,9 +21,10 @@ Android OpenGL ES开发中，一般使用GLSurfaceView将绘制结果显示到
 
 
 
+---
+- [上一篇: 11.OpenGL ES滤镜](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/11.OpenGL%20ES%E6%BB%A4%E9%95%9C.md)
 
-[上一篇: 11.OpenGL ES滤镜](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/11.OpenGL%20ES%E6%BB%A4%E9%95%9C.md)
-[下一篇: 13.LUT滤镜](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/13.LUT%E6%BB%A4%E9%95%9C.md)
+- [下一篇: 13.LUT滤镜](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/13.LUT%E6%BB%A4%E9%95%9C.md)
 
 ---
 
diff --git "a/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md" "b/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md"
index ed005e2e..d02b6e97 100644
--- "a/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md"
+++ "b/VideoDevelopment/OpenGL/13.LUT\346\273\244\351\225\234.md"
@@ -81,7 +81,6 @@ LUT从查找方式上可以分为1D LUT和3D LUT:
 
 ### 映射示例
 
-以一个具体的颜色Color(r=30.0, g=30.0, b=25.4)为例子来说明是如何通过LUT来做映射的。
 
 #### 1.1 寻找B值的两个格子
 
@@ -91,18 +90,20 @@ B值对应的是0 ~ 63，共64个格子，在计算时，并不一定会是一
 
 - 首先是对原图进行像素采样
 
-```glsl`
-vec4 textureColor = texture2D(vTexture, v_TextureCoord);
+```glsl
+vec4 textureColor = texture(s_texture, v_texCoord);
 ```
 
-textureColor.b是一个0 - 1之间的浮点数，乘以63用来确定B分量所在的格子.      
+textureColor.b是一个0 - 1之间的浮点数，乘以63用来确定B分量所在的格子.       
 因为会出现浮点误差，所以才需要取两个B分量，也就是下一步的取与B分量值最接近的2个小方格的坐标，最后根据小数点进行插值运算。
 
 
 - 第一个小格子:         
 
 ```python
-float blueColor = textureColor.b * 63.0;
+vec4 color = texture(s_texture, v_texCoord);
+float blueColor = color.b * 63.0;
+
 vec2 quad1;
 // blueColor = 25.4, 第3行的第1个小格子
 // floor:向下取整
@@ -120,7 +121,9 @@ quad2.y = floor(ceil(blueColor) / 8.0);
 quad2.x = ceil(blueColor) - (quad2.y * 8.0);
 ```
 
-##### 确定每个格子对应的R G值
+##### 确定每个格子内具体点对应的色值
+
+通过R和G分量的值确定小方格内目标映射的RGB组合的坐标，然后归一化，转化为纹理坐标。
 
 每个B格子代表的纹理坐标长度是 1/8 = 0.125
 63 * textureColor.r是将当前实际像素的r值映射到0 ~ 63，再除以512是转化为纹理坐标中实际的点，LUT图的分辨率为`512*512`
@@ -130,16 +133,15 @@ quad2.x = ceil(blueColor) - (quad2.y * 8.0);
 ```glsl
 
 vec2 texPos1;
-texPos1.x = (quad1.x * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * textureColor.r);
-texPos1.y = (quad1.y * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * textureColor.g);
-
+texPos1.x = (quad1.x * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * color.r);
+texPos1.y = (quad1.y * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * color.g);
 
 vec2 texPos2;
-texPos2.x = (quad2.x * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * textureColor.r);
-texPos2.y = (quad2.y * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * textureColor.g);
+texPos2.x = (quad2.x * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * color.r);
+texPos2.y = (quad2.y * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * color.g);
 ```
 
-- 上面texPos1.x，texPos1.y代表的是在0-1的纹理坐标中改点(texPos1)的具体坐标。  
+- 上面texPos1.x，texPos1.y代表的是在0-1的纹理坐标中该点(texPos1)的具体坐标。  
 - `(quad1.x * 0.125)`指的是在纹理坐标中的左上角的归一化坐标
     - quad1.x代表当前格子在`8*8`的格子中横坐标的第几个，这个`8*8`的格子构成了0-1的纹理空间，所以一个格子代表的纹理坐标长度就是 1/8 = 0.125
     - 所以第几个格子就代表了具有几个0.125这样的纹理长度
@@ -169,9 +171,9 @@ texPos2.y = (quad2.y * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * textureColor.
 
 ##### 通过纹理坐标获取两个新的颜色   
 
-```python
-vec4 newColor1 = texture2D(u_LookupTable, texPos1);
-vec4 newColor2 = texture2D(u_LookupTable, texPos2);
+```glsl
+vec4 newColor1 = texture(textureLUT, texPos1);
+vec4 newColor2 = texture(textureLUT, texPos2);
 ```
 
 ##### 然后根据蓝色值小数部分作为权重做线性混合，获取最终的颜色输出
@@ -182,71 +184,56 @@ vec4 newColor2 = texture2D(u_LookupTable, texPos2);
 // 使用mix方法对2个边界像素值进行插值混合
 // 根据浮点数到整点的距离来计算其对应的颜色值，fract函数是指小数部分。
 vec4 newColor = mix(newColor1, newColor2, fract(blueColor));
-
 // 将原图与映射后的图进行插值混合
 // 这次的插值混合是实现我们常见的滤镜调节功能，adjust调节的范围是(0-1)，取0时完全使用原图，取1时完全使用映射后的滤镜图
 gl_FragColor = mix(textureColor, vec4(newColor.rgb, textureColor.w), adjust);
 ```
 
-
-完整的顶点着色器:   
-
-```python
-attribute vec4 a_Position;
-attribute vec4 a_TextureCoordinate;
-
-varying vec2 vTextureUnitCoordinate;
-
-void main() {
-    gl_Position = a_Position;
-    vTextureUnitCoordinate = a_TextureCoordinate.xy;
-}
-```
-
 片元着色器代码:     
 
-```python
+```glsl
+#version 300 es
 precision mediump float;
 
-uniform sampler2D u_TextureSampler;
-uniform sampler2D u_LookupTable;
-uniform float u_Intensity;
+in vec2 v_texCoord;
+out vec4 outColor;
+uniform sampler2D s_texture;
+uniform sampler2D textureLUT;
 
-varying vec2 vTextureUnitCoordinate;
+//查找表滤镜
+vec4 lookupTable(vec4 color){
+    float blueColor = color.b * 63.0;
 
-void main() {
-    vec4 textureColor = texture2D(u_TextureSampler, vTextureUnitCoordinate);
-    float blueColor = textureColor.b * 63.0;
     vec2 quad1;
     quad1.y = floor(floor(blueColor) / 8.0);
     quad1.x = floor(blueColor) - (quad1.y * 8.0);
-
     vec2 quad2;
     quad2.y = floor(ceil(blueColor) / 8.0);
     quad2.x = ceil(blueColor) - (quad2.y * 8.0);
 
     vec2 texPos1;
-    texPos1.x = (quad1.x * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * textureColor.r);
-    texPos1.y = (quad1.y * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * textureColor.g);
-
+    texPos1.x = (quad1.x * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * color.r);
+    texPos1.y = (quad1.y * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * color.g);
     vec2 texPos2;
-    texPos2.x = (quad2.x * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * textureColor.r);
-    texPos2.y = (quad2.y * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * textureColor.g);
-
-    vec4 newColor1 = texture2D(u_LookupTable, texPos1);
-    vec4 newColor2 = texture2D(u_LookupTable, texPos2);
-
+    texPos2.x = (quad2.x * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * color.r);
+    texPos2.y = (quad2.y * 0.125) + 0.5/512.0 + ((0.125 - 1.0/512.0) * color.g);
+    vec4 newColor1 = texture(textureLUT, texPos1);
+    vec4 newColor2 = texture(textureLUT, texPos2);
     vec4 newColor = mix(newColor1, newColor2, fract(blueColor));
-    gl_FragColor = mix(textureColor, vec4(newColor.rgb, textureColor.w), u_Intensity);
+    return vec4(newColor.rgb, color.w);
 }
-```
-
 
+void main(){
+    vec4 tmpColor = texture(s_texture, v_texCoord);
+    outColor = lookupTable(tmpColor);
+}
 
+```
 
-[上一篇: 12.FBO](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/12.FBO.md)
-[下一篇: 14.实例化](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/14.%E5%AE%9E%E4%BE%8B%E5%8C%96.md)
+---
 
+- [12.FBO](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/12.FBO.md)    
+- [14.实例化](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/14.%E5%AE%9E%E4%BE%8B%E5%8C%96.md)
 
 ---
 
@@ -263,17 +250,6 @@ void main() {
 
 
 
-
-
-
-
-
-
-
-
-
-
-
 
 
 
diff --git "a/VideoDevelopment/OpenGL/14.\345\256\236\344\276\213\345\214\226.md" "b/VideoDevelopment/OpenGL/14.\345\256\236\344\276\213\345\214\226.md"
index cf2f5fae..f0a70991 100644
--- "a/VideoDevelopment/OpenGL/14.\345\256\236\344\276\213\345\214\226.md"
+++ "b/VideoDevelopment/OpenGL/14.\345\256\236\344\276\213\345\214\226.md"
@@ -19,7 +19,8 @@
 
 
 
-[上一篇: 10.GLSurfaceView+MediaPlayer播放视频](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md)
+--- 
+[上一篇: 13.LUT滤镜](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/13.LUT%E6%BB%A4%E9%95%9C.md)
 
 ---
 
diff --git "a/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
index 7a17ce67..be25becb 100644
--- "a/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
@@ -209,9 +209,11 @@ SurfaceTexture对象可以在任何线程上创建。
 updateTexImage()只能在包含纹理对象的OpenGL ES上下文的线程上调用。 在任意线程上调用frame-available回调函数，不与updateTexImage()在同一线程上出现。
 
 
+--- 
 
-[上一篇: 1.OpenGL简介](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/1.OpenGL%E7%AE%80%E4%BB%8B.md)        
-[下一篇: 3.GLSurfaceView源码解析](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/3.GLSurfaceView%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90.md)
+- [上一篇: 1.OpenGL简介](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/1.OpenGL%E7%AE%80%E4%BB%8B.md)        
+
+- [下一篇: 3.GLSurfaceView源码解析](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/3.GLSurfaceView%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90.md)
 
 ---
 
diff --git "a/VideoDevelopment/OpenGL/3.GLSurfaceView\346\272\220\347\240\201\350\247\243\346\236\220.md" "b/VideoDevelopment/OpenGL/3.GLSurfaceView\346\272\220\347\240\201\350\247\243\346\236\220.md"
index d5c9e8ab..4453dcc7 100644
--- "a/VideoDevelopment/OpenGL/3.GLSurfaceView\346\272\220\347\240\201\350\247\243\346\236\220.md"
+++ "b/VideoDevelopment/OpenGL/3.GLSurfaceView\346\272\220\347\240\201\350\247\243\346\236\220.md"
@@ -689,9 +689,11 @@ public void setRenderer(Renderer renderer) {
 
 
 
+---
+
+- [上一篇: 2.GLSurfaceView简介](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/2.GLSurfaceView%E7%AE%80%E4%BB%8B.md)       
 
-[上一篇: 2.GLSurfaceView简介](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/2.GLSurfaceView%E7%AE%80%E4%BB%8B.md)       
-[下一篇: 4.GLTextureView实现](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/4.GLTextureView%E5%AE%9E%E7%8E%B0.md)
+- [下一篇: 4.GLTextureView实现](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/4.GLTextureView%E5%AE%9E%E7%8E%B0.md)
 
 ---
 
diff --git "a/VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md" "b/VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md"
index 86affc03..63981545 100644
--- "a/VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md"
+++ "b/VideoDevelopment/OpenGL/4.GLTextureView\345\256\236\347\216\260.md"
@@ -1,4 +1,4 @@
-### 4.GLTextureView实现
+## 4.GLTextureView实现
 
 系统提供了GLSurfaceView，确没有提供GLTextureView，但是我们目前的项目灰常复杂庞大，我不想去封一层接口，然后动态去选择使用GLSurfaceView(实现一些纹理效果)或者TextureView(无OpenGL效果)来播放视频。我只想在目前的基础上去扩展，我想去实现一个GLTextureView。上面分析完GLSurfaceView的源码后我们也可以自己去实现GLTextureView的功能了。具体的实现就是和GLSurfaceView的源码一模一样。
 
@@ -1977,9 +1977,10 @@ public class GLTextureView extends TextureView implements TextureView.SurfaceTex
 
 
 
+---
+- [上一篇: 3.GLSurfaceView源码解析](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/3.GLSurfaceView%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90.md)     
 
-[上一篇: 3.GLSurfaceView源码解析](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/3.GLSurfaceView%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90.md)     
-[下一篇: 5.OpenGL ES绘制三角形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/5.OpenGL%20ES%E7%BB%98%E5%88%B6%E4%B8%89%E8%A7%92%E5%BD%A2.md)
+- [下一篇: 5.OpenGL ES绘制三角形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/5.OpenGL%20ES%E7%BB%98%E5%88%B6%E4%B8%89%E8%A7%92%E5%BD%A2.md)
 
 ---
 
diff --git "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md" "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"
index 3fbe1436..c1779157 100644
--- "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
@@ -1171,10 +1171,10 @@ public class IsoTriangleRender implements GLTextureView.Renderer {
 
 
 
+---
 
-
-[上一篇: 4.GLTextureView实现](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/4.GLTextureView%E5%AE%9E%E7%8E%B0.md)  
-[下一篇: 6.OpenGL ES绘制矩形及圆形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/6.OpenGL%20ES%E7%BB%98%E5%88%B6%E7%9F%A9%E5%BD%A2%E5%8F%8A%E5%9C%86%E5%BD%A2.md)
+- [上一篇: 4.GLTextureView实现](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/4.GLTextureView%E5%AE%9E%E7%8E%B0.md)  
+- [下一篇: 6.OpenGL ES绘制矩形及圆形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/6.OpenGL%20ES%E7%BB%98%E5%88%B6%E7%9F%A9%E5%BD%A2%E5%8F%8A%E5%9C%86%E5%BD%A2.md)
 
 ---
 
diff --git "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md" "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"
index 9b9d547d..49d52826 100644
--- "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"	
@@ -522,9 +522,10 @@ public class CircleRender extends BaseGLSurfaceViewRenderer {
 
 
 
+--- 
 
-[上一篇: 5.OpenGL ES绘制三角形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/5.OpenGL%20ES%E7%BB%98%E5%88%B6%E4%B8%89%E8%A7%92%E5%BD%A2.md)       
-[下一篇: 7.OpenGL ES着色器语言GLSL](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/7.OpenGL%20ES%E7%9D%80%E8%89%B2%E5%99%A8%E8%AF%AD%E8%A8%80GLSL.md)
+- [上一篇: 5.OpenGL ES绘制三角形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/5.OpenGL%20ES%E7%BB%98%E5%88%B6%E4%B8%89%E8%A7%92%E5%BD%A2.md)       
+- [下一篇: 7.OpenGL ES着色器语言GLSL](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/7.OpenGL%20ES%E7%9D%80%E8%89%B2%E5%99%A8%E8%AF%AD%E8%A8%80GLSL.md)
 
 ---
 
diff --git "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md" "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
index d91aa94e..ac66269e 100644
--- "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
+++ "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
@@ -513,9 +513,10 @@ void main(void)
 
 
 
+---
 
-[上一篇: 6.OpenGL ES绘制矩形及圆形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/6.OpenGL%20ES%E7%BB%98%E5%88%B6%E7%9F%A9%E5%BD%A2%E5%8F%8A%E5%9C%86%E5%BD%A2.md)  
-[下一篇: 8.GLES类及Matrix类](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/8.GLES%E7%B1%BB%E5%8F%8AMatrix%E7%B1%BB.md)
+- [上一篇: 6.OpenGL ES绘制矩形及圆形](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/6.OpenGL%20ES%E7%BB%98%E5%88%B6%E7%9F%A9%E5%BD%A2%E5%8F%8A%E5%9C%86%E5%BD%A2.md)  
+- [下一篇: 8.GLES类及Matrix类](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/8.GLES%E7%B1%BB%E5%8F%8AMatrix%E7%B1%BB.md)
 
 ---
 
diff --git "a/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md" "b/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
index 01eb63e1..7be018c0 100644
--- "a/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
+++ "b/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
@@ -253,8 +253,10 @@ OpenGL有一个固定在原点(0,0,0)并朝向z轴负方向的相机，如下图
 
 
 
-[上一篇: 7.OpenGL ES着色器语言GLSL](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/7.OpenGL%20ES%E7%9D%80%E8%89%B2%E5%99%A8%E8%AF%AD%E8%A8%80GLSL.md)  
-[下一篇: 9.OpenGL ES纹理](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/9.OpenGL%20ES%E7%BA%B9%E7%90%86.md)
+---
+
+- [上一篇: 7.OpenGL ES着色器语言GLSL](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/7.OpenGL%20ES%E7%9D%80%E8%89%B2%E5%99%A8%E8%AF%AD%E8%A8%80GLSL.md)  
+- [下一篇: 9.OpenGL ES纹理](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/9.OpenGL%20ES%E7%BA%B9%E7%90%86.md)
 
 ---
 
diff --git "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md" "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"
index 37eb449f..0b92ed52 100644
--- "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
+++ "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
@@ -571,9 +571,10 @@ void main() {
 顶点着色器允许一次操作一个顶点，而片段着色器一次可以操作一个片段（实际上是一个像素），但几何着色器却可以一次操作一个图元。
 
 
+---
+- [上一篇: 8.GLES类及Matrix类](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/8.GLES%E7%B1%BB%E5%8F%8AMatrix%E7%B1%BB.md)  
 
-[上一篇: 8.GLES类及Matrix类](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/8.GLES%E7%B1%BB%E5%8F%8AMatrix%E7%B1%BB.md)  
-[下一篇: 10.GLSurfaceView+MediaPlayer播放视频](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md)
+- [下一篇: 10.GLSurfaceView+MediaPlayer播放视频](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/10.GLSurfaceView%2BMediaPlayer%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91.md)
 
 ---
 

From 66b1db472308f2efabd1d3c8ea6b42a297062fe3 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Sat, 11 May 2024 20:44:09 +0800
Subject: [PATCH 178/213] update rxjava part

---
 AdavancedPart/ARouter.md                      |  71 ++++
 .../Gradle\344\270\223\351\242\230.md"        | 337 ++++++++++++++++++
 ...\350\257\246\350\247\243(\344\270\200).md" | 128 ++++---
 ...\350\257\246\350\247\243(\344\272\214).md" | 104 +++---
 ...\350\257\246\350\247\243(\344\270\211).md" |  33 +-
 ...\345\216\237\347\220\206(\345\233\233).md" |   3 +-
 6 files changed, 569 insertions(+), 107 deletions(-)
 create mode 100644 AdavancedPart/ARouter.md

diff --git a/AdavancedPart/ARouter.md b/AdavancedPart/ARouter.md
new file mode 100644
index 00000000..f9d9cc9f
--- /dev/null
+++ b/AdavancedPart/ARouter.md
@@ -0,0 +1,71 @@
+ARouter
+---
+
+
+[ARouter](https://github.com/alibaba/ARouter)
+一个用于帮助 Android App 进行组件化改造的框架 —— 支持模块间的路由、通信、解耦
+
+
+
+
+```java
+Intent intent = new Intent(mContext, XxxActivity.class);
+intent.putExtra("key","value");
+startActivity(intent);
+        
+Intent intent = new Intent(mContext, XxxActivity.class);
+intent.putExtra("key","value");
+startActivityForResult(intent, 666);
+```
+在未使用ARouter路由框架之前的原生页面跳转方式。 
+
+
+## 原生路由方案的缺点 
+
+1. 显式: 直接的类依赖，耦合严重
+2. 隐式: 会在Manifest文件中进行集中管理，写作困难
+
+
+## ARouter的优势
+
+1. 使用注解，实现了映射关系自动注册与分布式路由管理
+2. 编译期间处理注解，并生成映射文件，没有使用反射，不影响运行时性能
+3. 映射关系按组分类，分级管理，按需初始化。
+4. 灵活的降级策略，每次跳转都会回调跳转结果，避免startActivity()一旦失败会抛出异常
+5. 自定义拦截器，自定义拦截顺序，可以对路由进行拦截，比如登录判断和埋点处理
+6. 支持依赖注入，可单独作为依赖注入框架使用，从而实现跨模块API调用
+7. 支持直接解析标准url进行跳转，并自动注入参数到目标页面中
+8. 支持多模块使用，支持组件化开发
+
+
+
+## 基本使用
+
+添加依赖并初始化后的基本使用:     
+
+```java
+// 在支持路由的页面上添加注解(必选)
+// 这里的路径需要注意的是至少需要有两级，/xx/xx
+@Route(path = "/test/activity")
+public class YourActivity extend Activity {
+    ...
+}
+
+// 1. 应用内简单的跳转(通过URL跳转在'进阶用法'中)
+ARouter.getInstance().build("/test/activity").navigation();
+
+// 2. 跳转并携带参数
+ARouter.getInstance().build("/test/1")
+    .withLong("key1", 666L)
+    .withString("key3", "888")
+    .withObject("key4", new Test("Jack", "Rose"))
+    .navigation();
+```
+
+
+
+
+
+
+
+
diff --git "a/Gradle&Maven/Gradle\344\270\223\351\242\230.md" "b/Gradle&Maven/Gradle\344\270\223\351\242\230.md"
index 67820a04..b2689789 100644
--- "a/Gradle&Maven/Gradle\344\270\223\351\242\230.md"
+++ "b/Gradle&Maven/Gradle\344\270\223\351\242\230.md"
@@ -1749,6 +1749,343 @@ pizzaPrices.pepperoni
 
 
 
+
+
+
+1.Groovy概述
+Groovy是Apache 旗下的一种基于JVM的面向对象编程语言，既可以用于面向对象编程，也可以用作纯粹的脚本语言。在语言的设计上它吸纳了Python、Ruby 和 Smalltalk 语言的优秀特性，比如动态类型转换、闭包和元编程支持。
+Groovy与 Java可以很好的互相调用并结合编程 ，比如在写 Groovy 的时候忘记了语法可以直接按Java的语法继续写，也可以在 Java 中调用 Groovy 脚本。比起Java，Groovy语法更加的灵活和简洁，可以用更少的代码来实现Java实现的同样功能。
+
+2.Groovy编写和调试
+Groovy的代码可以在Android Studio和IntelliJ IDEA等IDE中进行编写和调试，缺点是需要配置环境，这里推荐在文本中编写代码并结合命令行进行调试（文本推荐使用Sublime Text）。关于命令行请查看Gradle入门前奏这篇文章。
+具体的操作步骤就是：在一个目录中新建build.gradle文件，在build.gradle中新建一个task，在task中编写Groovy代码，用命令行进入这个build.gradle文件所在的目录，运行gradle task名称 等命令行对代码进行调试，本文中的例子都是这样编写和调试的。
+
+3.变量
+Groovy中用def关键字来定义变量，可以不指定变量的类型，默认访问修饰符是public。
+
+def a = 1;
+def int b = 1;
+def c = "hello world";
+4.方法
+方法使用返回类型或def关键字定义，方法可以接收任意数量的参数，这些参数可以不申明类型，如果不提供可见性修饰符，则该方法为public。
+用def关键字定义方法。
+
+task method <<{
+    add (1,2)
+    minus 1,2 //1
+}
+def add(int a,int b) { 
+ println a+b //3
+}  
+def minus(a,b) {//2 
+ println a-b
+}   
+如果指定了方法返回类型，可以不需要def关键字来定义方法。
+
+task method <<{
+    def number=minus 1,2
+    println number
+}
+int minus(a,b) { 
+  return a-b 
+}  
+如果不使用return ，方法的返回值为最后一行代码的执行结果。
+
+int minus(a,b) { 
+  a-b //4
+}  
+从上面两段代码中可以发现Groovy中有很多省略的地方：
+
+语句后面的分号可以省略。
+
+方法的括号可以省略，比如注释1和注释3处。
+
+参数类型可以省略，比如注释2处。
+
+return可以省略掉，比如注释4处。
+
+5.类
+Groovy类非常类似于Java类。
+
+task method <<{
+    def p = new Person()
+    p.increaseAge 5
+    println p.age
+}
+class Person {                       
+    String name                      
+    Integer age =10
+    def increaseAge(Integer years) { 
+        this.age += years
+    }
+}
+运行 gradle method打印结果为：
+15
+
+Groovy类与Java类有以下的区别：
+
+默认类的修饰符为public。
+
+没有可见性修饰符的字段会自动生成对应的setter和getter方法。
+
+类不需要与它的源文件有相同的名称，但还是建议采用相同的名称。
+
+6.语句
+6.1 断言
+Groovy断言和Java断言不同，它一直处于开启状态，是进行单元测试的首选方式。
+
+task method <<{
+  assert 1+2 == 6
+}
+输出结果为：
+
+Execution failed for task ':method'.
+> assert 1+2 == 6
+          |  |
+          3  false
+当断言的条件为false时，程序会抛出异常，不再执行下面的代码，从输出可以很清晰的看到发生错误的地方。
+
+6.2 for循环
+Groovy支持Java的for(int i=0;i<N;i++)和for(int i :array)形式的循环语句，另外还支持for in loop形式，支持遍历范围、列表、Map、数组和字符串等多种类型。
+
+//遍历范围
+def x = 0
+for ( i in 0..3 ) {
+    x += i
+}
+assert x == 6
+//遍历列表
+def x = 0
+for ( i in [0, 1, 2, 3] ) {
+    x += i
+}
+assert x == 6
+//遍历Map中的值
+def map = ['a':1, 'b':2, 'c':3]
+x = 0
+for ( v in map.values() ) {
+    x += v
+}
+assert x == 6
+6.3 switch语句
+Groovy中的Switch语句不仅兼容Java代码，还可以处理更多类型的case表达式。
+
+task method <<{
+def x = 16
+def result = ""
+
+switch ( x ) {
+    case "ok":
+        result = "found ok"
+    case [1, 2, 4, 'list']:
+        result = "list"
+        break
+    case 10..19:
+        result = "range"
+        break
+    case Integer:
+        result = "integer"
+        break
+    default:
+        result = "default"
+}
+assert result == "range"
+}
+case表达式可以是字符串、列表、范围、Integer等等，因为篇幅原因，这里只列出了一小部分。
+
+7. 数据类型
+Groovy中的数据类型主要有以下几种：
+
+Java中的基本数据类型
+
+Groovy中的容器类
+
+闭包
+
+7.1 字符串
+Groovy中的基本数据类型和Java大同小异，这里主要介绍下字符串类型。在Groovy种有两种字符串类型，普通字符串String（java.lang.String）和插值字符串GString（groovy.lang.GString）。
+
+单引号字符串
+在Groovy中单引号字符串和双引号字符串都可以定义一个字符串常量，只不过单引号字符串不支持插值。
+
+'Android进阶解密'
+双引号字符串
+要想插值可以使用双引号字符串，插值指的是替换字符串中的占位符，占位符表达式为${}或者以$为前缀。
+
+def name = 'Android进阶之光'
+println "hello ${name}"
+println "hello $name"
+三引号字符串
+三引号字符串可以保留文本的换行和缩进格式，不支持插值。
+
+task method <<{
+def name = '''Android进阶之光
+       Android进阶解密
+Android进阶？'''
+println name 
+}
+打印结果为：
+
+Android进阶之光
+       Android进阶解密
+Android进阶？
+GString
+String是不可变的，GString却是可变的，GString和String即使有相同的字面量，它们的hashCodes的值也可能不同，因此应该避免使用使用GString作为Map的key。
+
+assert "one: ${1}".hashCode() != "one: 1".hashCode()
+当双引号字符串中包含插值表达式时，字符串类型为GString，因此上面的断言为true。
+
+7.2  List
+Groovy没有定义自己的集合类，它在Java集合类的基础上进行了增强和简化。Groovy的List对应Java中的List接口，默认的实现类为Java中的ArrayList。
+
+def number = [1, 2, 3]         
+assert number instanceof List  
+def linkedList = [1, 2, 3] as LinkedList    
+assert linkedList instanceof java.util.LinkedList
+可以使用as操作符来显式指定List的实现类为java.util.LinkedList。
+获取元素同样要比Java要简洁些，使用[]来获取List中具有正索引或负索引的元素。
+
+task method <<{
+def number  = [1, 2, 3, 4]   
+assert number [1] == 2
+assert number [-1] == 4 //1  
+
+number << 5     //2             
+assert number [4] == 5
+assert number [-1] == 5
+}
+注释1处的索引-1是列表末尾的第一个元素。注释2处使用<<运算符在列表末尾追加一个元素。
+
+7.3  Map
+创建Map同样使用[]，需要同时指定键和值，默认的实现类为java.util.LinkedHashMap。
+
+def name = [one: '魏无羡', two: '杨影枫', three: '张无忌']   
+assert name['one']  == '魏无羡' 
+assert name.two  == '杨影枫'
+Map还有一个键关联的问题：
+
+def key = 'name'
+def person = [key: '魏无羡'] //1
+assert person.containsKey('key') 
+person = [(key): '魏无羡'] //2       
+assert person.containsKey('name') 
+注释1处魏无羡的键值是key这个字符串，而不是key变量的值 name。如果想要以key变量的值为键值，需要像注释2处一样使用(key)，用来告诉解析器我们传递的是一个变量，而不是定义一个字符串键值。
+
+7.4  闭包（Closure）
+Groovy中的闭包是一个开放的、匿名的、可以接受参数和返回值的代码块。
+定义闭包
+闭包的定义遵循以下语法：
+
+{ [closureParameters -> ] statements }
+闭包分为两个部分，分别是参数列表部分[closureParameters -> ]和语句部分 statements 。
+参数列表部分是可选的，如果闭包只有一个参数，参数名是可选的，Groovy会隐式指定it作为参数名，如下所示。
+
+{ println it }     //使用隐式参数it的闭包                                 
+当需要指定参数列表时，需要->将参数列表和闭包体相分离。
+
+{ it -> println it }   //it是一个显示参数 
+{ String a, String b ->                                
+    println "${a} is a ${b}"
+}   
+闭包是groovy.lang.Cloush类的一个实例，这使得闭包可以赋值给变量或字段，如下所示。
+
+//将闭包赋值给一个变量
+def println ={ it -> println it }     
+assert println instanceof Closure
+//将闭包赋值给Closure类型变量
+Closure do= { println 'do!' }                      
+调用闭包
+闭包既可以当做方法来调用，也可以显示调用call方法。
+
+def code = { 123 }
+assert code() == 123 //闭包当做方法调用
+assert code.call() == 123 //显示调用call方法
+def isOddNumber = { int i -> i%2 != 0 }                           
+assert isOddNumber(3) == true  //调用带参数的闭包
+8. I/O 操作
+Groovy的 I/O 操作要比Java的更为的简洁。
+
+8.1 文件读取
+我们可以在PC上新建一个name.txt，在里面输入一些内容，然后用Groovy来读取该文件的内容：
+
+def filePath = "D:/Android/name.txt"
+def file = new File(filePath) ;
+file.eachLine {
+    println it
+}
+可以看出Groovy的文件读取是很简洁的，还可以更简洁些：
+
+def filePath = "D:/Android/name.txt"
+def file = new File(filePath) ;
+println file.text
+8.2 文件写入
+文件写入同样十分简洁：
+
+def filePath = "D:/Android/name.txt"
+def file = new File(filePath);
+
+file.withPrintWriter {
+    it.println("三井寿")
+    it.println("仙道彰")
+}
+9. 其他
+9.1 asType
+asType可以用于数据类型转换：
+
+String a = '23'
+int b = a as int
+def c = a.asType(Integer)
+assert c instanceof java.lang.Integer
+9.2 判断是否为真
+if (name != null && name.length > 0) {}
+可以替换为
+
+if (name) {}
+9.3 安全取值
+在Java中，要安全获取某个对象的值可能需要大量的if语句来判空：
+
+if (school != null) {
+    if (school.getStudent() != null) {
+        if (school.getStudent().getName() != null) {
+            System.out.println(school.getStudent().getName());
+        }
+    }
+}
+Groovy中可以使用？.来安全的取值：
+
+println school?.student?.name
+9.4 with操作符
+对同一个对象的属性进行赋值时，可以这么做：
+
+task method <<{
+Person p = new Person()
+p.name = "杨影枫"
+p.age = 19
+p.sex = "男"
+println p.name
+}
+class Person {                       
+    String name                      
+    Integer age
+    String sex
+}
+使用with来进行简化：
+
+Person p = new Person()
+p.with {
+   name = "杨影枫"
+   age= 19
+   sex= "男"
+ }   
+println p.name
+
+
+
+
+
+
+
+
 [1]: https://github.com/CharonChui/AndroidNote/blob/master/AndroidStudioCourse/AndroidStudio%E4%BD%BF%E7%94%A8%E6%95%99%E7%A8%8B(%E7%AC%AC%E4%B8%83%E5%BC%B9).md       "AndroidStudio使用教程(第七弹)"
 
 
diff --git "a/RxJavaPart/1.RxJava\350\257\246\350\247\243(\344\270\200).md" "b/RxJavaPart/1.RxJava\350\257\246\350\247\243(\344\270\200).md"
index 81b665b6..6767b6d9 100644
--- "a/RxJavaPart/1.RxJava\350\257\246\350\247\243(\344\270\200).md"
+++ "b/RxJavaPart/1.RxJava\350\257\246\350\247\243(\344\270\200).md"
@@ -1,8 +1,6 @@
 RxJava详解(一)
 ===
 
-年初的时候就想学习下`RxJava`然后写一些`RxJava`的教程，无奈发现已经年底了，然而我还么有写。今天有点时间，特别是发布了`RxJava 2.0`后，我决定动笔开始。
-
 现在`RxJava`变的越来越流行了，很多项目中都使用了它。特别是大神`JakeWharton`等的加入，以及`RxBinding、Retrofit、RxLifecycle`等众多项目的，然开发越来越方便，但是上手比较难，不过一旦你入门后你就会发现真是太棒了。
 
 
@@ -92,7 +90,9 @@ public void rxFetchUserDetails() {
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/rx_logo.png?raw=true)
 
-`Rx`基于观察者模式，它是一种编程模型，目标是提供一致的编程接口，帮助开发者更方便的处理异步数据流。`ReactiveX.io`给的定义是，`Rx`是一个使用可观察数据流进行异步编程的编程接口，`ReactiveX`结合了观察者模式、迭代器模式和函数式编程的精华。`Rx`已经渗透到了各个语言中，有了`Rx`所以才有了`RxJava`、`Rx.NET`、`RxJS`、`RxSwift`、`Rx.rb`、`RxPHP`等等，
+`Rx`基于观察者模式，它是一种编程模型，目标是提供一致的编程接口，帮助开发者更方便的处理异步数据流。
+
+`ReactiveX.io`给的定义是，`Rx`是一个使用可观察数据流进行异步编程的编程接口，`ReactiveX`结合了观察者模式、迭代器模式和函数式编程的精华。`Rx`已经渗透到了各个语言中，有了`Rx`所以才有了`RxJava`、`Rx.NET`、`RxJS`、`RxSwift`、`Rx.rb`、`RxPHP`等等，
 
 这里先列举一下相关的官网:  
 
@@ -107,7 +107,9 @@ public void rxFetchUserDetails() {
 
 这里可能会有人想不就是个异步吗，至于辣么矫情么?用`AsyncTask`、`Handler`甚至自定义一个`BigAsyncTask`分分钟搞定。
 
-但是`RxJava`的好处是简洁。异步操作很关键的一点是程序的简洁性，因为在调度过程比较复杂的情况下，异步代码经常会既难写也难被读懂。 `Android`创造的`AsyncTask`和`Handler`其实都是为了让异步代码更加简洁。虽然`RxJava`的优势也是简洁，但它的简洁的与众不同之处在于，随着程序逻辑变得越来越复杂，它依然能够保持简洁。
+但是`RxJava`的好处是简洁。异步操作很关键的一点是程序的简洁性，因为在调度过程比较复杂的情况下，异步代码经常会既难写也难被读懂。     
+
+`Android`创造的`AsyncTask`和`Handler`其实都是为了让异步代码更加简洁。虽然`RxJava`的优势也是简洁，但它的简洁的与众不同之处在于，随着程序逻辑变得越来越复杂，它依然能够保持简洁。
 
 
 #### 扩展的观察者模式
@@ -115,13 +117,23 @@ public void rxFetchUserDetails() {
 
 `RxJava`的异步实现，是通过一种扩展的观察者模式来实现的。
 
-观察者模式面向的需求是：`A`对象（观察者）对`B`对象（被观察者）的某种变化高度敏感，需要在`B`变化的一瞬间做出反应。举个例子，新闻里喜闻乐见的警察抓小偷，警察需要在小偷伸手作案的时候实施抓捕。在这个例子里，警察是观察者，小偷是被观察者，警察需要时刻盯着小偷的一举一动，才能保证不会漏过任何瞬间。程序的观察者模式和这种真正的『观察』略有不同，观察者不需要时刻盯着被观察者（例如`A`不需要每过`2ms`就检查一次`B`的状态），而是采用注册(`Register`)或者称为订阅(`Subscribe`)的方式，告诉被观察者：我需要你的某某状态，你要在它变化的时候通知我。 `Android`开发中一个比较典型的例子是点击监听器`OnClickListener`。对设置`OnClickListener`来说，`View`是被观察者，`OnClickListener`是观察者，二者通过 `setOnClickListener()`方法达成订阅关系。订阅之后用户点击按钮的瞬间，`Android Framework`就会将点击事件发送给已经注册的`OnClickListener`。采取这样被动的观察方式，既省去了反复检索状态的资源消耗，也能够得到最高的反馈速度。当然，这也得益于我们可以随意定制自己程序中的观察者和被观察者，而警察叔叔明显无法要求小偷『你在作案的时候务必通知我』。
+观察者模式面向的需求是：`A`对象（观察者）对`B`对象（被观察者）的某种变化高度敏感，需要在`B`变化的一瞬间做出反应。    
+
+举个例子，新闻里喜闻乐见的警察抓小偷，警察需要在小偷伸手作案的时候实施抓捕。在这个例子里，警察是观察者，小偷是被观察者，警察需要时刻盯着小偷的一举一动，才能保证不会漏过任何瞬间。     
+
+程序的观察者模式和这种真正的『观察』略有不同，观察者不需要时刻盯着被观察者（例如`A`不需要每过`2ms`就检查一次`B`的状态），而是采用注册(`Register`)或者称为订阅(`Subscribe`)的方式，告诉被观察者：我需要你的某某状态，你要在它变化的时候通知我。       
+
+`Android`开发中一个比较典型的例子是点击监听器`OnClickListener`。对设置`OnClickListener`来说，`View`是被观察者，`OnClickListener`是观察者，二者通过 `setOnClickListener()`方法达成订阅关系。    
+
+订阅之后用户点击按钮的瞬间，`Android Framework`就会将点击事件发送给已经注册的`OnClickListener`。      采取这样被动的观察方式，既省去了反复检索状态的资源消耗，也能够得到最高的反馈速度。当然，这也得益于我们可以随意定制自己程序中的观察者和被观察者，而警察叔叔明显无法要求小偷『你在作案的时候务必通知我』。   
 
 `OnClickListener`的模式大致如下图：
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/btn_onclick.jpg?raw=true)
 
-如图所示，通过`setOnClickListener()`方法，`Button`持有`OnClickListener`的引用（这一过程没有在图上画出）；当用户点击时，`Button`自动调用`OnClickListener`的`onClick()` 方法。另外，如果把这张图中的概念抽象出来（`Button` -> 被观察者、`OnClickListener` -> 观察者、`setOnClickListener()` -> 订阅，`onClick()` -> 事件），就由专用的观察者模式（例如只用于监听控件点击）转变成了通用的观察者模式。如下图：
+如图所示，通过`setOnClickListener()`方法，`Button`持有`OnClickListener`的引用（这一过程没有在图上画出）；当用户点击时，`Button`自动调用`OnClickListener`的`onClick()` 方法。     
+
+另外，如果把这张图中的概念抽象出来（`Button` -> 被观察者、`OnClickListener` -> 观察者、`setOnClickListener()` -> 订阅，`onClick()` -> 事件），就由专用的观察者模式（例如只用于监听控件点击）转变成了通用的观察者模式。如下图：
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/btn_rxjava_observable.jpg?raw=true)
 
@@ -134,7 +146,7 @@ public void rxFetchUserDetails() {
 `RxJava`的基本概念：
 
 - `Observable`(可观察者，即被观察者):产生事件，例如去饭店吃饭的顾客。
-- `Observer`(观察者):接收事件，并给出响应动作，例如去饭店吃饭的厨房，会接受事件，并给出相应。
+- `Observer`(观察者):接收事件，并给出响应动作，例如去饭店吃饭的厨房，会接受事件，并给出响应。
 - `subscribe()`(订阅):连接被观察者与观察者，例如去饭店吃饭的服务员。
     `Observable`和`Observer`通过`subscribe()` 方法实现订阅关系，从而`Observable`可以在需要的时候发出事件来通知`Observer`。
 - `Event`(事件):被观察者与观察者沟通的载体，例如顾客点的菜。
@@ -155,6 +167,18 @@ public void rxFetchUserDetails() {
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/rxjava_observer_1.jpg?raw=true)
 
 
+RxJava在响应式编程中的基本流程如下：
+
+这个流程，可以简单的理解为：Observable -> Operator1 -> Operator2 -> Operator3 -> Subscriber
+
+- Observable发出一系列事件，他是事件的产生者；
+- Subscriber负责处理事件，他是事件的消费者；
+- Operator是对Observable发出的事件进行修改和变换；
+- 若事件从产生到消费不需要其他处理，则可以省略掉中间的Operator，从而流程变为Obsevable -> Subscriber；
+- Subscriber通常在主线程执行，所以原则上不要去处理太多的事务，而这些复杂的处理则交给Operator；
+
+
+
 #### 基本实现
 
 
@@ -219,13 +243,14 @@ public void rxFetchUserDetails() {
     observable.subscribe(subscriber);
     ```
 
-    > 有人可能会注意到，`subscribe()`这个方法有点怪：它看起来是`observalbe`订阅了`observer/subscriber`而不是`observer/subscriber`订阅了`observalbe`，这看起来就像『杂志订阅了读者』一样颠倒了对象关系。这让人读起来有点别扭，不过如果把`API`设计成`observer.subscribe(observable)/subscriber.subscribe(observable)` ，虽然更加符合思维逻辑，但对流式`API`的设计就造成影响了，比较起来明显是得不偿失的。
+    > 有人可能会注意到，`subscribe()`这个方法有点怪：它看起来是`observalbe`订阅了`observer/subscriber`而不是`observer/subscriber`订阅了`observalbe`，这看起来就像『杂志订阅了读者』一样颠倒了对象关系。       
+    > 这让人读起来有点别扭，不过如果把`API`设计成`observer.subscribe(observable)/subscriber.subscribe(observable)` ，虽然更加符合思维逻辑，但对流式`API`的设计就造成影响了，比较起来明显是得不偿失的。
 
   
 `RxJava`入门示例
 ---
 
-一个`Observable`可以发出零个或者多个事件，知道结束或者出错。每发出一个事件，就会调用它的`Subscriber`的`onNext`方法，最后调用`Subscriber.onComplete()`或者`Subscriber.onError()`结束。
+一个`Observable`可以发出零个或者多个事件，直到结束或者出错。每发出一个事件，就会调用它的`Subscriber`的`onNext`方法，最后调用`Subscriber.onComplete()`或者`Subscriber.onError()`结束。
 
 #### `Hello World`
 
@@ -285,7 +310,7 @@ public Subscription subscribe(Subscriber subscriber) {
 }
 ```
 
-可以看到`subscriber()`做了3件事：
+可以看到`subscriber()`做了3件事:        
 
 - 调用`Subscriber.onStart()`。这个方法在前面已经介绍过，是一个可选的准备方法。
 - 调用`Observable`中的`onSubscribe.call(Subscriber)`。在这里，事件发送的逻辑开始运行。从这也可以看出，在`RxJava`中，`Observable` 并不是在创建的时候就立即开始发送事件，而是在它被订阅的时候，即当`subscribe()`方法执行的时候。
@@ -296,8 +321,6 @@ public Subscription subscribe(Subscriber subscriber) {
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/rxjava_observable_list.gif?raw=true)
 
 
-讲到这里很多人肯定会骂傻`X`,这TM简洁你妹啊...，这里只是个入门`Hello World`，真正的简洁等你看完全部介绍后就明白了。
-
 `RxJava`内置了很多简化创建`Observable`对象的函数，比如`Observable.just()`就是用来创建只发出一个事件就结束的`Observable`对象，上面创建`Observable`对象的代码可以简化为一行
 
 ```java
@@ -330,7 +353,7 @@ Observable.just("Hello ", "World !").subscribe(new Action1<String>() {
 });
 ```
 
-这里顺便多提一些`subscribe()`的多个`Action`参数：   
+这里顺便多提一下`subscribe()`的多个`Action`参数：   
 ```java
 Action1<String> onNextAction = new Action1<String>() {
     // onNext()
@@ -357,12 +380,27 @@ Action0 onCompletedAction = new Action0() {
 observable.subscribe(onNextAction, onErrorAction, onCompletedAction);
 ```
 
-简单解释一下这段代码中出现的`Action1`和`Action0`。`Action0`是`RxJava`的一个接口，它只有一个方法`call()`，这个方法是无参无返回值的；由于`onCompleted()` 方法也是无参无返回值的，因此`Action0`可以被当成一个包装对象，将`onCompleted()`的内容打包起来将自己作为一个参数传入`subscribe()`以实现不完整定义的回调。这样其实也可以看做将 `onCompleted()`方法作为参数传进了`subscribe()`，相当于其他某些语言中的『闭包』。`Action1`也是一个接口，它同样只有一个方法`call(T param)`，这个方法也无返回值，但有一个参数；与`Action0`同理，由于`onNext(T obj)`和`onError(Throwable error)`也是单参数无返回值的，因此`Action1`可以将`onNext(obj)`和`onError(error)`打包起来传入`subscribe()`以实现不完整定义的回调。事实上，虽然`Action0`和`Action1`在`API`中使用最广泛，但`RxJava`是提供了多个`ActionX`形式的接口(例如`Action2`, `Action3`)的，它们可以被用以包装不同的无返回值的方法。
+简单解释一下这段代码中出现的`Action1`和`Action0`。      
+
+`Action0`是`RxJava`的一个接口，它只有一个方法`call()`，这个方法是无参无返回值的；     
+
+由于`onCompleted()` 方法也是无参无返回值的，因此`Action0`可以被当成一个包装对象，将`onCompleted()`的内容打包起来将自己作为一个参数传入`subscribe()`以实现不完整定义的回调。      
+
+
+这样其实也可以看做将 `onCompleted()`方法作为参数传进了`subscribe()`，相当于其他某些语言中的『闭包』。       
+
+`Action1`也是一个接口，它同样只有一个方法`call(T param)`，这个方法也无返回值，但有一个参数；       
+
+与`Action0`同理，由于`onNext(T obj)`和`onError(Throwable error)`也是单参数无返回值的，因此`Action1`可以将`onNext(obj)`和`onError(error)`打包起来传入`subscribe()`以实现不完整定义的回调。      
+
+事实上，虽然`Action0`和`Action1`在`API`中使用最广泛，但`RxJava`是提供了多个`ActionX`形式的接口(例如`Action2`, `Action3`)的，它们可以被用以包装不同的无返回值的方法。
 
 
 假设我们的`Observable`是第三方提供的，它提供了大量的用户数据给我们，而我们需要从用户数据中筛选部分有用的信息，那我们该怎么办呢？    
 从`Observable`中去修改肯定是不现实的？那从`Subscriber`中进行修改呢？ 这样好像是可以完成的。但是这种方式并不好，因为我们希望`Subscriber`越轻量越好，因为很有可能我们需要
-在主线程中去执行`Subscriber`。另外，根据响应式函数编程的概念，`Subscribers`更应该做的事情是`响应`，响应`Observable`发出的事件，而不是去修改。
+在主线程中去执行`Subscriber`。
+
+另外，根据响应式函数编程的概念，`Subscribers`更应该做的事情是`响应`，响应`Observable`发出的事件，而不是去修改。
 那该怎么办呢？ 这就要用到下面的部分要讲的操作符。  
 
 
@@ -381,7 +419,7 @@ observable.subscribe(onNextAction, onErrorAction, onCompletedAction);
 
 > 背压是指在异步场景中，被观察者发送事件速度远快于观察者的处理速度的情况下，一种告诉上游的被观察者降低发送速度的策略。
 
-简而言之，背压是流速控制的一种策略。
+简而言之，背压是流速控制的一种策略。      
 其实`RxJava 2.x`最大的改动就是对于`backpressure`的处理，为此将原来的`Observable`拆分成了新的`Observable`和`Flowable`，同时其他相关部分也同时进行了拆分。
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/rxjava1vs2.png?raw=true)
@@ -394,7 +432,7 @@ observable.subscribe(onNextAction, onErrorAction, onCompletedAction);
 
 `RxJava`提供了对事件序列进行变换的支持，这是它的核心功能之一.所谓变换，就是将事件序列中的对象或整个序列进行加工处理，转换成不同的事件或事件序列。       
 操作符就是为了解决对`Observable`对象的变换的问题，操作符用于在`Observable`和最终的`Subscriber`之间修改`Observable`发出的事件。`RxJava`提供了很多很有用的操作符。
-比如`map`操作符，就是用来把把一个事件转换为另一个事件的。
+比如`map`操作符，就是用来把一个事件转换为另一个事件的。
 
 #### `map`
 
@@ -456,10 +494,10 @@ map.subscribe(new Action1<Integer>() {
 
 通过上面的部分我们可以得知:   
 
-- `Observable`和`Subscriber`可以做任何事情
+- `Observable`和`Subscriber`可以做任何事情    
     `Observable`可以是一个数据库查询，`Subscriber`用来显示查询结果；`Observable`可以是屏幕上的点击事件，`Subscriber`用来响应点击事件；`Observable`可以是一个网络请求，`Subscriber`用来显示请求结果。
 
-- `Observable`和`Subscriber`是独立于中间的变换过程的。
+- `Observable`和`Subscriber`是独立于中间的变换过程的      
     在`Observable`和`Subscriber`中间 可以增减任何数量的`map`。整个系统是高度可组合的，操作数据是一个很简单的过程。
 
 
@@ -532,7 +570,9 @@ Observable.from(students)
     .subscribe(subscriber);
 ```
 
-`map`与`flatmap`在功能上是一致的,它也是把传入的参数转化之后返回另一个对象。区别在于`flatmap`是通过中间`Observable`来进行，而`map`是直接执行.`flatMap()`中返回的是个 `Observable`对象，并且这个`Observable`对象并不是被直接发送到了`Subscriber`的回调方法中。 
+`map`与`flatmap`在功能上是一致的,它也是把传入的参数转化之后返回另一个对象。区别在于`flatmap`是通过中间`Observable`来进行，而`map`是直接执行.       
+
+`flatMap()`中返回的是个 `Observable`对象，并且这个`Observable`对象并不是被直接发送到了`Subscriber`的回调方法中。 
 
 `flatMap()`的原理是这样的:  
 
@@ -585,18 +625,18 @@ Observable.from(s).subscribe(new Action1<String>() {
 
 ```java
 Observable.from(new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9})
-                .filter(new Func1<Integer, Boolean>() {
-                    @Override
-                    public Boolean call(Integer integer) {
-                        return integer < 5;
-                    }
-                })
-                .subscribe(new Action1<Integer>() {
-                    @Override
-                    public void call(Integer integer) {
-                        Log.i("@@@", "integer=" + integer); //1,2,3,4
-                    }
-                });
+    .filter(new Func1<Integer, Boolean>() {
+        @Override
+        public Boolean call(Integer integer) {
+            return integer < 5;
+        }
+    })
+    .subscribe(new Action1<Integer>() {
+        @Override
+        public void call(Integer integer) {
+            Log.i("@@@", "integer=" + integer); //1,2,3,4
+        }
+    });
 ```
 
 #### `timer`
@@ -606,12 +646,12 @@ Observable.from(new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9})
 
 ```java
 Observable.timer(3, TimeUnit.SECONDS).observeOn(AndroidSchedulers.mainThread())
-                .subscribe(new Action1<Long>() {
-                    @Override
-                    public void call(Long aLong) {
-                        Log.i("@@@", "aLong=" + aLong); // 延时3s
-                    }
-                });
+    .subscribe(new Action1<Long>() {
+        @Override
+        public void call(Long aLong) {
+            Log.i("@@@", "aLong=" + aLong); // 延时3s
+        }
+    });
 ```
 
 #### `interval`
@@ -622,12 +662,12 @@ Observable.timer(3, TimeUnit.SECONDS).observeOn(AndroidSchedulers.mainThread())
 
 ```java
 Observable.interval(1, TimeUnit.SECONDS, AndroidSchedulers.mainThread())
-        .subscribe(new Action1<Long>() {
-            @Override
-            public void call(Long aLong) {
-                Log.i("@@@", "aLong=" + aLong); //从0递增，间隔1s 0,1,2,3....
-            }
-        });
+    .subscribe(new Action1<Long>() {
+        @Override
+        public void call(Long aLong) {
+            Log.i("@@@", "aLong=" + aLong); //从0递增，间隔1s 0,1,2,3....
+        }
+    });
 ```
 
 #### `Repeat`
diff --git "a/RxJavaPart/2.RxJava\350\257\246\350\247\243(\344\272\214).md" "b/RxJavaPart/2.RxJava\350\257\246\350\247\243(\344\272\214).md"
index a689be18..55be3ce4 100644
--- "a/RxJavaPart/2.RxJava\350\257\246\350\247\243(\344\272\214).md"
+++ "b/RxJavaPart/2.RxJava\350\257\246\350\247\243(\344\272\214).md"
@@ -85,7 +85,7 @@ try{
 这样，我们就可以处理这三个函数中所抛出的任何异常了。如果没有`try catch`语句，我们也可以把异常继续传递下去。
 
 
-向异步粗发
+向异步出发
 ---
 
 但是，现实世界中我们往往没法等待。有些时候你没法只使用阻塞调用。在`Android`中你需要处理各种异步操作。
@@ -225,7 +225,6 @@ public class CatsHelper {
 
 
 #### 奔向更好的世界     
-#### 通用的回调
 
 
 如果我们仔细的观察下回调接口，我们会发现它们的共性:   
@@ -318,7 +317,6 @@ public class CatsHelper{
 下面来试试看看这种方式能否有效。
 如果我们返回一个临时的对象作为异步操作的回调接口处理方式，我们需要先定义这个对象。由于对象遵守通用的行为(有一个回调接口参数)，我们定义一个能用于所有操作的对象。我们称之为`AsyncJob`。
 
-> 注意： 我非常想把这个名字称之为`AsyncTask`。但是由于`Android`系统已经有个`AsyncTask`类了， 为了避免混淆，所以就用`AsyncJob`了。
 
 该对象如下:   
 ```java
@@ -384,28 +382,28 @@ public class CatsHelper {
             @Override
             public void start(Callback<Uri> cutestCatCallback) {
                 apiWrapper.queryCats(query)
-                        .start(new Callback<List<Cat>>() {
-                            @Override
-                            public void onResult(List<Cat> cats) {
-                                Cat cutest = findCutest(cats);
-                                apiWrapper.store(cutest)
-                                        .start(new Callback<Uri>() {
-                                            @Override
-                                            public void onResult(Uri result) {
-                                                cutestCatCallback.onResult(result);
-                                            }
- 
-                                            @Override
-                                            public void onError(Exception e) {
-                                                cutestCatCallback.onError(e);
-                                            }
-                                        });
-                            }
- 
-                            @Override
-                            public void onError(Exception e) {
-                                cutestCatCallback.onError(e);
-                            }
+                    .start(new Callback<List<Cat>>() {
+                        @Override
+                        public void onResult(List<Cat> cats) {
+                            Cat cutest = findCutest(cats);
+                            apiWrapper.store(cutest)
+                                .start(new Callback<Uri>() {
+                                    @Override
+                                    public void onResult(Uri result) {
+                                        cutestCatCallback.onResult(result);
+                                    }
+
+                                    @Override
+                                    public void onError(Exception e) {
+                                        cutestCatCallback.onError(e);
+                                    }
+                                });
+                        }
+
+                        @Override
+                        public void onError(Exception e) {
+                            cutestCatCallback.onError(e);
+                        }
                         });
             }
         };
@@ -466,17 +464,17 @@ public class CatsHelper {
                     @Override
                     public void onResult(Cat cutest) {
                         apiWrapper.store(cutest)
-                                .start(new Callback<Uri>() {
-                                    @Override
-                                    public void onResult(Uri result) {
-                                        cutestCatCallback.onResult(result);
-                                    }
- 
-                                    @Override
-                                    public void onError(Exception e) {
-                                        cutestCatCallback.onError(e);
-                                    }
-                                });
+                            .start(new Callback<Uri>() {
+                                @Override
+                                public void onResult(Uri result) {
+                                    cutestCatCallback.onResult(result);
+                                }
+
+                                @Override
+                                public void onError(Exception e) {
+                                    cutestCatCallback.onError(e);
+                                }
+                            });
                     }
  
                     @Override
@@ -505,21 +503,21 @@ public class CatsHelper {
 
 ```java
 AsyncJob<Cat> cutestCatAsyncJob = new AsyncJob<Cat>() {
+    @Override
+    public void start(Callback<Cat> callback) {
+        catsListAsyncJob.start(new Callback<List<Cat>>() {
             @Override
-            public void start(Callback<Cat> callback) {
-                catsListAsyncJob.start(new Callback<List<Cat>>() {
-                    @Override
-                    public void onResult(List<Cat> result) {
-                        callback.onResult(findCutest(result));
-                    }
- 
-                    @Override
-                    public void onError(Exception e) {
-                        callback.onError(e);
-                    }
-                });
+            public void onResult(List<Cat> result) {
+                callback.onResult(findCutest(result));
             }
-        };
+
+            @Override
+            public void onError(Exception e) {
+                callback.onError(e);
+            }
+        });
+    }
+};
 ```
 
 这 16 行代码中，只有一行代码是我们的业务逻辑代码：
@@ -661,7 +659,7 @@ public class CatsHelper {
     }
 }
 ```
-哎。。。 看起来没这么简单啊， 下面修复返回的类型再试一次：
+哎。。。 看起来没这么简单啊，下面修复返回的类型再试一次:    
 
 ```java
 public class CatsHelper {
@@ -911,7 +909,7 @@ public class CatsHelper {
 }
 ```
 
-把 Observable 替换为 AsyncJob 后 他们的代码是一样的。
+把Observable替换为AsyncJob后他们的代码是一样的。
 
 #### 结论
 
@@ -926,7 +924,7 @@ public class CatsHelper {
 
 如果嫌上面的代码麻烦，可以通过下面的例子看:   
 
-假设有这样一个需求：界面上有一个自定义的视图`imageCollectorView`，它的作用是显示多张图片，并能使用`addImage(Bitmap)` 方法来任意增加显示的图片。现在需要程序将一个给出的目录数组`File[] folders`中每个目录下的`png`图片都加载出来并显示在`imageCollectorView`中。需要注意的是，由于读取图片的这一过程较为耗时，需要放在后台执行，而图片的显示则必须在`UI`线程执行。常用的实现方式有多种，我这里贴出其中一种：
+假设有这样一个需求：界面上有一个自定义的视图`imageCollectorView`，它的作用是显示多张图片，并能使用`addImage(Bitmap)` 方法来任意增加显示的图片。现在需要程序将一个给出的目录数组`File[] folders`中每个目录下的`png`图片都加载出来并显示在`imageCollectorView`中。需要注意的是，由于读取图片的这一过程较为耗时，需要放在后台执行，而图片的显示则必须在`UI`线程执行。常用的实现方式有多种，我这里贴出其中一种:        
 
 
 ```java
@@ -984,7 +982,7 @@ Observable.from(folders)
     });
 ```
 
-那位说话了：『你这代码明明变多了啊！简洁个毛啊！』大兄弟你消消气，我说的是逻辑的简洁，不是单纯的代码量少（逻辑简洁才是提升读写代码速度的必杀技对不？）。观察一下你会发现， `RxJava`的这个实现，是一条从上到下的链式调用，没有任何嵌套，这在逻辑的简洁性上是具有优势的。当需求变得复杂时，这种优势将更加明显（试想如果还要求只选取前`10`张图片，常规方式要怎么办？如果有更多这样那样的要求呢？再试想，在这一大堆需求实现完两个月之后需要改功能，当你翻回这里看到自己当初写下的那一片迷之缩进，你能保证自己将迅速看懂，而不是对着代码重新捋一遍思路？）。
+观察一下你会发现， `RxJava`的这个实现，是一条从上到下的链式调用，没有任何嵌套，这在逻辑的简洁性上是具有优势的。当需求变得复杂时，这种优势将更加明显（试想如果还要求只选取前`10`张图片，常规方式要怎么办？如果有更多这样那样的要求呢？再试想，在这一大堆需求实现完两个月之后需要改功能，当你翻回这里看到自己当初写下的那一片迷之缩进，你能保证自己将迅速看懂，而不是对着代码重新捋一遍思路？）。
 
 更多内容请看下一篇文章[RxJava详解(三)][1]
 
diff --git "a/RxJavaPart/3.RxJava\350\257\246\350\247\243(\344\270\211).md" "b/RxJavaPart/3.RxJava\350\257\246\350\247\243(\344\270\211).md"
index e1f39a75..4d0ac650 100644
--- "a/RxJavaPart/3.RxJava\350\257\246\350\247\243(\344\270\211).md"
+++ "b/RxJavaPart/3.RxJava\350\257\246\350\247\243(\344\270\211).md"
@@ -22,9 +22,11 @@ public <R> Observable<R> lift(Operator<? extends R, ? super T> operator) {
 }
 ```
 
-这段代码很有意思：它生成了一个新的`Observable`并返回，而且创建新`Observable`所用的参数`OnSubscribe的回调方法`call()`中的实现竟然看起来和前面讲过的`Observable.subscribe()`一样！然而它们并不一样哟~不一样的地方关键就在于第二行`onSubscribe.call(subscriber)`中的`onSubscribe` 所指代的对象不同          
+这段代码很有意思：它生成了一个新的`Observable`并返回，而且创建新`Observable`所用的参数`OnSubscribe的回调方法`call()`中的实现竟然看起来和前面讲过的`Observable.subscribe()`一样！      
+然而它们并不一样哟~不一样的地方关键就在于第二行`onSubscribe.call(subscriber)`中的`onSubscribe` 所指代的对象不同:            
 - `subscribe()`中这句话的`onSubscribe`指的是`Observable`中的`onSubscribe`对象，这个没有问题，但是`lift()`之后的情况就复杂了点。
-- 当含有`lift()`时： 
+- 当含有`lift()`时:     
+
     - `lift()`创建了一个`Observable`后，加上之前的原始`Observable`，已经有两个`Observable`了； 
     - 而同样地，新`Observable`里的新`OnSubscribe`加上之前的原始`Observable`中的原始`OnSubscribe`，也就有了两个`OnSubscribe`； 
     - 当用户调用经过`lift()`后的`Observable`的`subscribe()`的时候，使用的是`lift()`所返回的新的`Observable`，于是它所触发的`onSubscribe.call(subscriber)`，也是用的新`Observable`中的新`OnSubscribe`，即在`lift()`中生成的那个`OnSubscribe`； 
@@ -69,7 +71,7 @@ observable.lift(new Observable.Operator<String, Integer>() {
 线程控制`Scheduler`
 ---
 
-在不指定线程的情况下，`RxJava`遵循的是线程不变的原则，即在哪个线程调用`subscribe()`方法就在哪个线程生产事件；在哪个线程生产事件，就在哪个线程消费事件。也就是说事件的发出和消费都是在同一个线程的。观察者模式本身的目的就是『后台处理，前台回调』的异步机制，因此异步对于`RxJava`是至关重要的。而要实现异步，则需要用到`RxJava`的另一个概念：`Scheduler`。   
+在不指定线程的情况下，`RxJava`遵循的是线程不变的原则，即在哪个线程调用`subscribe()`方法就在哪个线程生产事件；       在哪个线程生产事件，就在哪个线程消费事件。也就是说事件的发出和消费都是在同一个线程的。观察者模式本身的目的就是『后台处理，前台回调』的异步机制，因此异步对于`RxJava`是至关重要的。而要实现异步，则需要用到`RxJava`的另一个概念：`Scheduler`。   
 
 
 #### `Scheduler`简介
@@ -98,16 +100,23 @@ Observable.just("Hello ", "World !")
         });
 ```
 
-上面这段代码中，`subscribeOn(Schedulers.io())`的指定会让创建的事件的内容`Hello `、`World !`将会在`IO`线程发出；而由于`observeOn(AndroidScheculers.mainThread())` 的指定，因此`subscriber()`方法设置后的回调中内容的打印将发生在主线程中。事实上，这种在`subscribe()`之前写上两句`subscribeOn(Scheduler.io())`和`observeOn(AndroidSchedulers.mainThread())`的使用方式非常常见，它适用于多数的***后台线程取数据，主线程显示***的程序策略。
+上面这段代码中，`subscribeOn(Schedulers.io())`的指定会让创建的事件的内容`Hello `、`World !`将会在`IO`线程发出；      
+
+而由于`observeOn(AndroidScheculers.mainThread())` 的指定，因此`subscriber()`方法设置后的回调中内容的打印将发生在主线程中。     
+事实上，这种在`subscribe()`之前写上两句`subscribeOn(Scheduler.io())`和`observeOn(AndroidSchedulers.mainThread())`的使用方式非常常见，它适用于多数的***后台线程取数据，主线程显示***的程序策略。
 
 #### `Scheduler`的原理
 
-`RxJava`的`Scheduler API`很方便，也很神奇（加了一句话就把线程切换了，怎么做到的？而且 subscribe() 不是最外层直接调用的方法吗，它竟然也能被指定线程？）。然而 Scheduler 的原理需要放在后面讲，因为它的原理是以下一节《变换》的原理作为基础的。
+`RxJava`的`Scheduler API`很方便，也很神奇（加了一句话就把线程切换了，怎么做到的？而且subscribe()不是最外层直接调用的方法吗，它竟然也能被指定线程？）。然而Scheduler的原理需要放在后面讲，因为它的原理是以下一节《变换》的原理作为基础的。
 
 好吧这一节其实我屁也没说，只是为了让你安心，让你知道我不是忘了讲原理，而是把它放在了更合适的地方。
 
 
-能不能多切换几次线程？答案是：能。因为`observeOn()`指定的是`Subscriber`的线程，而这个`Subscriber`并不是（严格说应该为『不一定是』，但这里不妨理解为『不是』）`subscribe()` 参数中的`Subscriber`，而是`observeOn()`执行时的当前`Observable`所对应的`Subscriber`，即它的直接下级`Subscriber`。换句话说`observeOn()` 指定的是它之后的操作所在的线程。因此如果有多次切换线程的需求，只要在每个想要切换线程的位置调用一次`observeOn()`即可。
+能不能多切换几次线程？答案是：能。      
+
+因为`observeOn()`指定的是`Subscriber`的线程，而这个`Subscriber`并不是（严格说应该为『不一定是』，但这里不妨理解为『不是』）`subscribe()` 参数中的`Subscriber`，而是`observeOn()`执行时的当前`Observable`所对应的`Subscriber`，即它的直接下级`Subscriber`。      
+
+换句话说`observeOn()` 指定的是它之后的操作所在的线程。因此如果有多次切换线程的需求，只要在每个想要切换线程的位置调用一次`observeOn()`即可。
 
 上代码：
 
@@ -140,13 +149,19 @@ Observable.just(1, 2, 3, 4) // IO 线程，由 subscribeOn() 指定
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/rxjava_observable_list.jpg?raw=true)
 
-图中共有5处含有对事件的操作。由图中可以看出，①和②两处受第一个`subscribeOn()`影响，运行在红色线程；③和④处受第一个`observeOn()`的影响，运行在绿色线程；⑤处受第二个 `onserveOn()`影响，运行在紫色线程；而第二个`subscribeOn()`，由于在通知过程中线程就被第一个`subscribeOn()` 截断，因此对整个流程并没有任何影响。这里也就回答了前面的问题：当使用了多个`subscribeOn()`的时候，只有第一个`subscribeOn()`起作用。
+图中共有5处含有对事件的操作。由图中可以看出，①和②两处受第一个`subscribeOn()`影响，运行在红色线程；     
+③和④处受第一个`observeOn()`的影响，运行在绿色线程；      
+⑤处受第二个 `onserveOn()`影响，运行在紫色线程；而第二个`subscribeOn()`，由于在通知过程中线程就被第一个`subscribeOn()` 截断，因此对整个流程并没有任何影响。     
+
+这里也就回答了前面的问题：当使用了多个`subscribeOn()`的时候，只有第一个`subscribeOn()`起作用。
 
 在前面讲`Subscriber`的时候，提到过`Subscriber`的`onStart()`可以用作流程开始前的初始化。然而`onStart()`由于在`subscribe()`发生时就被调用了，因此不能指定线程，而是只能执行在`subscribe()`被调用时的线程。这就导致如果`onStart()`中含有对线程有要求的代码（例如在界面上显示一个`ProgressBar`，这必须在主线程执行），将会有线程非法的风险，因为有时你无法预测`subscribe()`将会在什么线程执行。
 
-而与`Subscriber.onStart()`相对应的，有一个方法`Observable.doOnSubscribe()`。它和`Subscriber.onStart()`同样是在`subscribe()`调用后而且在事件发送前执行，但区别在于它可以指定线程。默认情况下,`doOnSubscribe()`执行在`subscribe()`发生的线程；而如果在`doOnSubscribe()`之后有`subscribeOn()`的话，它将执行在离它最近的`subscribeOn()`所指定的线程。
+而与`Subscriber.onStart()`相对应的，有一个方法`Observable.doOnSubscribe()`。      
+它和`Subscriber.onStart()`同样是在`subscribe()`调用后而且在事件发送前执行，但区别在于它可以指定线程。       
+默认情况下,`doOnSubscribe()`执行在`subscribe()`发生的线程；而如果在`doOnSubscribe()`之后有`subscribeOn()`的话，它将执行在离它最近的`subscribeOn()`所指定的线程。
 
-示例代码：
+示例代码:       
 
 ```java
 Observable.create(onSubscribe)
diff --git "a/RxJavaPart/4.RxJava\350\257\246\350\247\243\344\271\213\346\211\247\350\241\214\345\216\237\347\220\206(\345\233\233).md" "b/RxJavaPart/4.RxJava\350\257\246\350\247\243\344\271\213\346\211\247\350\241\214\345\216\237\347\220\206(\345\233\233).md"
index 52de63e3..913f85d2 100644
--- "a/RxJavaPart/4.RxJava\350\257\246\350\247\243\344\271\213\346\211\247\350\241\214\345\216\237\347\220\206(\345\233\233).md"
+++ "b/RxJavaPart/4.RxJava\350\257\246\350\247\243\344\271\213\346\211\247\350\241\214\345\216\237\347\220\206(\345\233\233).md"
@@ -300,7 +300,7 @@ public interface Subscription {
 observable.subscribe(subscriber)源码分析
 ---
 
-好了，关系部分出现了，我们继续看`Observable`类中的`subscribe()`方法，上面在将`Observable`源码的时候我们简单带过这部分，没有细说，这里仔细说一下:     
+好了，关键部分出现了，我们继续看`Observable`类中的`subscribe()`方法，上面在将`Observable`源码的时候我们简单带过这部分，没有细说，这里仔细说一下:     
 ```java
 public class Observable<T> {
     final OnSubscribe<T> onSubscribe;
@@ -486,6 +486,7 @@ observable.subscribe(subscriber);
 ```
 
 总结一下:
+
 - 首先我们调用`Observable.create(OnSubscribe f)`创建一个观察者，同时创建一个`OnSubscribe`接口的实现类作为`create()`方法的参数，并重写该接口的`call()`方法，在`call()`方法中我们调用`subscriber`的`onNext()`、`onComplete()`及`onError()`方法。而这个`call()`方法中的`subscriber`对象就是我们后面调用`observable.subscribe(subscriber);`所传递的`subscribe`对象。    
 - 然后调用`new Subscriber()`创建一个`Subscriber`类的实例。 
 - 最后通过`observable.subscribe(subscriber);`将`Observable`和`Subscriber`对象进行绑定。来订阅我们自己创建的观察者`Subscriber`对象。

From 6e62714220a38e976e478731f7946a4636d318d7 Mon Sep 17 00:00:00 2001
From: xuchuanren <charon.chui@gmail.com>
Date: Tue, 14 May 2024 15:37:45 +0800
Subject: [PATCH 179/213] update

---
 .../Gradle\344\270\223\351\242\230.md"        |  27 ++++
 Gradle&Maven/kts.md                           | 124 ++++++++++++++++++
 2 files changed, 151 insertions(+)
 create mode 100644 Gradle&Maven/kts.md

diff --git "a/Gradle&Maven/Gradle\344\270\223\351\242\230.md" "b/Gradle&Maven/Gradle\344\270\223\351\242\230.md"
index b2689789..253a8c33 100644
--- "a/Gradle&Maven/Gradle\344\270\223\351\242\230.md"
+++ "b/Gradle&Maven/Gradle\344\270\223\351\242\230.md"
@@ -15,6 +15,12 @@ Gradle的版本在`gradle/wrapper/gradle-wrapper.properties`下:
 gradle-wrapper是对Gradle的一层包装，便于在团队开发过程中统一Gradle构建的版本号，这样大家都可以使用统一的Gradle版本进行构建。 
 里面的distributionUrl属性是用于配置Gradle发行版压缩包的下载地址。    
 
+Gradle 是一个 运行在 JVM 的通用构建工具,其核心模型是一个由 Task 组成的有向无环图(Directed Acyclic Graphs).
+
+
+![image](https://github.com/CharonChui/Pictures/blob/master/gradle_task_1.png?raw=true)
+
+
 简介
 ---
 
@@ -35,6 +41,27 @@ Java程序员可以无缝切换到使用Groovy开发程序。Groovy说白了就
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/android_build_process.png?raw=true)
 
+
+说起来我们一直在使用Gradle，但仔细想想我们在项目中其实没有用gradle命令，而一般是使用gradlew命令，同时如下图所示，找遍整个项目，与gradle有关的就这两个文件夹，却只发现gradle-wrapper.jar。
+
+
+那么问题来了，gradlew是什么，gradle-wrapper.jar又是什么?
+
+wrapper的意思：包装。
+
+那么可想而已，这是gradle的包装。其实是这样的，因为gradle处于快速迭代阶段，经常发布新版本，如果我们的项目直接去引用，那么更改版本等会变得无比麻烦。而且每个项目又有可能用不一样的gradle版本，这样去手动配置每一个项目对应的gradle版本就会变得麻烦，gradle的引入本来就是想让大家构建项目变得轻松，如果这样的话，岂不是又增加了新的麻烦？
+
+所以android想到了包装，引入gradle-wrapper，通过读取配置文件中gradle的版本，为每个项目自动的下载和配置gradle，就是这么简单。我们便不用关心如何去下载gradle,如何配置到项目中。
+
+至于gradlew也是一样的道理，它共有两个文件，gradlew是在linux,mac下使用的，gradlew.bat是在window下使用的，提供在命令行下执行gradle命令的功能
+
+至于为什么不直接执行Gradle，而是执行Gradlew命令呢?
+
+因为就像wrapper本身的意义，gradle命令行也是善变的，所以wrapper对命令行也进行了一层封装，使用同一的gradlew命令，wrapper会自动去执行具体版本对应的gradle命令。
+
+同时如果我们配置了全局的gradle命令，在项目中如果也用gradle容易造成混淆，而gradlew明确就是项目中指定的gradle版本，更加清晰与明确
+
+
 ### Gradle的生命周期
 
 1. Initialization：初始化阶段     
diff --git a/Gradle&Maven/kts.md b/Gradle&Maven/kts.md
new file mode 100644
index 00000000..a12bb7ca
--- /dev/null
+++ b/Gradle&Maven/kts.md
@@ -0,0 +1,124 @@
+Gradle 支持使用 Groovy DSL 或 Kotlin DSL 来编写脚本。所以在学习具体怎么写脚本时，我们肯定会考虑到底是使用 Kotlin 来写还是 Groovy 来写。
+
+不一定说你是 Kotlin Android 开发者就一定要用 Kotlin 来写 Gradle，我们得判断哪种写法更适合项目、更适合开发团队人群（学习成本）。
+
+所以下面来学习一下这两种语言的差异。
+
+1. Groovy 和 Kotlin 的差异
+1.1 语言差异
+Groovy
+Groovy是一种基于 JVM 的面向对象的编程语言，它可以作为常规编程语言，但主要是作为脚本的语言（为了解决 Java 在写脚本时过于死板）。它是一个动态语言，可以不指定变量类型。它的特性是支持闭包，闭包的本质很简单，简单的说就是定义一个匿名作用域，这个作用域内部可以封装函数和变量，外部不可以访问这个作用域内部的东西，但是可以通过调用这个作用域来完成一些任务。
+Kotlin
+Kotlin 则是 Java 的优化版，在解决 Kotlin 很多痛点的情况下，不引入过多的新概念。它具有强大的类型推断系统，使得语言有良好的动态性，其次是其语言招牌 —— 语法糖，Kotlin 的代码可以写的非常简洁。这使得 Kotlin 不仅做为常规编程语言能大放异彩，作为脚本语言也深受很多开发者喜爱。
+它们共同特点就是基于JVM，可以和 Java 互操作。Gradle 能提供的东西， Kotlin 也能通过提供（闭包）。在功能上，两者能做的事情都是一样的。此外一些简单的差异有：
+
+groovy 字符串可以使用单引号，而 kotlin 则必须为双引号
+groovy 在方法调用时可以省略扩号，而 kotlin 不可省略
+groovy 分配属性时可以省略 = 赋值运算符，而 kotlin 不可省略
+groovy 是动态语言，不用导包，而 kotlin 则需要。
+
+
+
+为什么要用Kotlin DSL写gradle脚本
+撇开其他方面，就单从提高程序员生产效率方面就有很多优点：
+
+脚本代码自动补全
+跳转查看源码
+动态显示注释
+支持重构(Refactoring)
+…
+怎么样，要是你经历过groovy那令人蛋疼的体验，kotlin会让你爽的起飞，接下来让我们开始吧。
+
+从Groovy到Kotlin
+让我们使用Android Studio 新建一个Android项目，AS默认会为我们生成3个gradle脚本文件。
+
+settings.gradle (属于 project)
+build.gradle (属于 project)
+build.gradle (属于 module)
+我们的目的就是转换这3个文件
+
+第一步: 修改groovy语法到严格格式
+groovy既支持双引号""也支持单引号''，而kotlin只支持双引号，所以首先将所有的单引号改为双引号。
+
+例如 include ':app' -> include ":app"
+
+groovy方法调用可以不使用() 但是kotlin方法调用必须使用(),所以将所有方法调用改为()方式。
+
+例如
+
+implementation "androidx.appcompat:appcompat:1.0.2"
+改为
+
+ implementation ("androidx.appcompat:appcompat:1.0.2")
+groovy 属性赋值可以不使用=，但是kotlin属性赋值需要使用=，所以将所有属性赋值添加=。
+
+例如
+
+applicationId "com.ss007.gradlewithkotlin"
+改为
+
+applicationId = "com.ss007.gradlewithkotlin"
+完成以上几步，准备工作就完成了。
+
+
+
+
+1.2 文件差异
+两者编写 Gradle 的文件是有差异的：
+
+用 Groovy 写的 Gradle 文件是 .gradle 后缀
+用 Kotlin 写的 Gradle 文件是 .gradle.kts 为后缀
+两者的主要区别是：
+
+代码提示和编译检查
+.kts 内所有都是基于kotlin代码规范的，所以强类型语言的好处就是编译没通过的情况下根本无法运行。此外，IDE 集成后可以提供自动补全代码的能力
+.gradle 则不会有代码提示和编译检查
+源代码、文档查看
+.gradle 被编译后是 JVM 字节码，有时候无法查看其源码
+.kts 的 DSL 是通过扩展函数实现的（可以看这篇：Kotlin DSL 学习），IDE 支持下可以导航到源代码、文档或重构部分
+对于写脚本的人来说，两者的差异不大，因为 Gradle 的 DSL 是 Groovy 提供的，后来的 Kotlin 并没有另起炉灶，而是写了一套 Kotlin 版的。所以两者在代码上也就只有所用语言的差异了，概念啥的都是一样的。
+
+作为一名 Kotlin Android 开发者，我之后基本上是使用 Kotlin DSL 来学习写 Gradle 脚本，但是就跟我上面说的一样，了解其中一个后，要搞懂另外一个成本是很低的。
+
+
+2. 基本命令
+2.1 Project 、 Task 和 Action 介绍
+Gradle 主要是围绕着 Project（项目）、Task（任务）、Action（行为）这几个概念进行的。它们的作用分别是：
+
+project：每次 build 可以由一个或多个 project 组成。Gradle 为每个 build.gradle 创建一个相应的 project 领域对象，在编写Gradle脚本时，我们实际上是在操作诸如 project 这样的 Gradle 领域对象。
+若要创建多 project 的项目，我们需要在 根工程（root目录）下面新建 settings.gradle 文件，将所有的子 project 都写进去（include）。在 Android 中，每个 Module 都是一个子 project。
+task：每个 project 可以由一个或多个 task 组成。它代表更加细化的构建任务，例如：签名、编译一些java文件等。
+action：每个 task 可以由一个或多个 action 组成，它有 doFirst{} 和 doLast{} 两种类型
+————————————————
+
+                            
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

From 3aa5408f12cd8c5bb41410aba3d48f0d1616961f Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Tue, 14 May 2024 19:14:34 +0800
Subject: [PATCH 180/213] update OpenGL part

---
 .../1.RxJava\350\257\246\350\247\243(\344\270\200).md"   | 9 +++++++++
 .../OpenGL/1.OpenGL\347\256\200\344\273\213.md"          | 4 ++--
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git "a/RxJavaPart/1.RxJava\350\257\246\350\247\243(\344\270\200).md" "b/RxJavaPart/1.RxJava\350\257\246\350\247\243(\344\270\200).md"
index 6767b6d9..9e6e2c14 100644
--- "a/RxJavaPart/1.RxJava\350\257\246\350\247\243(\344\270\200).md"
+++ "b/RxJavaPart/1.RxJava\350\257\246\350\247\243(\344\270\200).md"
@@ -83,6 +83,15 @@ public void rxFetchUserDetails() {
 
 从根本上讲，函数响应式编程是在观察者模式的基础上，增加对`Observables`发送的数据流进行操纵和变换的功能。
 
+
+
+特殊注意：
+
+（1） 若Observable.subscribeOn（）多次指定被观察者 生产事件的线程，则只有第一次指定有效，其余的指定线程无效。
+（2） 若Observable.observeOn（）多次指定观察者 接收 & 响应事件的线程，则每次指定均有效，即每指定一次，就会进行一次线程的切换。
+
+
+
 `RxJava`简介
 ---
 
diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
index 5f45c5d2..9b8ba320 100644
--- "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -245,7 +245,7 @@ GLFW是一个专门针对OpenGL的C语言库，它提供了一些渲染物体所
 它把一个单独的顶点作为输入。顶点着色器主要的目的是把3D坐标转为另一种3D坐标（后面会解释）从而生成每个顶点的最终位置，同时顶点着色器允许我们对顶点属性进行一些基本处理。
 
 
-所有顶点着色器的主要目标都是讲顶点发送给管线(正如之前所说的它会对每个顶点进行处理)。
+所有顶点着色器的主要目标都是将顶点发送给管线(正如之前所说的它会对每个顶点进行处理)。
 
 顶点着色器可以操作的属性有: 位置、颜色、纹理坐标，但是不能创建新的顶点。最终产生纹理坐标、颜色、点位置等信息送往后续阶段。
 
@@ -381,7 +381,7 @@ OpenGLES3.0 VBO和EBO的出现就是为了解决这个问题。VBO和EBO的作
 
 把数据发送给OpenGL管线还要更加复杂一点，有两种方式:    
 
-- 通过顶点属性的缓冲区；
+- 通过顶点属性的缓冲区。
 - 直接发送给统一变量。
 
 理解这两种方式的机制非常重要，因为这样我们才能为每个要发送的项目选取合适的方式。  

From d903180e00476bac0a045be60e636a6e3a7638c4 Mon Sep 17 00:00:00 2001
From: Charon <CharonChui@users.noreply.github.com>
Date: Tue, 14 May 2024 20:09:27 +0800
Subject: [PATCH 181/213] =?UTF-8?q?Update=201.Kotlin=5F=E7=AE=80=E4=BB=8B&?=
 =?UTF-8?q?=E5=8F=98=E9=87=8F&=E7=B1=BB&=E6=8E=A5=E5=8F=A3.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...&\347\261\273&\346\216\245\345\217\243.md" | 44 +++++++++++--------
 1 file changed, 26 insertions(+), 18 deletions(-)

diff --git "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md" "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
index 72e4986b..6bd6e2fe 100644
--- "a/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
+++ "b/KotlinCourse/1.Kotlin_\347\256\200\344\273\213&\345\217\230\351\207\217&\347\261\273&\346\216\245\345\217\243.md"
@@ -673,8 +673,8 @@ class Person{
 }
 ```
 
-如果类有一个主构造函数，每个次构造函数都需要委托给主构造函数(不然会报错)， 可以直接委托或者通过别的次构造函数间接委托。
-委托到同一个类的另一个构造函数用`this`关键字即可:    
+**如果类有一个主构造函数，每个次构造函数都需要委托给主构造函数(不然会报错)， 可以直接委托或者通过别的次构造函数间接委托。
+委托到同一个类的另一个构造函数用`this`关键字即可:**    
 ```kotlin
 class Person constructor(name: String) {
     constructor(name: String, surName: String) : this(name) {
@@ -711,7 +711,7 @@ class Example(p: Int) : Base(p)
 ```
 
 如果该类有一个主构造函数，那么其基类型可以用主构造函数的参数进行初始化。   
-如果该类没有主构造函数，那么每个次构造函数必须使用super关键字初始化其类型，或者委托给另一个构造函数初始化。如：   
+**如果该类没有主构造函数，那么每个次构造函数必须使用super关键字初始化其类型，或者委托给另一个构造函数初始化**。如：   
 ```kotlin
 class Example : View {
     constructor(ctx: Context) : super(ctx)
@@ -954,12 +954,12 @@ class User(val name: String, val age: Int) {
 }
 ```
 
-在上面的实例中，User类还有一个special函数，使用User::special可以获取成员函数的对象，然后使用invoke函数调用special函数，以获取该函数的内容。   
+**在上面的实例中，User类还有一个special函数，使用User::special可以获取成员函数的对象，然后使用invoke函数调用special函数，以获取该函数的内容。**   
 
 
 ### 构造函数引用
 
-构造函数的引用和属性、方法类似，构造函数可以作用于任何函数类型的对象，该函数的对象与构造函数的参数相同，可以使用::操作符加类名的方式来引用构造函数。 
+**构造函数的引用和属性、方法类似，构造函数可以作用于任何函数类型的对象，该函数的对象与构造函数的参数相同，可以使用::操作符加类名的方式来引用构造函数。** 
 
 ```kotlin
 class Foo
@@ -1030,14 +1030,17 @@ class SuperPerson(num: Int) : Person(num)
 请记住，即使你没有在父类中显式地添加构造函数，编译器也会在编译代码的时候自动创建一个空构造函数。
 假如我们不想为Person类添加构造函数，因此编译器在编译代码的时候创建了一个空构造函数。该构造函数通过使用Person()被调用。
 
-注意： 上面在说到继承的时候`class SuperPerson(num: Int) : Person(num)`在父类后面必须加上括号，这是为了能够调用到父类的主构造函数。
-Kotlin中规定，当一个类既有主构造函数又有次构造函数时，所有的次构造函数都必须调用主构造函数(包括间接调用)。
-但是如果类没有主构造函数，那么每个次构造函数必须使用`super`关键字初始化其基类型，或委托给另一个构造函数做到这一点。 这里很特殊，在Kotlin
-中是允许类中只有次构造函数，没有主构造函数的。当一个类没有显式的定义主构造函数且定义了次构造函数时，它就是没有主构造函数的。
 
-如果该类有一个主构造函数，其基类必须用基类型的主构造函数参数就地初始化。
+***注意： 上面在说到继承的时候`class SuperPerson(num: Int) : Person(num)`在父类后面必须加上括号，这是为了能够调用到父类的主构造函数。
+Kotlin中规定，当一个类既有主构造函数又有次构造函数时，所有的次构造函数都必须调用主构造函数(包括间接调用)。***
+***但是如果类没有主构造函数，那么每个次构造函数必须使用`super`关键字初始化其基类型，或委托给另一个构造函数做到这一点。 这里很特殊，在Kotlin
+中是允许类中只有次构造函数，没有主构造函数的。当一个类没有显式的定义主构造函数且定义了次构造函数时，它就是没有主构造函数的。***
+
+***如果该类有一个主构造函数，其基类必须用基类型的主构造函数参数就地初始化。***
+
+***如果类没有主构造函数，那么每个次构造函数必须使用`super`关键字初始化其基类型，或委托给另一个构造函数做到这一点。***
+
 
-如果类没有主构造函数，那么每个次构造函数必须使用`super`关键字初始化其基类型，或委托给另一个构造函数做到这一点。
 注意，在这种情况下，不同的次构造函数可以调用基类型的不同的构造函数:   
 
 ```kotlin
@@ -1046,11 +1049,15 @@ class MyView : View {
     constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs)
 }
 ```
-也就是MyView类的后面没有显式的定义主构造函数，同时又定义了次构造函数。所以现在MyView类是没有主构造函数的。那么既然没有主构造函数，继承View类
-的时候也就不需要再在View类后加上括号了。其实原因就是这么简单，只是很多人在刚开始学习Kotlin的时候没能理解这对括号的意义和规则，因此总感觉继承的
+
+也就是MyView类的后面没有显式的定义主构造函数，同时又定义了次构造函数。所以现在MyView类是没有主构造函数的。     
+
+***那么既然没有主构造函数，继承View类的时候也就不需要再在View类后加上括号了。***
+
+其实原因就是这么简单，只是很多人在刚开始学习Kotlin的时候没能理解这对括号的意义和规则，因此总感觉继承的
 写法有时候要加上括号，有时候又不要加，搞得晕头转向的，而在你真正理解了规则之后，就会发现其实还是很好懂的。
 
-另外，由于没有主构造函数，次构造函数只能直接调用父类的构造函数，上述代码也是将this关键字换成了super关键字，这部分就很好理解了。
+***另外，由于没有主构造函数，次构造函数只能直接调用父类的构造函数，上述代码也是将this关键字换成了super关键字，这部分就很好理解了。***
 
 
 ### Any
@@ -1283,14 +1290,15 @@ Unit与Int一样，都是一种类型，然而它不代表任何信息，用面
 
 ### 表达式函数体
 
-如果返回的结果可以使用一个表达式计算出来，你可以不使用括号而是使用等号:         
+***如果一个函数的返回的结果可以使用一个表达式计算出来，你可以不使用括号而是使用等号***:         
 
 ```kotlin
 fun add(x: Int,y: Int) : Int = x + y // 省略了{}
 ```
 
-Kotlin支持这种单行表达式与等号的语法来定义函数，叫做表达式函数体，作为区分，普通的函数声明则可以叫做代码块函数体。如你所见，在使用表达式函数体
-的情况下我们可以不声明返回值类型，这进一步简化了语法。
+***Kotlin支持这种单行表达式与等号的语法来定义函数，叫做表达式函数体，作为区分，普通的函数声明则可以叫做代码块函数体。***    
+
+如你所见，在使用表达式函数体的情况下我们可以不声明返回值类型，这进一步简化了语法。
 
 我们可以给参数指定一个默认值使的它们变的可选，这是非常有帮助的。这里有一个例子，在`Activity`中创建了一个函数用来`Toast`一段信息:    
 
@@ -1367,7 +1375,7 @@ val mList2 = vars(0, *myArray, 6, 7)
 
 ### 类布局
 
-通常，一个类的内容按以下顺序排列：
+通常，一个类的内容按以下顺序排列:      
 
 - 属性声明与初始化块
 - 次构造函数

From 7d12b58dc9bc2400c9a76ef722c243ccda98354d Mon Sep 17 00:00:00 2001
From: Charon <CharonChui@users.noreply.github.com>
Date: Tue, 14 May 2024 21:29:59 +0800
Subject: [PATCH 182/213] =?UTF-8?q?Update=202.Kotlin=5F=E9=AB=98=E9=98=B6?=
 =?UTF-8?q?=E5=87=BD=E6=95=B0&Lambda&=E5=86=85=E8=81=94=E5=87=BD=E6=95=B0.?=
 =?UTF-8?q?md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...05\350\201\224\345\207\275\346\225\260.md" | 98 ++++++++++++-------
 1 file changed, 62 insertions(+), 36 deletions(-)

diff --git "a/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md" "b/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
index dba30dbf..166994ce 100644
--- "a/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
+++ "b/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
@@ -30,7 +30,7 @@ fun <T> lock(lock: Lock, body: () -> T): T {
 
 调用lock函数时，可以传入另一个函数作为参数。  
 
-和许多编程语言类似，如果函数的最后一个参数也是函数，则该函数参数还可以定义在括号外面，如:   
+***和许多编程语言类似，如果函数的最后一个参数也是函数，则该函数参数还可以定义在括号外面***，如:   
 ```kotlin
 val result = lock(lock, { sharedResource.operation()})
 // 等同于
@@ -42,7 +42,7 @@ lock(lock) {
 
 高阶函数类似C语言的函数指针，它的另一个使用场景是map函数。
 
-如果函数只有一个参数，则可以忽略声明的函数参数，用it来代替。   
+***如果函数只有一个参数，则可以忽略声明的函数参数，用it来代替。***   
 
 ```kotlin
 val doubled = mMap.map {it -> it * 2}
@@ -183,7 +183,8 @@ class CountryTest {
 
 - 需要把isBigEuropeanCountry的方法引用当做参数传递给filterCountries
 
-    Kotlin存在一种特殊的语法，通过两个冒号来实现对于某个类的方法进行引用(方法引用表达式)。以上面的代码为例，假如我们有一个CountryTest类的对象实例countryTest，如果要引用它的isBigEuropeanCountry方法，就可以这样写:   
+    **Kotlin存在一种特殊的语法，通过两个冒号来实现对于某个类的方法进行引用(方法引用表达式)。**
+    以上面的代码为例，假如我们有一个CountryTest类的对象实例countryTest，如果要引用它的isBigEuropeanCountry方法，就可以这样写:   
 
     ```kotlin
     countryTest::isBigEuropeanCountry
@@ -307,26 +308,27 @@ val foo = { x: Int ->
 ```java
 // 没有使用Lambda的老方法:   
 button.addActionListener(new ActionListener(){
-	public void actionPerformed(ActionEvent ae){
-		System.out.println("Actiondetected");
-	}
+    public void actionPerformed(ActionEvent ae){
+        System.out.println("Actiondetected");
+    }
 });
 // 使用Lambda:  
-button.addActionListener(()->{ 
-	System.out.println("Actiondetected");
+button.addActionListener(() -> { 
+    System.out.println("Actiondetected");
 });
 
 
 // 不采用Lambda的老方法: 
-Runnable runnable1=new Runnable(){
-	@Override
-	public void run(){
-		System.out.println("RunningwithoutLambda");
-	}
+Runnable runnable1 = new Runnable() {
+    @Override
+    public void run() {
+        System.out.println("RunningwithoutLambda");
+    }
 };
+
 // 使用Lambda:   
-Runnable runnable2=()->{
-	System.out.println("RunningfromLambda");
+Runnable runnable2 = () -> {
+    System.out.println("RunningfromLambda");
 };
 ```
 
@@ -357,10 +359,10 @@ max(strings, compare)
 ```
 就是找出`strings`里面最长的那个。但是我个人觉得`compare`还是很碍眼的，因为我并不想在后面引用他，那我怎么办呢，就是用“匿名函数”方式。
 ```kotlin
-max(strings, (a,b)->{a.length < b.length})
+max(strings, (a,b) -> {a.length < b.length})
 ```
 
-`(a,b)->{a.length < b.length}`就是一个没有名字的函数，直接作为参数赋给`max`方法的第二个参数。但这个方法有很多东西都没有写明，如:   
+`(a,b) -> {a.length < b.length}`就是一个没有名字的函数，直接作为参数赋给`max`方法的第二个参数。但这个方法有很多东西都没有写明，如:   
 
 - 参数的类型
 - 返回值的类型
@@ -409,7 +411,7 @@ val msg = { x: Int -> "xxx" }
 (Int) -> String
 ```
 
-如果将lambda赋值给一个变量，编译器会根据该lambda来推测变量的类型，如上例所示。然而，就像任何其他类型的对象一样，你可以显式地定义该变量的类型。例如，以下代码定义了一个变量add，该变量可以保存对具有两个Int参数并返回Int类型的lambda的引用：
+如果将lambda赋值给一个变量，编译器会根据该lambda来推测变量的类型，如上例所示。然而，就像任何其他类型的对象一样，你可以显式地定义该变量的类型。例如，以下代码定义了一个变量add，该变量可以保存对具有两个Int参数并返回Int类型的lambda的引用:      
 
 ```kotlin
 val add: (Int, Int) -> Int
@@ -420,7 +422,8 @@ add = { x: Int, y: Int -> x + y }
 Lambda类型也被认为是函数类型。
 
 
-当Lambda表达式的参数列表中只有一个参数时，那么可以不声明唯一的参数名，而是可以使用it关键字来代替，因为Kotlin会隐含的声明一个名为it的参数.
+**当Lambda表达式的参数列表中只有一个参数时，那么可以不声明唯一的参数名，而是可以使用it关键字来代替，因为Kotlin会隐含的声明一个名为it的参数.这叫做单个参数的隐式名称，代表了这个Lambda所接收的单个参数**    
+
 ```kotlin
 val list = listOf("Apple", "Bnana", "Orange", "Pear")
 val maxLengthFruit = list.maxBy {it.length}
@@ -435,13 +438,13 @@ fun foo(int: Int) = {
 listOf(1, 2, 3).forEach { foo(it) } // 对一个整数列表的元素遍历调用foo
 ```
 
-这里，你可定会纳闷it是啥？其实它也是Kotlin简化Lambda表达的一种语法糖，叫做单个参数的隐式名称，代表了这个Lambda所接收的单个参数。这里的调用等价于:  
+这里的调用等价于:  
 
 ```kotlin
 listOf(1, 2, 3).forEach { item -> foo(item) }
 ```
 
-如果lambda具有一个单独的参数，而且编译器能够推断其类型，你可以省略该参数，并在lambda的主体中使用关键字it指代它。要了解它是如何工作的，如前所述，假设使用以下代码将lambda赋值给变量：
+假设使用以下代码将lambda赋值给变量：
 
 ```kotlin
 val addFive: (Int) -> Int = { x -> x + 5 }
@@ -453,7 +456,11 @@ val addFive: (Int) -> Int = { x -> x + 5 }
 val addFive: (Int) -> Int = { it + 5 }
 ```
 
-在上述代码中，{it+5}等价于{x->x+5}，但更加简洁。请注意，你只能在编译器能够推断该参数类型的情况下使用it语法。例如，以下代码将无法编译，因为编译器不知道it应该是什么类型：
+在上述代码中，{it+5}等价于{x->x+5}，但更加简洁。      
+
+请注意，你只能在编译器能够推断该参数类型的情况下使用it语法。       
+
+例如，以下代码将无法编译，因为编译器不知道it应该是什么类型：
 
 ```kotlin
 val addFive = { it + 5 } // 该代码无法编译，因为编译器不能推断其类型
@@ -463,7 +470,7 @@ val addFive = { it + 5 } // 该代码无法编译，因为编译器不能推断
 
 
 
-我们看一下foo函数用IDE转换后的Java代码:  
+我们看一下foo函数用IDE转换后的Java代码:      
 
 ```java
 @JvmStatic
@@ -520,13 +527,14 @@ listOf(1, 2, 3).forEach{ foo(it)() }
 ## 闭包
 
 
-闭包就是能够读取其他函数内部变量的函数。   
+**闭包就是能够读取其他函数内部变量的函数。**   
 
 它是函数内部和函数外部信息交换的桥梁。   
 
-在Kotlin中，Lambda表达式或匿名函数(局部函数、对象表达式等)都可以访问它的必报。 
+在Kotlin中，Lambda表达式或匿名函数(局部函数、对象表达式等)都可以访问它的闭包。 
 
-在Kotlin中，你会发现匿名函数体、Lambda在语法上都存在“{}"，由这对花括号包裹的代码如果访问了外部环境变量则被称为一个闭包。一个闭包可以被当做参数传递或直接使用，它可以简单的看成”访问外部环境变量的函数“。Lambda是Kotlin中最常见的闭包形式。
+在Kotlin中，你会发现匿名函数体、Lambda在语法上都存在“{}"，由这对花括号包裹的代码如果访问了外部环境变量则被称为一个闭包。      
+一个闭包可以被当做参数传递或直接使用，它可以简单的看成”访问外部环境变量的函数“。Lambda是Kotlin中最常见的闭包形式。
 
 与Java不一样的地方在于，Kotlin中的闭包不仅可以访问外部变量，还能够对其进行修改(我有点疑惑，Java为啥不能修改？下面说)，如下： 
 
@@ -539,8 +547,6 @@ listOf(1, 2, 3).filter { it > 0 }.forEach {
 println(sum)  // 6
 ```
 
-看到这里我是懵逼的？ 到底什么是闭包？ 闭包有什么作用？ 
-
 闭包就是能够读取其他函数内部变量的函数。例如在javascript中，只有函数内部的子函数才能读取局部变量，所以闭包可以理解成“定义在一个函数内部的函数“。在本质上，闭包是将函数内部和函数外部连接起来的桥梁。--百度百科
 第一句总结的很简洁了：闭包就是能够读取其他函数内部变量的函数。
 
@@ -623,7 +629,7 @@ What java docs says about “Local Inner class cannot access the non-final local
 
 
 
-JVM create create a synthetic field inside the inner class in java -
+JVM create a synthetic field inside the inner class in java -
 
 As final variable will not change after initialization, when a inner class access final local variables **compiler create a synthetic field inside the inner class and also copy that variable into the heap.** So, these synthetic fields can be accessed inside local inner class even when execution of method is over in java.
 
@@ -680,7 +686,9 @@ fun main() {
 
 是不是发现了新世界的大门，内部函数很轻松地调用了外部变量a。
 
-这只是一个最简单的闭包实现。按照这种思想，其他的实现例如：函数、条件语句、Lambda表达式等等都可以理解为闭包，这里不再赘述。不过万变不离其宗，只要记得一句话：**闭包就是能够读取其他函数内部变量的函数**。就是一个函数A可以访问另一个函数B的局部变量，即便另一个函数B执行完成了也没关系。目前把满足这样条件的函数A叫做闭包。
+这只是一个最简单的闭包实现。按照这种思想，其他的实现例如：函数、条件语句、Lambda表达式等等都可以理解为闭包，这里不再赘述。    
+
+不过万变不离其宗，只要记得一句话：**闭包就是能够读取其他函数内部变量的函数**。就是一个函数A可以访问另一个函数B的局部变量，即便另一个函数B执行完成了也没关系。目前把满足这样条件的函数A叫做闭包。
 
 
 
@@ -688,13 +696,21 @@ fun main() {
 
 ## 内联函数
 
-刚被闭包搞蒙，这里又没搞明白内联函数到底是干什么？ 有什么作用？Kotlin中的内联函数其实显得有点尴尬，因为它之所以被设计出来，主要是为了优化Kotlin支持Lambda表达式之后所带来的开销。然而，在Java中我们似乎并不需要特别关注这个问题，因为在Java 7之后，JVM引入了一种叫做invokedynamic的技术，它会自动帮助我们做Lambda优化。但是为什么Kotlin要引入内联函数这种手动的语法呢？ 这主要还是因为Kotlin要兼容Java 6。
+刚被闭包搞蒙，这里又没搞明白内联函数到底是干什么？ 有什么作用？Kotlin中的内联函数其实显得有点尴尬，因为它之所以被设计出来，主要是为了优化Kotlin支持Lambda表达式之后所带来的开销。     
+
+然而，在Java中我们似乎并不需要特别关注这个问题，因为在Java 7之后，JVM引入了一种叫做invokedynamic的技术，它会自动帮助我们做Lambda优化。但是为什么Kotlin要引入内联函数这种手动的语法呢？ 这主要还是因为Kotlin要兼容Java 6。
 
 
 
 ## 优化Lambda开销
 
-在Kotlin中每声明一个Lambda表达式，就会在字节码中产生一个匿名类(也就是说我们一直使用的Lambda表达式在底层被转换成了匿名类的实现方式)。该匿名类包含了一个invoke方法，作为Lambda的调用方法，每次调用的时候，还会创建一个新的匿名类对象。可想而知，Lambda语法虽然简洁，但是额外增加的开销也不少。并且，如果Lambda捕捉了某个变量，那么每次调用的时候都会创建一个新的对象，这样导致效率较低。尤其对Kotlin这门语言来说，它当今优先要实现的目标，就是在Android这个平台上提供良好的语言特性支持。Kotlin要在Android中引入Lambda语法，必须采用某种方法来优化Lambda带来的额外开销，也就是内联函数。 
+在Kotlin中每声明一个Lambda表达式，就会在字节码中产生一个匿名类(也就是说我们一直使用的Lambda表达式在底层被转换成了匿名类的实现方式)。      
+
+该匿名类包含了一个invoke方法，作为Lambda的调用方法，每次调用的时候，还会创建一个新的匿名类对象。      
+
+可想而知，Lambda语法虽然简洁，但是额外增加的开销也不少。并且，如果Lambda捕捉了某个变量，那么每次调用的时候都会创建一个新的对象，这样导致效率较低。     
+
+尤其对Kotlin这门语言来说，它当今优先要实现的目标，就是在Android这个平台上提供良好的语言特性支持。Kotlin要在Android中引入Lambda语法，必须采用某种方法来优化Lambda带来的额外开销，也就是内联函数。 
 
 #### 1. invokedynamic
 
@@ -710,7 +726,9 @@ fun main() {
 
 invokedynamic固然不错，但Kotlin不支持它的理由似乎也很充分，我们有足够的理由相信，其最大的原因是Kotlin在一开始就需要兼容Android最主流的Java版本SE 6，这导致它无法通过invovkedynamic来解决Android平台的Lambda开销问题。 
 
-因此，作为另一种主流的解决方案，Kotlin拥抱了内联函数，在C++、C#等语言中也支持这种特性。简单的来说，我们可以用inline关键字来修饰函数，这些函数就称为了内联函数。他们的函数体在编译期被嵌入每一个被调用的地方，以减少额外生成的匿名类数，以及函数执行的时间开销。
+因此，作为另一种主流的解决方案，Kotlin拥抱了内联函数，在C++、C#等语言中也支持这种特性。     
+
+简单的来说，我们可以用inline关键字来修饰函数，这些函数就称为了内联函数。他们的函数体在编译期被嵌入每一个被调用的地方，以减少额外生成的匿名类数，以及函数执行的时间开销。
 所以内联函数的工作原理并不复杂，就是Kotlin编译器会将内敛函数中的代码在编译的时候自动替换到调用它的地方，这样也就不存在运行时的开销了。 
 
 所以如果你想在用Kotlin开发时获得尽可能良好的性能支持，以及控制匿名类的生成数量，就有必要来学习下内联函数的相关语法。 
@@ -975,7 +993,9 @@ fun main() {
     println("main end")
 }
 ```
-这里定义了一个叫作printString()的高阶函数，用于在Lambda表达式中打印传入的字符串参数。但是如果字符串参数为空，那么就不进行打印。注意，Lambda表达式中是不允许直接使用return关键字的，这里使用了return@printString的写法，表示进行局部返回，并且不再执行Lambda表达式的剩余部分代码。现在我们就刚好传入一个空的字符串参数，运行程序，打印结果如下： 
+这里定义了一个叫作printString()的高阶函数，用于在Lambda表达式中打印传入的字符串参数。但是如果字符串参数为空，那么就不进行打印。      
+
+注意，Lambda表达式中是不允许直接使用return关键字的，这里使用了return@printString的写法，表示进行局部返回，并且不再执行Lambda表达式的剩余部分代码。现在我们就刚好传入一个空的字符串参数，运行程序，打印结果如下： 
 ```
 main start
 printString begin
@@ -1024,7 +1044,9 @@ inline fun runRunnable(block: () -> Unit) {
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/inline_noline_error.png?raw=true)        
 
-这个错误出现的原因解释起来可能会稍微有点复杂。首先，在runRunnable()函数中，我们创建了一个Runnable对象，并在Runnable的Lambda表达式中调用了传入的函数类型参数。而Lambda表达式在编译的时候会被转换成匿名类的实现方式，也就是说，上述代码实际上是在匿名类中调用了传入的函数类型参数。
+这个错误出现的原因解释起来可能会稍微有点复杂。首先，在runRunnable()函数中，我们创建了一个Runnable对象，并在Runnable的Lambda表达式中调用了传入的函数类型参数。      
+
+而Lambda表达式在编译的时候会被转换成匿名类的实现方式，也就是说，上述代码实际上是在匿名类中调用了传入的函数类型参数。
 
 
 而内联函数所引用的Lambda表达式允许使用return关键字进行函数返回，但是由于我们是在匿名类中调用的函数类型参数，此时是不可能进行外层调用函数返回的，最多只能对匿名类中的函数调用进行返回，因此这里就提示了上述错误。
@@ -1064,7 +1086,11 @@ Error: (2, 11) Kotlin: 'return' is not allowed here
 
 #### 具体化参数类型
 
-除了非局部返回之外，内联函数还可以帮助Kotlin实现具体化参数类型。Kotlin与Java一样，由于运行时的类型擦除，我们并不能直接获取一个参数的类型。然而，由于内联函数会直接在字节码中生成相应的函数体实现，这种情况下我们反而可以获得参数的具体类型。我们可以用reified修饰符来实现这一效果。
+除了非局部返回之外，内联函数还可以帮助Kotlin实现具体化参数类型。
+
+**Kotlin与Java一样，由于运行时的类型擦除，我们并不能直接获取一个参数的类型。**  
+
+**然而，由于内联函数会直接在字节码中生成相应的函数体实现，这种情况下我们反而可以获得参数的具体类型。我们可以用reified修饰符来实现这一效果。**
 
 ```kotlin
 fun main(args: Array<String>) {

From fdfc03caf2d7944992e601e2a3756d5072474d37 Mon Sep 17 00:00:00 2001
From: Charon <CharonChui@users.noreply.github.com>
Date: Tue, 14 May 2024 22:18:12 +0800
Subject: [PATCH 183/213] =?UTF-8?q?Update=203.Kotlin=5F=E6=95=B0=E5=AD=97&?=
 =?UTF-8?q?=E5=AD=97=E7=AC=A6=E4=B8=B2&=E6=95=B0=E7=BB=84&=E9=9B=86?=
 =?UTF-8?q?=E5=90=88.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...0\347\273\204&\351\233\206\345\220\210.md" | 35 +++++++++----------
 1 file changed, 17 insertions(+), 18 deletions(-)

diff --git "a/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md" "b/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md"
index 213e4c91..f4d67cad 100644
--- "a/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md"
+++ "b/KotlinCourse/3.Kotlin_\346\225\260\345\255\227&\345\255\227\347\254\246\344\270\262&\346\225\260\347\273\204&\351\233\206\345\220\210.md"
@@ -193,11 +193,10 @@ val str = "$s.length is ${s.length}" // 求值结果为 "abc.length is 3"
 
 ### 字符串判等
 
-Kotlin中的判等性主要有两种类型： 
+Kotlin中的判等性主要有两种类型:       
 
-- 结构相等。通过操作符==来判断两个对象的内容是否相等。
-- 引用相等。通
-引用相等由`===`以及其否定形式`!===`操作判断。`a === b`当且仅当`a`和`b`指向同一个对象时求值为`true`。如果比较的是运行时的原始类型，比如Int，那么===判断的效果也等价于==。
+- 结构相等: 通过操作符==来判断两个对象的内容是否相等。
+- 引用相等: 引用相等由`===`以及其否定形式`!===`操作判断。`a === b`当且仅当`a`和`b`指向同一个对象时求值为`true`。如果比较的是运行时的原始类型，比如Int，那么===判断的效果也等价于==。
 
 ```kotlin
 var a = "Java"
@@ -367,7 +366,7 @@ val newList = list.map{it * 2} // 对集合遍历，在遍历过程中，给每
 
 val mStudents = students.filter{it.sex == "m"} // 筛选出性别为男的学生
 
-val scoreTotal = students.sumBy{it.score} // 拥挤和中的sumby实现求和
+val scoreTotal = students.sumBy{it.score} // 用集合中的sumby实现求和
 ```
 
 #### 通过序列提高效率
@@ -391,7 +390,7 @@ list.asSequence().filter {it > 2}.map {it * 2}.toList()
 toList方法将序列转为列表。将list转换为序列，在很大程度上就提高了上面操作集合的效率。
 因为在使用序列的时候filter方法和map方法的操作都没有创建额外的集合，这样当集合中的元素数量巨大的时候，
 就减少了大部分开销。在Kotlin中，序列中元素的求值是惰性的，这就意味着在利用序列进行链式求值的时候，
-不需要像操作普通集合那样，每进行一次求值操作，就产生一个新的集合保存中间数据。那么什么惰性又是什么意思呢？
+不需要像操作普通集合那样，每进行一次求值操作，就产生一个新的集合保存中间数据。那么惰性又是什么意思呢？
 
 #### 惰性求值
 在编程语言理论中，惰性求值(Lazy Evaluation)表示一种在需要时才进行求值的计算方式。
@@ -406,10 +405,10 @@ toList方法将序列转为列表。将list转换为序列，在很大程度上
 list.asSequence().filter {it > 2}.map {it * 2}.toList()
 ```
 
-在这个例子中，我们序列总共执行了两类操作分别是: 
+在这个例子中，我们序列总共执行了两类操作分别是:     
 
-- `filter{it > 2}.map{it * 2}`:filter和map的操作返回的都是序列，我们将这类操作称为中间操作。
-- `toList()`:这一类操作将序列转换为List，我们将这类操作称为末端操作。
+- `filter{it > 2}.map{it * 2}`: filter和map的操作返回的都是序列，我们将这类操作称为中间操作。
+- `toList()`: 这一类操作将序列转换为List，我们将这类操作称为末端操作。
 
 其实，Kotlin中序列的操作就分为两类： 
 
@@ -432,10 +431,10 @@ list.asSequence().filter {it > 2}.map {it * 2}.toList()
 - 末端操作
 
     在对集合进行操作的时候，大部分情况下，我们在意的只是结果，而不是中间过程。
-  末端操作就是一个返回结果的操作，它的返回值不能是序列，必须是一个明确的结果，
-  比如列表、数字、对象等表意明确的结果。末端操作一般都放在链式操作的末尾，
-  在执行末端操作的时候，会去触发中间操作的延迟计算，也就是将”被需要“这个状态打开了，
-  我们给上面的例子加上末端操作: 
+    末端操作就是一个返回结果的操作，它的返回值不能是序列，必须是一个明确的结果，
+    比如列表、数字、对象等表意明确的结果。末端操作一般都放在链式操作的末尾，
+    在执行末端操作的时候，会去触发中间操作的延迟计算，也就是将”被需要“这个状态打开了，
+    我们给上面的例子加上末端操作: 
 
     ```kotlin
     list.asSequence().filter {
@@ -458,10 +457,10 @@ list.asSequence().filter {it > 2}.map {it * 2}.toList()
     ```
 
     可以看到，所有的中间操作都被执行了。从上面执行打印的结果我们发现，它的执行顺序与我们预想的不一样。
-  普通集合在进行链式操作的时候会先在list上调用filter，然后产生一个结果列表，接下来map就在这个结果列表上进行操作。
-  而序列则不一样，序列在执行链式操作的时候，会将所有的操作都应用在一个元素上，也就是说，第一个元素执行完所有的操作之后，
-  第二个元素再去执行所有的操作，以此类推。放到我们这个例子上面，就是第一个元素执行了filter之后再去执行map，
-  然后第二个元素也是这样。
+    普通集合在进行链式操作的时候会先在list上调用filter，然后产生一个结果列表，接下来map就在这个结果列表上进行操作。
+    而序列则不一样，序列在执行链式操作的时候，会将所有的操作都应用在一个元素上，也就是说，第一个元素执行完所有的操作之后，
+    第二个元素再去执行所有的操作，以此类推。放到我们这个例子上面，就是第一个元素执行了filter之后再去执行map，
+    然后第二个元素也是这样。
 
 #### 序列可以是无限的
 
@@ -525,7 +524,7 @@ if(str == null) {
 }
 ```
 
-那么如果我们需要的就是一个`Int`的结果(事实上大部分情况都是如此)，那又该怎么办呢？在`kotlin`中除了`?`表示可为空以外，还有一个新的符号:双感叹号`!!`，表示一定不能为空。所以上面的例子，如果要对`result`进行操作，可以这么写:  
+那么如果我们需要的就是一个`Int`的结果(事实上大部分情况都是如此)，那又该怎么办呢？在`kotlin`中除了`?`表示可为空以外，还有一个新的双感叹号`!!`符号，表示一定不能为空。所以上面的例子，如果要对`result`进行操作，可以这么写:  
 
 ```kotlin
 var str : String? = null

From 7267cf5dcaefde553324d5d80f49890063067d69 Mon Sep 17 00:00:00 2001
From: Charon <CharonChui@users.noreply.github.com>
Date: Thu, 16 May 2024 17:24:51 +0800
Subject: [PATCH 184/213] =?UTF-8?q?Update=205.Kotlin=5F=E5=86=85=E9=83=A8?=
 =?UTF-8?q?=E7=B1=BB&=E5=AF=86=E5=B0=81=E7=B1=BB&=E6=9E=9A=E4=B8=BE&?=
 =?UTF-8?q?=E5=A7=94=E6=89=98.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...2\344\270\276&\345\247\224\346\211\230.md" | 40 +++++++++++--------
 1 file changed, 23 insertions(+), 17 deletions(-)

diff --git "a/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md" "b/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
index f3f9117d..ce13420d 100644
--- "a/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
+++ "b/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
@@ -43,7 +43,7 @@ inline fun <reified T> startActivity(context: Context) {
     context.startActivity(intent)
 }
 ```
-这里我们定义了一个startActivity()函数，该函数接收一个Context参数，并同时使用inline和reified关键字让泛型T成为了一个被实化的泛型。接下来就是神奇的地方了，Intent接收的第二个参数本来应该是一个具体Activity的Class类型，但由于现在T已经是一个被实化的泛型了，因此这里我们可以直接传入T::class.java。最后调用Context的startActivity()方法来完成Activity的启动。现在，如果我们想要启动TestActivity，只需要这样写就可以了：[插图]Kotlin将能够识别出指定泛型的实际类型，并启动相应的Activity。
+这里我们定义了一个startActivity()函数，该函数接收一个Context参数，并同时使用inline和reified关键字让泛型T成为了一个被实化的泛型。接下来就是神奇的地方了，Intent接收的第二个参数本来应该是一个具体Activity的Class类型，但由于现在T已经是一个被实化的泛型了，因此这里我们可以直接传入T::class.java。最后调用Context的startActivity()方法来完成Activity的启动。现在，如果我们想要启动TestActivity，只需要像下面这样写就可以了，Kotlin将能够识别出指定泛型的实际类型，并启动相应的Activity:       
 ```kotlin
 startActivity<TestActivity>(context)
 ```
@@ -55,7 +55,7 @@ intent.putExtra("param1", "data")
 intent.putExtra("param2", 123)
 context.startActivity(intent)
 ```
-而经过刚才的封装之后，我们就无法进行传参了。这个问题也不难解决，只需要借助之前在第6章学习的高阶函数就可以轻松搞定。回到reified.kt文件当中，这里添加一个新的startActivity()函数重载，如下所示：
+而经过刚才的封装之后，我们就无法进行传参了。这个问题也不难解决，只需要借助之前学习的高阶函数就可以轻松搞定。回到reified.kt文件当中，这里添加一个新的startActivity()函数重载，如下所示：
 ```kotlin
 inline fun <reified T> startActivity(context: Context, block: Intent.() -> Unit) {
     val intent = Intent(context, T::class.java)
@@ -187,13 +187,11 @@ mViewPager.addOnPageChangeListener(object : ViewPager.OnPageChangeListener {
     override fun onPageSelected(position: Int) {
         TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
     }
-
 })
 ```
 
 如果对象实例是一个函数接口，还可以使用Lambda表达式来实现。 
 ```kotlin
-
 val listener = ActionListener {
     println("clicked")
 }
@@ -253,7 +251,7 @@ enum class MessageType(var msg: String) {
 }
 ```
 
-但是使用这种方法存在两个问题： 
+但是使用这种方法存在两个问题:        
 
 - 每个值都是一个常量，并且仅作为单个实例存在。
 
@@ -267,7 +265,11 @@ enum class MessageType(var msg: String) {
 
 ### 密封类
 
-Kotlin除了可以利用final来限制类的继承之外，还可以通过密封类的语法来限制一个类的继承。密封类就像枚举类的加强版本。它允许你将类层次结构限制为一组特定的子类型，每个子类型都可以定义自己的属性和函数。与枚举类不同，你可以创建每种类型的多个实例。 你可以通过使用sealed前缀类名来创建密封类。例如，以下代码创建一个名为MessageType的密封类，其中包含名为MessageSuccess和MessageFailure的子类型。每个子类型都有一个名为msg的String属性，并且MessageFailure子类型中有一个额外的名为e的Exception属性：
+Kotlin除了可以利用final来限制类的继承之外，还可以通过密封类的语法来限制一个类的继承。密封类就像枚举类的加强版本。        
+
+它允许你将类层次结构限制为一组特定的子类型，每个子类型都可以定义自己的属性和函数。与枚举类不同，你可以创建每种类型的多个实例。         
+
+你可以通过使用sealed前缀类名来创建密封类。例如，以下代码创建一个名为MessageType的密封类，其中包含名为MessageSuccess和MessageFailure的子类型。每个子类型都有一个名为msg的String属性，并且MessageFailure子类型中有一个额外的名为e的Exception属性:     
 
 ```kotlin
 sealed class MessageType
@@ -276,7 +278,7 @@ class MessageSuccess(var msg: String) : MessageType()
 class MessageFailure(var msg: String, var e: Exception) : MessageType()
 ```
 
-由于MessageType是一个有限子类的密封类。你可以使用when来检查每个子类型，这样可以避免使用额外的else子句，如以下代码所示:  
+由于MessageType是一个有限子类的密封类。你可以使用when来检查每个子类型，这样可以避免使用额外的else子句，如以下代码所示:      
 
 ```kotlin
 fun main(args: Array<String>) {
@@ -328,7 +330,8 @@ public abstract class Bird {
 ```
 
 
-密封类用来表示受限的类继承结构:当一个值为有限几种的类型、而不能有任何其他类型时。在某种意义上，他们是枚举类的扩展:枚举类型的值集合也是受限的，但每个枚举常量只存在一个实例，而密封类的一个子类可以有可包含状态的多个实例。
+密封类用来表示受限的类继承结构: 当一个值为有限几种的类型、而不能有任何其他类型时。       
+在某种意义上，他们是枚举类的扩展:枚举类型的值集合也是受限的，但每个枚举常量只存在一个实例，而密封类的一个子类可以有可包含状态的多个实例。
 
 虽然密封类也可以有子类，但是所有子类都必须在与密封类自身相同的文件中声明。(在`Kotlin 1.1`之前，该规则更加严格:子类必须嵌套在密封类声明的内部)。
 
@@ -359,7 +362,7 @@ fun eval(expr: Expr): Double = when(expr) {
 
 ### 异常    
 
-在`Kotlin`中，所有的`Exception`都是实现了`Throwable`，含有一个`message`且未经检查。这表示我们不会强迫我们在任何地方使用`try/catch`。
+在`Kotlin`中，所有的`Exception`都是实现了`Throwable`，含有一个`message`且未经检查。这表示我们不会强迫我们在任何地方使用`try/catch`。       
 这与`Java`中不太一样，比如在抛出`IOException`的方法，我们需要使用`try-catch`包围代码块。但是通过检查`exception`来处理显示并不是一个
 好的方法。
 
@@ -372,11 +375,9 @@ throw MyException("Exception message")
 ```kotlin
 try{
     // 一些代码
-}
-catch (e: SomeException) {
+} catch (e: SomeException) {
     // 处理
-}
-finally {
+} finally {
     // 可选的finally块
 }
 ```
@@ -401,7 +402,8 @@ val s = try { x as String } catch(e: ClassCastException) { null }
 在Kotlin中，你将告别static这种语法，因为它引入了全新的关键字object，可以完美的代替使用static的所有场景。
 当然除了代替static的场景之外，它还能实现更多的功能，比如单例对象及简化匿名表达式等。 
 
-声明对象就如同声明一个类，你只需要用保留字`object`替代`class`，其他都相同。只需要考虑到对象不能有构造函数，因为我们不调用任何构造函数来访问它们。事实上，对象就是具有单一实现的数据类型。object声明的内容可以看成没有构造方法的类，它会在系统或者类加载时进行初始化。
+声明对象就如同声明一个类，你只需要用保留字`object`替代`class`，其他都相同。只需要考虑到对象不能有构造函数，因为我们不调用任何构造函数来访问它们。      
+事实上，对象就是具有单一实现的数据类型。object声明的内容可以看成没有构造方法的类，它会在系统或者类加载时进行初始化。
 
 ```kotlin
 object Resource {
@@ -427,7 +429,8 @@ recycler.adapter = object : RecyclerView.Adapter() {
 ```
 例如，每次想要创建一个接口的内联实现，或者扩展另一个类时，你将使用上面的符号。
 
-object表达式和匿名内部类很像，那对象表达式与Lambda表达式哪个更适合代替匿名内部类呢？  当你的匿名内部类使用的类接口只需要实现一个方法时，使用Lambda表达式更适合。当匿名内部类内有多个方法实现的时候，使用object表达式更适合。
+object表达式和匿名内部类很像，那对象表达式与Lambda表达式哪个更适合代替匿名内部类呢?        
+当你的匿名内部类使用的类接口只需要实现一个方法时，使用Lambda表达式更适合。当匿名内部类内有多个方法实现的时候，使用object表达式更适合。
 
 #### 伴生对象
 
@@ -543,9 +546,12 @@ class App : Application() {
 `lateinit`表示这个属性开始是没有值的，但是，在使用前将被赋值（否则，就会抛出异常）。     
 
 
-不过，上面companion object中的isRedpack()方法其实也并不是静态方法，companionobject这个关键字实际上会在类的内部创建一个伴生类，而isRedpack方法就是定义在这个伴生类里面的实例方法。只是Kotlin会保证类始终只会存在一个伴生类对象，因此调用Prize.isRedpack()方法实际上就是调用了Prize类中伴生对象的isRedpack()方法。由此可以看出，Kotlin确实没有直接定义静态方法的关键字，但是提供了一些语法特性来支持类似于静态方法调用的写法，这些语法特性基本可以满足我们平时的开发需求了。然而如果你确确实实需要定义真正的静态方法， Kotlin仍然提供了两种实现方式：注解和顶层方法。
+不过，上面companion object中的isRedpack()方法其实也并不是静态方法，companion object这个关键字实际上会在类的内部创建一个伴生类，而isRedpack方法就是定义在这个伴生类里面的实例方法。      
+
+只是Kotlin会保证类始终只会存在一个伴生类对象，因此调用Prize.isRedpack()方法实际上就是调用了Prize类中伴生对象的isRedpack()方法。     
+由此可以看出，Kotlin确实没有直接定义静态方法的关键字，但是提供了一些语法特性来支持类似于静态方法调用的写法，这些语法特性基本可以满足我们平时的开发需求了。然而如果你确确实实需要定义真正的静态方法， Kotlin仍然提供了两种实现方式：注解和顶层方法。
 
-先来看注解，前面使用的单例类和companion object都只是在语法的形式上模仿了静态方法的调用方式，实际上它们都不是真正的静态方法。因此如果你在Java代码中以静态方法的形式去调用的话，你会发现这些方法并不存在。而如果我们给单例类或companion object中的方法加上@JvmStatic注解，那么Kotlin编译器就会将这些方法编译成真正的静态方法
+先来看注解，前面使用的单例类和companion object都只是在语法的形式上模仿了静态方法的调用方式，实际上它们都不是真正的静态方法。因此如果你在Java代码中以静态方法的形式去调用的话，你会发现这些方法并不存在。而如果我们给单例类或companion object中的方法加上@JvmStatic注解，那么Kotlin编译器就会将这些方法编译成真正的静态方法。
 
 注意，@JvmStatic注解只能加在单例类或companion object中的方法上，如果你尝试加在一个普通方法上，会直接提示语法错误。那么现在不管是在Kotlin中还是在Java中，都可以使用Prize.isRedpack()的写法来调用了。
 

From 776b49b11bbc7ea4a9ad810c34b35105394e74a7 Mon Sep 17 00:00:00 2001
From: Charon <CharonChui@users.noreply.github.com>
Date: Mon, 20 May 2024 17:43:45 +0800
Subject: [PATCH 185/213] =?UTF-8?q?Update=208.Kotlin=5F=E5=8D=8F=E7=A8=8B.?=
 =?UTF-8?q?md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 "KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md" | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git "a/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md" "b/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
index 8fbfda6e..2c319266 100644
--- "a/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
+++ "b/KotlinCourse/8.Kotlin_\345\215\217\347\250\213.md"
@@ -31,11 +31,12 @@ Kotlin引入了协程（Coroutine）来支持更好的异步操作，利用它
 可以说，只要内存足够，一个线程中可以包含任意多个协程，但某一时刻却只能有一个协程在运行，多个协程分享该线程资源。   
 
 ## 进程、线程、协程
-进程：一段程序的执行过程，资源分配和调度的基本单位，有其独立地址空间，互相之间不发生干扰
-线程：轻量级进程，资源调度的最小单位，共享父进程地址空间和资源，其调度和进程一样要切换到内核态
-并行：同时发生，在多核CPU中，多个任务可同时在不同CPU上面同一时间执行
-并发：宏观并行，微观串行，操作系统根据相关算法，分配时间片来调度，从而达到一种宏观上并行的方式
-上下文：程序执行的状态，通常用调用栈记录程序执行的当前状态以及其相关的环境信息
+
+- 进程：一段程序的执行过程，资源分配和调度的基本单位，有其独立地址空间，互相之间不发生干扰      
+- 线程：轻量级进程，资源调度的最小单位，共享父进程地址空间和资源，其调度和进程一样要切换到内核态     
+- 并行：同时发生，在多核CPU中，多个任务可同时在不同CPU上面同一时间执行     
+- 并发：宏观并行，微观串行，操作系统根据相关算法，分配时间片来调度，从而达到一种宏观上并行的方式     
+- 上下文：程序执行的状态，通常用调用栈记录程序执行的当前状态以及其相关的环境信息      
 
 早期，CPU是单核，无法真正并行，为了产生共享CPU的假象，提出了时间片概念，将时间分割成连续的时间片段，多个程序交替获得CPU使用权限。 而管理时间片分配调度的调度器则成为操作系统的核心组件。
 

From 3d564a70e0fbc37e6e3e65b60e8d6e07b7684b18 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 22 May 2024 20:59:20 +0800
Subject: [PATCH 186/213] update

---
 ...2\344\270\276&\345\247\224\346\211\230.md" |  4 +--
 ...45\231\250\350\257\255\350\250\200GLSL.md" | 35 +++++++++++++++++--
 2 files changed, 35 insertions(+), 4 deletions(-)

diff --git "a/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md" "b/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
index ce13420d..d738c4b2 100644
--- "a/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
+++ "b/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
@@ -520,7 +520,7 @@ class Prize private constructor(val name: String, val count: Int, val type: Int)
     fun main(args: Array<String>) {
         val redpackPrize = Prize.newRedpackPrize("hongbao", 10)
         val couponPrize = Prize.newCouponPrize("shiyuan", 10)
-        vval commonPrize = Prize.defaultCommonPrize()
+        val commonPrize = Prize.defaultCommonPrize()
     }
 }
 ```
@@ -903,7 +903,7 @@ void test(){
 ```kotlin
 val p by lazy { ... }
 ```
-现在再来看这段代码，是不是觉得更有头绪了呢？实际上，bylazy并不是连在一起的关键字，只有by才是Kotlin中的关键字，
+现在再来看这段代码，是不是觉得更有头绪了呢？实际上，by lazy并不是连在一起的关键字，只有by才是Kotlin中的关键字，
 lazy在这里只是一个高阶函数而已。在lazy函数中会创建并返回一个Delegate对象，当我们调用p属性的时候，
 其实调用的是Delegate对象的getValue()方法，然后getValue()方法中又会调用lazy函数传入的Lambda表达式，
 这样表达式中的代码就可以得到执行了，并且调用p属性后得到的值就是Lambda表达式中最后一行代码的返回值。
diff --git "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md" "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
index ac66269e..cac05def 100644
--- "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
+++ "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
@@ -53,9 +53,9 @@ OpenGL ES版本有自己的着色器语言，其中OpenGL ES的版本与GLSL的
 
 - OpenGL ES 3.0的shader中没有texture2D()和texture3D等了，全部使用texture()方法替换。
 
-- 300版本中布局限定符可以声明顶点着色器输入和片段着色器输出的问题，例如layout(location = 2) in vec3 values[4];
+- 可直接使用layout制定属性值。 300版本中布局限定符可以声明顶点着色器输入和片段着色器输出的问题，例如layout(location = 2) in vec3 values[4];，如果不限定该属性的位置为2，需要通过glGetAttribuLocation()查询
 
-- 舍弃了gl_FragColor和gl_FragData内置属性，变成我们需要自己使用out关键字定义的属性，例如out vec4 fragColor，这就是为什么你从网还是哪个找到的代码换成GLSL ES 300版本后报错的原因。
+- 舍弃了gl_FragColor和gl_FragData内置属性，变成我们需要自己使用out关键字定义的属性，例如out vec4 fragColor，这就是为什么你从网还是哪个找到的代码换成GLSL ES 300版本后报错的原因。不过保留了gl_Position
 
 - GL_OES_EGL_image_external被废弃
 
@@ -275,6 +275,24 @@ vec2 vect = vec2(0.5, 0.7);
 vec4 result = vec4(vect, 0.0, 0.0);
 ```
 
+#### vec4表示矩形
+
+通常，一个矩形可以用其左上角位置（x, y），宽度（width），高度（height）来定义。我们可以将这些值存储在一个 vec4 中，如下：
+
+```glsl
+vec4 rect = vec4(x, y, width, height);
+```
+
+这里的 rect 向量表示:    
+
+- rect.x 是矩形的左上角的 x 坐标。
+- rect.y 是矩形的左上角的 y 坐标。
+- rect.z 是矩形的宽度。
+- rect.w 是矩形的高度。
+
+
+
+
 - 矩阵
 
 在GLSL中矩阵拥有2 * 2、3 * 3、4 * 4三种类型的矩阵，分别用mat2、mat3、mat4表示。         
@@ -284,6 +302,19 @@ vec4 result = vec4(vect, 0.0, 0.0);
 
 矩阵可以通过(i, j)进行索引，i是行，j是列，这就是上面的矩阵叫做2×3矩阵的原因（3列2行，也叫做矩阵的维度(Dimension)）。这与你在索引2D图像时的(x, y)相反，获取4的索引是(2, 1)（第二行，第一列）（译注：如果是图像索引应该是(1, 2)，先算列，再算行）
 
+矩阵的构造方法则更加灵活，有以下规则:      
+
+- 如果对矩阵构造器只提供了一个标量参数，该值会作为矩阵的对角线上的值。例如 mat4(1.0) 可以构造一个 4 × 4 的单位矩阵
+- 矩阵可以通过多个向量作为参数来构造，例如一个 mat2 可以通过两个 vec2 来构造
+- 矩阵可以通过多个标量作为参数来构造，矩阵中每个值对应一个标量，按照从左到右的顺序
+
+```glsl
+mat3 myMat3 = mat3(1.0, 0.0, 0.0,  // 第一列
+                   0.0, 1.0, 0.0,  // 第二列
+                   0.0, 1.0, 1.0); // 第三列
+```
+
+
 - 采样器
 
   采样器是专门用来对纹理进行采样工作的，在GLSL中一般来说，一个采样器变量表示一副或者一套纹理贴图。所谓的纹理贴图可以理解为我们看到的物体上的皮肤。

From 3012d7c8d202ccd750dae9bc98984d1743186ac5 Mon Sep 17 00:00:00 2001
From: xuchuanren <charon.chui@gmail.com>
Date: Tue, 28 May 2024 12:19:35 +0800
Subject: [PATCH 187/213] update OpenGL

---
 ...45\231\250\350\257\255\350\250\200GLSL.md" | 42 +++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md" "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
index cac05def..8dbd031b 100644
--- "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
+++ "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
@@ -1,5 +1,16 @@
 ## 7.OpenGL ES着色器语言GLSL
 
+### 齐次坐标(Homogeneous coordinates)
+
+三维顶点视为三元组(x,y,z)。现在引入一个新的分量w，得到向量(x,y,z,w)。请先记住以下两点：
+
+若w==1，则向量(x, y, z, 1)为空间中的点。
+若w==0，则向量(x, y, z, 0)为方向。
+
+齐次坐标使得我们可以用同一个公式对点和方向作运算。
+
+
+
 着色器是使用一种叫GLSL的类C语言写成的。GLSL是为图形计算量身定制的，它包含一些针对向量和矩阵操作的有用特性。
 
 着色器的开头总是要声明版本，接着是输入和输出变量、uniform和main函数。       
@@ -315,6 +326,37 @@ mat3 myMat3 = mat3(1.0, 0.0, 0.0,  // 第一列
 ```
 
 
+三维图形学中我们只用到4x4矩阵，它能对顶点(x,y,z,w)作变换。这一变换是用矩阵左乘顶点来实现的：
+
+矩阵x顶点（记住顺序！！矩阵左乘顶点，顶点用列向量表示）= 变换后的顶点
+
+![image](https://github.com/CharonChui/Pictures/blob/master/MatrixXVect.gif?raw=true)
+
+这看上去复杂，实则不然。左手指着a，右手指着x，得到ax。 左手移向右边一个数b，右手移向下一个数y，得到by。依次类推，得到cz、dw。最后求和ax + by + cz + dw，就得到了新的x！每一行都这么算下去，就得到了新的(x, y, z, w)向量。
+
+
+这种重复无聊的计算就让计算机代劳吧。
+
+用C++，GLM表示：
+```c++
+glm::mat4 myMatrix;
+glm::vec4 myVector;
+// fill myMatrix and myVector somehow
+glm::vec4 transformedVector = myMatrix * myVector; // Again, in this order ! this is important.
+```
+
+用GLSL表示:      
+
+```glsl
+mat4 myMatrix;
+vec4 myVector;
+// fill myMatrix and myVector somehow
+vec4 transformedVector = myMatrix * myVector; // Yeah, it's pretty much the same than GLM
+```
+
+
+
+
 - 采样器
 
   采样器是专门用来对纹理进行采样工作的，在GLSL中一般来说，一个采样器变量表示一副或者一套纹理贴图。所谓的纹理贴图可以理解为我们看到的物体上的皮肤。

From 77a3f3b3f2571fbb50ec361d95a1dd37e31adf51 Mon Sep 17 00:00:00 2001
From: xuchuanren <charon.chui@gmail.com>
Date: Thu, 6 Jun 2024 16:36:05 +0800
Subject: [PATCH 188/213] update OperatingSystem

---
 OperatingSystem/{5.I:O.md => 5.IO.md} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename OperatingSystem/{5.I:O.md => 5.IO.md} (100%)

diff --git a/OperatingSystem/5.I:O.md b/OperatingSystem/5.IO.md
similarity index 100%
rename from OperatingSystem/5.I:O.md
rename to OperatingSystem/5.IO.md

From f29e3a6f3a2c287fdac48a462082a7f179f4784f Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 6 Jun 2024 16:51:08 +0800
Subject: [PATCH 189/213] update OpenGL part

---
 .../OpenGL/1.OpenGL\347\256\200\344\273\213.md"           | 6 +++++-
 ...30\345\210\266\344\270\211\350\247\222\345\275\242.md" | 2 ++
 ...51\345\275\242\345\217\212\345\234\206\345\275\242.md" | 2 ++
 ...50\211\262\345\231\250\350\257\255\350\250\200GLSL.md" | 8 ++++++++
 4 files changed, 17 insertions(+), 1 deletion(-)

diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
index 9b8ba320..a347c9e6 100644
--- "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -179,7 +179,8 @@ OpenGL ES 3.0实现了具有可编程着色功能的图形管线，有两个规
 
 
 
-### 立即渲染模式(Immediate mode) && 核心模式(Core-profile)
+### 立即渲染模式(Immediate mode) && 核心模式(Core-profile)       
+
 早期的OpenGL使用立即渲染模式（Immediate mode，也就是固定渲染管线），这个模式下绘制图形很方便。OpenGL的大多数功能都被库隐藏起来，开发者很少有控制OpenGL如何进行计算的自由。而开发者迫切希望能有更多的灵活性。随着时间推移，规范越来越灵活，开发者对绘图细节有了更多的掌控。立即渲染模式确实容易使用和理解，但是效率太低。因此从OpenGL3.2开始，规范文档开始废弃立即渲染模式，并鼓励开发者在OpenGL的核心模式(Core-profile)下进行开发，这个分支的规范完全移除了旧的特性。
 
 当使用OpenGL的核心模式时，OpenGL迫使我们使用现代的函数。当我们试图使用一个已废弃的函数时，OpenGL会抛出一个错误并终止绘图。现代函数的优势是更高的灵活性和效率，然而也更难于学习。立即渲染模式从OpenGL实际运作中抽象掉了很多细节，因此它在易于学习的同时，也很难让人去把握OpenGL具体是如何运作的。现代函数要求使用者真正理解OpenGL和图形编程，它有一些难度，然而提供了更多的灵活性，更高的效率，更重要的是可以更深入的理解图形编程。
@@ -467,6 +468,9 @@ OpenGL中最基础且唯一的多边形就是三角形，所有更复杂的图
 
 **在现代OpenGL中，我们必须定义至少一个顶点着色器和一个片段着色器（因为GPU中没有默认的顶点/片段着色器）。**  
 
+
+光栅化后产生了多少个片元，就会插值计算出多少套in变量。同时，渲染管线就会调用多少次片元着色器。可以看出，一般情况下对一个3D物体的渲染中，片元着色器执行的次数会大大超过顶点着色器。          因此，GPU硬件中配置的片元着色器硬件数量往往多于顶点着色器硬件数量，通过这些硬件单元的并行执行，提高渲染速度。
+
 整个处理过程又分为以下几个部分:     
 
 - 逐片段操作
diff --git "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md" "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"
index c1779157..1fb4a6e7 100644
--- "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
@@ -55,6 +55,8 @@ float vertices[] = {
     你后面会看到为什么我们会需要这个位置值。
     
 
+layout限定符是从OpenGL ES 3.0开始出现的，其主要用于设置变量的存储索引（即引用）值.    
+
 ##### 向量(Vector)
 
 在图形编程中我们经常会使用向量这个数学概念，因为它简明地表达了任意空间中的位置和方向，并且它有非常有用的数学属性。      
diff --git "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md" "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"
index 49d52826..ff975060 100644
--- "a/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/6.OpenGL ES\347\273\230\345\210\266\347\237\251\345\275\242\345\217\212\345\234\206\345\275\242.md"	
@@ -143,6 +143,8 @@ public abstract class BaseGLSurfaceViewRenderer implements GLSurfaceView.Rendere
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_es_gl_triangle.jpg)
 
 
+OpenGL ES中仅允许采用三角形来搭建物体。其实这从构造能力上来说并没有区别，因为任何多边形都可以拆分为多个三角形。OpenGL ES中之所以仅支持三角形而不支持任意多边形是出于性能的考虑，就目前移动嵌入式设备的硬件性能情况来看，这是必然的选择了。
+
 
 ### 顶点法和索引法
 
diff --git "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md" "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
index 8dbd031b..7d5b2fb6 100644
--- "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
+++ "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
@@ -129,6 +129,14 @@ void main()
 由于我们在顶点着色器中将颜色设置为深红色，最终的片段也是深红色的。
 
 
+
+
+顶点着色器中用in限定符修饰的变量其值实质是由宿主程序（本书中为Java、C++）批量传入渲染管线的，管线进行基本处理后再传递给顶点着色器。       数据中有多少个顶点，管线就调用多少次顶点着色器，每次将一个顶点的各种属性数据传递给顶点着色器中对应的in变量。因此，顶点着色器每次执行将完成对一个顶点各项属性数据的处理。
+
+
+顶点着色器每顶点执行一次，而片元着色器每片元执行一次，片元着色器的执行次数明显大于顶点着色器的执行次数。因此在开发中，应尽量减少片元着色器的运算量，可以将一些复杂运算尽量放在顶点着色器中执行。
+
+
 ####  精度限定符
 
 精度限定符使着色器创作者可以指定着色器变量的计算精度。变量可以声明为低、中或者高精度。这些限定符用于提示编译器允许在较低的范围和精度上执行变量计算。在较低的精度上，有些OpenGL ES实现在运行着色器时可能更快，或者电源效率更高。

From b2ad165cbfa21840b4a3755fbed3acb6ffe14216 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 12 Jun 2024 11:51:20 +0800
Subject: [PATCH 190/213] update OpenGL part

---
 ...ES\347\261\273\345\217\212Matrix\347\261\273.md" | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git "a/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md" "b/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
index 7be018c0..103439cb 100644
--- "a/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
+++ "b/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
@@ -146,6 +146,11 @@ Matrix就是专门设计出来帮助我们简化矩阵和向量运算操作的
 利用这点，我们构建一个的矩阵，与图形所有的顶点坐标坐标相乘，得到新的顶点坐标集合，当这个矩阵构造恰当的话，新得到的顶点坐标集合形成的图形相对原图形就会出现平移、旋转、缩放或拉伸、抑或扭曲的效果。    
 Matrix是专门为处理4*4矩阵和4元素向量设计的，其中的方法都是static的，不需要初始化Matrix实例。
 
+
+
+OpenGL ES中使用的是列向量。列向量和矩阵相乘实现变换时，只能再列向量前面乘以矩阵。    
+而行向量则反之，否则乘法没有意义。   
+
 - multiplyMM
 
   两个4x4矩阵相乘，并将结果存储到第三个4x4矩阵中。
@@ -253,6 +258,14 @@ OpenGL有一个固定在原点(0,0,0)并朝向z轴负方向的相机，如下图
 
 
 
+### 旋转
+
+OpenGL ES中，旋转角度的正负可以用右手螺旋定则来确定。
+所谓右手螺旋定则是指：右手握住旋转轴，使大姆指指向旋转轴的正方向，4指环绕的方向即为旋转的正方向，也就是旋转角度为正值。
+
+![](https://raw.githubusercontent.com/CharonChui/Pictures/master/opengl_rotate_angle.png)
+
+
 ---
 
 - [上一篇: 7.OpenGL ES着色器语言GLSL](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/7.OpenGL%20ES%E7%9D%80%E8%89%B2%E5%99%A8%E8%AF%AD%E8%A8%80GLSL.md)  

From 99dba190379050fa40eacda9578bf438b94e2417 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Tue, 9 Jul 2024 21:52:24 +0800
Subject: [PATCH 191/213] Add Leetcode part

---
 .../python3\345\205\245\351\227\250.md"       |  19 +-
 ...44\346\225\260\344\271\213\345\222\214.md" | 173 +++++++++++++++
 ...44\346\225\260\347\233\270\345\212\240.md" | 210 ++++++++++++++++++
 ...00\351\225\277\345\255\220\344\270\262.md" | 190 ++++++++++++++++
 ...05\350\201\224\345\207\275\346\225\260.md" |  11 +
 5 files changed, 593 insertions(+), 10 deletions(-)
 create mode 100644 "JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/1. LeetCode_\344\270\244\346\225\260\344\271\213\345\222\214.md"
 create mode 100644 "JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/2. LeetCode_\344\270\244\346\225\260\347\233\270\345\212\240.md"
 create mode 100644 "JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/3. LeetCode_\346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262.md"

diff --git "a/JavaKnowledge/python3\345\205\245\351\227\250.md" "b/JavaKnowledge/python3\345\205\245\351\227\250.md"
index b3d4ae5f..985895a7 100644
--- "a/JavaKnowledge/python3\345\205\245\351\227\250.md"
+++ "b/JavaKnowledge/python3\345\205\245\351\227\250.md"
@@ -9,8 +9,6 @@ print(message)
 
 ## 字符串
 
-
-
 字符串就是一系列字符。在Python中，用引号括起来的都是字符串，其中的引号可以是单引号，也可以是双引号。例如:     
 ```python
 message = 'Hello World'
@@ -20,11 +18,13 @@ print(message)
 ```
 
 ### 大小写
+
 修改单词中的大小写:     
 
-title()方法是以首字母大写的方式显示每个单词，即将每个单词的首字母都改为大写。   
-upper()方法将字符串改为全部大写。
-lower()方法将字符串改为全部小写。   
+- title()方法是以首字母大写的方式显示每个单词，即将每个单词的首字母都改为大写。   
+- upper()方法将字符串改为全部大写。
+- lower()方法将字符串改为全部小写。   
+
 ```python
 message = 'hello world'
 print(message.title())
@@ -46,7 +46,7 @@ print(full_name)
 
 ### 空格
 
-rstrip(): 去除字符串末尾空白。注意去除只是暂时的，等你再次访问该变量是，你会发现这个字符串仍然包含末尾空白。      
+rstrip(): 去除字符串末尾空白。注意去除只是暂时的，等你再次访问该变量时，你会发现这个字符串仍然包含末尾空白。      
 要永久删除这个字符串中的空白，必须将删除的结果存回到变量中:   
 
 
@@ -55,8 +55,8 @@ print(first_name)
 first_name = first_name.rstrip()
 print(first_name)
 
-lstrip(): 去除字符串开头空白       
-strip(): 同时去除字符串两端的空白      
+- lstrip(): 去除字符串开头空白       
+- strip(): 同时去除字符串两端的空白      
 
 
 ## 整数
@@ -179,7 +179,6 @@ print(size)
 - 没有缩进的是for循环之外的
 
 
-- 
 ```python
 bicycles = ['trek', 'cannondale', 'redline', 'specialized']
 for bcy in bicycles:
@@ -369,7 +368,7 @@ for language in set(favorite_languages.values()):❶
 
 函数input()让程序暂停运行，等待用户输入一些文本。     
 
-获取用户输入后，Python将其村村在一个变量中，以方便你使用。   
+获取用户输入后，Python将其存在一个变量中，以方便你使用。   
 ```python3
 age = input("How old are you?")
 print(age)
diff --git "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/1. LeetCode_\344\270\244\346\225\260\344\271\213\345\222\214.md" "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/1. LeetCode_\344\270\244\346\225\260\344\271\213\345\222\214.md"
new file mode 100644
index 00000000..72102238
--- /dev/null
+++ "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/1. LeetCode_\344\270\244\346\225\260\344\271\213\345\222\214.md"	
@@ -0,0 +1,173 @@
+1. LeetCode_两数之和
+===
+
+给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。
+
+你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
+
+你可以按任意顺序返回答案。
+
+ 
+
+示例 1：
+
+输入：nums = [2,7,11,15], target = 9
+输出：[0,1]
+解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
+示例 2：
+
+输入：nums = [3,2,4], target = 6
+输出：[1,2]
+示例 3：
+
+输入：nums = [3,3], target = 6
+输出：[0,1]
+
+
+
+提示：
+
+2 <= nums.length <= 104
+-109 <= nums[i] <= 109
+-109 <= target <= 109
+只会存在一个有效答案
+ 
+
+进阶：你可以想出一个时间复杂度小于 O(n2) 的算法吗？
+
+
+### 方法一：暴力枚举
+
+
+最简单的方法就是对数组中的每一个数x，都去遍历找后面是否存在target - x的值是否存在。
+
+```java
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        int size = nums.length;
+
+        for (int i = 0; i < size; i++) {
+            for (int j = i + 1; j < size; j++) {
+                if (nums[i] + nums[j] == target) {
+                    return new int[]{i, j};
+                }
+            }
+        }
+        return new int[0];
+    }
+}
+```
+
+```c++
+#include <vector>
+using namespace std;
+
+
+class Solution {
+public:
+    vector<int> twoSum(vector<int> &nums, int target) {
+        int size = nums.size();
+
+        for (int i = 0; i < size; i++) {
+            for (int j = i + 1; j < size; j++) {
+                if (nums[i] + nums[j] == target) {
+                    return {i, j};
+                }
+            }
+        }
+        return {};
+    }
+};
+```
+
+复杂度分析:    
+
+- 时间复杂度：O(N²)，其中N是数组中的元素数量。最坏情况下数组中任意两个数都要被匹配一次。
+
+- 空间复杂度：O(1)。
+
+
+### 方法二： 哈希表
+
+注意到方法一的时间复杂度较高的原因是寻找 target - x 的时间复杂度过高。
+
+因此，我们需要一种更优秀的方法，能够快速寻找数组中是否存在目标元素。如果存在，我们需要找出它的索引。
+
+使用哈希表，可以将寻找 target - x 的时间复杂度降低到从 O(N) 降低到 O(1)。
+
+
+---
+
+如果想要快速确定某个元素是否在nums数组中，并且可以快速的获取所在下表index。
+我们的第一反应就是将数组维护成一个Map结构:     
+
+- key: 存储数组里的值
+- value: 存储数组的下标index
+
+这样我们只需要通过target - nums[i]的值去Map中查找即可。
+但是这样存在一个问题，就是你需要先把数组中的值都放到Map中，需要多一步循环。
+
+
+
+
+--- 
+
+其实我们可以先创建一个Map，在Map的初始化过程中什么元素都不放。    
+
+对于每一个 x，我们首先查询哈希表中是否存在 target - x，如果已存在就返回，如果不存在那再将 x 插入到哈希表中，即可保证不会让 x 和自己匹配。
+
+这样只需要一次循环就可以了，而且Map数组不用提前初始化，在性能和内存占用率都比较低。  
+
+
+```java
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        Map<Integer, Integer> hashtable = new HashMap<Integer, Integer>();
+        for (int i = 0; i < nums.length; ++i) {
+            if (hashtable.containsKey(target - nums[i])) {
+                return new int[]{hashtable.get(target - nums[i]), i};
+            }
+            hashtable.put(nums[i], i);
+        }
+        return new int[0];
+    }
+}
+
+```
+
+```c++ 
+#include <unordered_map>
+#include <vector>
+
+using namespace std;
+
+class Solution {
+public:
+    vector<int> twoSum(vector<int> &nums, int target) {
+        unordered_map<int, int> map;
+        for (int i = 0; i < nums.size(); i ++) {
+            auto it = map.find(target - nums[i]);
+            if (it != map.end()) {
+                return {i, it->second};
+            }
+
+            map[nums[i]] = i;
+        }
+        return {};
+    }
+};
+```
+
+
+复杂度分析:    
+
+- 时间复杂度：O(N)，其中 N 是数组中的元素数量。对于每一个元素 x，我们可以 O(1) 地寻找 target - x。
+
+- 空间复杂度：O(N)，其中 N 是数组中的元素数量。主要为哈希表的开销。
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/2. LeetCode_\344\270\244\346\225\260\347\233\270\345\212\240.md" "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/2. LeetCode_\344\270\244\346\225\260\347\233\270\345\212\240.md"
new file mode 100644
index 00000000..789a2a9f
--- /dev/null
+++ "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/2. LeetCode_\344\270\244\346\225\260\347\233\270\345\212\240.md"	
@@ -0,0 +1,210 @@
+2. LeetCode_两数相加
+===
+
+给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
+
+请你将两个数相加，并以相同形式返回一个表示和的链表。
+
+你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
+
+
+输入：l1 = [2,4,3], l2 = [5,6,4]
+输出：[7,0,8]
+解释：342 + 465 = 807.
+
+
+
+输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
+输出：[8,9,9,9,0,0,0,1]
+
+
+提示：
+
+- 每个链表中的节点数在范围 [1, 100] 内
+- 0 <= Node.val <= 9
+- 题目数据保证列表表示的数字不含前导零
+
+
+
+想法：  
+
+我的想法是先把两个链表转成两个整数相加，然后把这个整数转成字符串再次生成链表。      
+
+这种方案是不可行的，因为链表的长度可能会很长，整数是操作不了的，例如:  
+
+
+方法： 
+
+由于输入的两个链表都是逆序存储数字的位数的，因此两个链表中同一位置的数字可以直接相加。      
+
+我们同时遍历两个链表，逐位计算它们的和，并与当前位置的进位值相加。具体而言，如果当前两个链表处相应位置的数字为 n1,n2，进位值为 carry，则它们的和为 n1+n2+carry；      
+其中，答案链表处相应位置的数字为 (n1+n2+carry)mod10，而新的进位值为 [(n1+n2+carry) / 10]
+
+如果两个链表的长度不同，则可以认为长度短的链表的后面有若干个 0 。
+
+此外，如果链表遍历结束后，有 carry>0，还需要在答案链表的后面附加一个节点，节点的值为 carry。
+
+
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_2_twoaddsum.png?raw=true)    
+
+
+- 将链表反过来看，头结点在右侧
+- 横线上的数字为进位
+- 2 + 5 + 0(第一个进位默认为0) = 7 
+
+    - 7 % 10得到新节点中的元素为7
+    - 7 / 10得到下一个进位为0
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_2_twoaddsum_2.png?raw=true)    
+    
+
+```java
+class ListNode {
+    int val;
+    ListNode next;
+    
+    ListNode() {
+        this.val = 0;
+        this.next = null;
+    }
+
+    ListNode(int val) {
+        this.val = val;
+        this.next = null;
+    }
+
+    ListNode(int val, ListNode next) {
+        this.val = val;
+        this.next = next;
+    }
+}
+
+class Solution {
+    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+         ListNode head = null;
+         ListNode tail = null;
+
+         int carry = 0;
+
+         while(l1 != null || l2 != null) {
+            int n1 = l1 != null ? l1.val : 0;
+            int n2 = l2 != null ? l2.val : 0;
+
+            int sum = n1 + n2 + carry;
+
+            if (head == null) {
+                head = tail = new ListNode(sum % 10);
+            } else {
+                tail.next = new ListNode(sum % 10);
+                tail = tail.next;
+            }
+
+            carry = sum / 10;
+
+            if (l1 != null) {
+                l1 = l1.next;
+            }
+
+            if (l2 != null) {
+                l2 = l2.next;
+            }
+         }
+
+         if (carry > 0) {
+            tail.next = new ListNode(carry);
+         }
+         return head;
+     }
+}
+```
+
+
+
+复杂度分析:    
+
+- 时间复杂度：O(max(m,n))，其中 m 和 n 分别为两个链表的长度。我们要遍历两个链表的全部位置，而处理每个位置只需要 O(1) 的时间。
+
+- 空间复杂度：O(1)。注意返回值不计入空间复杂度。
+
+
+### 改进： 递归
+
+```java
+class Solution {
+    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+        return add(l1, l2, 0);
+    }
+}
+
+    public ListNode add(ListNode l1, ListNode l2, int carry) {
+        if (l1 == null && l2 == null && carry == 0) {
+            return null;
+        }
+        int val = carry;
+        if (l1 != null) {
+            val += l1.val;
+            l1 = l1.next;
+        }
+        if (l2 != null) {
+            val += l2.val;
+            l2 = l2.next;
+        }
+        ListNode node = new ListNode(val % 10);
+        node.next = add(l1, l2, val / 10);
+        return node;
+    }
+}
+```
+
+使用C++实现:   
+
+```c++
+struct ListNode {
+    int val;
+    ListNode *next;
+
+    ListNode() : val(0), next(nullptr) {
+    }
+
+    ListNode(int x) : val(x), next(nullptr) {
+    }
+
+    ListNode(int x, ListNode *next) : val(x), next(next) {
+    }
+};
+
+class Solution {
+public:
+    ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {
+        int carry = 0;
+
+        ListNode *answer = new ListNode();
+        ListNode *head = answer;
+
+        while (l1 || l2) {
+            int number = (l1 ? l1->val : 0) + (l2 ? l2->val : 0) + carry;
+            carry = number / 10;
+            number %= 10;
+            head->next = new ListNode(number);
+            head = head->next;
+
+            l1 ? l1 = l1->next : 0;
+            l2 ? l2 = l2->next : 0;
+        }
+        if (carry) {
+            head->next = new ListNode(carry);
+        }
+        return answer->next;
+    }
+};
+```
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/3. LeetCode_\346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262.md" "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/3. LeetCode_\346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262.md"
new file mode 100644
index 00000000..748e420e
--- /dev/null
+++ "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/3. LeetCode_\346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262.md"	
@@ -0,0 +1,190 @@
+3. LeetCode_无重复字符的最长子串
+===
+
+给定一个字符串s，请你找出其中不含有重复字符的 最长子串 的长度。
+
+
+示例 1:
+
+输入: s = "abcabcbb"
+输出: 3 
+解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
+示例 2:
+
+输入: s = "bbbbb"
+输出: 1
+解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
+示例 3:
+
+输入: s = "pwwkew"
+输出: 3
+解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
+     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
+ 
+
+提示：
+
+0 <= s.length <= 5 * 104
+s 由英文字母、数字、符号和空格组成
+
+
+
+方式一:    
+
+暴力破解，通过多个循环以穷举的方式 找出答案。简单且易想到的方案，包括之前我们刷的两道算法题也可以使用暴力破解来解决，缺点就是虽然简单，但是效率非常低，并非是最优方案。
+
+
+具体思路:   
+
+- 将字符串中每个字符作为一个循环，和子串的组合进行比较，从而获取最长字串长度。
+
+如字符串abc，则第一轮比较为: 字符a和子串a、ab、abc比较，第二轮则为字符b和子串b、bc比较，以此类推，最后获取不重复的子串长度。
+
+```java
+public class Solution {
+    public static int lengthOfLongestSubstring(String s) {
+        int maxLength = 0;
+
+        for (int i = 0; i < s.length(); i++) {
+            for (int j = i + 1; j < s.length(); j++) {
+                if (!judgeCharacterExist(i, j, s)) {
+                    maxLength = Math.max(maxLength, j - i);
+                }
+            }
+        }
+        return maxLength;
+    }
+
+
+    public static boolean judgeCharacterExist(int start, int end, String param) {
+        HashSet<Character> hashSet = new HashSet<>();
+        for (int i = start; i < end; i++) {
+            if (hashSet.contains(param.charAt(i))) {
+                return true;
+            }
+            hashSet.add(param.charAt(i));
+        }
+
+        return false;
+    }
+}
+```
+
+该方法效率低，时间福再度为O(n³)。
+
+
+方法二： 滑动窗口法
+
+滑动窗口： 是数组和字符串中一个抽象的概念，可分为滑动和窗口两个概念理解。   
+
+窗口：即表示一个范围，通常是字符串和数组从开始到结束两个索引范围中间包含的一系列元素集合。如字符串abcd，如果开始索引和结束索引分别为0、2的话，这个窗口包含的字符则为： abc。
+
+滑动：它表示窗口的开始和结束索引是可以往某个方向移动的。        
+如上面的例子开始索引和结束索引分别为0、2的话，当开始索引和结束索引都往右移动一位时，它们的索引值分别为1、3，这个窗口包含的字符为：bcd。
+
+示例：  
+
+- abcdef
+- 字符串开始索引： 0
+- 字符串结束索引： 5
+- 开始和结束索引范围包含的字符(abcdef)就可以看作是一个窗口
+
+思路：   
+
+- 使用一个HashSet来实现滑动窗口，用来检查重复字符
+- 维护开始和结束两个索引，默认都是从0开始
+- 随着循环 向右移动结束索引 
+
+    - 遇到不是重复的字符则放入窗口里
+    - 遇到重复字符则向右移动开始索引
+
+最终得到结果。      
+
+```java
+public class Solution {
+    public static Integer lengthOfLongestSubstring(String s) {
+        int maxLength = 0;
+        int leftPoint = 0;
+        int rightPoint = 0;
+        
+        Set<Character> set = new HashSet<>();
+        
+        while(leftPoint < s.length() && rightPoint < s.length()) {
+            if (!set.contains(s.charAt(rightPoint))) {
+                set.add(s.charAt(rightPoint++));
+                maxLength = Math.max(maxLength, rightPoint - leftPoint);
+            } else {
+                set.remove(s.charAt(leftPoint++));
+            }
+        }
+        return maxLength;
+    }
+}
+```
+
+滑动窗口算法的时间复杂度为O(n)，相比于暴力破解，它的效率大大提高了。
+
+方式三:     
+
+虽然方式使用了滑动窗口时间复杂度只有O(n)，但是如果存在重复字符还需要移动开始索引，因此我们可以考虑借助之前其他算法谈到的“空间换时间”的想法，通过借助HashMap建立字符和索引映射，避免手动移动索引。
+
+
+```java
+public class Solution {
+    public static Integer lengthOfLongestSubstring(String s) {
+        char[] charArry = s.toCharArray();
+
+        HashMap<Character, Integer> keyMap = new HashMap<>();
+        int maxLength = 0;
+
+        int leftPoint = 0;
+        for (int i = 0; i < charArry.length; i++) {
+            if (keyMap.containsKey(charArry[i])) {
+                // 存在重复数据则获取索引值最大的
+                leftPoint = Math.max(leftPoint, keyMap.get(charArry[i]));
+            }
+            // 值重复就覆盖，不重复就添加
+            keyMap.put(charArry[i], i + 1);
+            maxLength = Math.max(maxLength, i + 1 - leftPoint);
+        }
+        return maxLength;
+    }
+}
+```
+
+时间复杂度为O(n)，虽然和上一种方案的时间复杂度是一样的，但是效率还是有一定的提高(思考问题时要思考是否还有其他有优质的方案，培养发散思维)。
+
+
+方式四: 
+
+
+上面题目分析的时候就提到了要注意题目中提到的：【字符串英文字母、数字、符号和空格组成】，这些字符是可以使用ASCII表示(如字符a的ASCII值为97，想具体了解的可以百度下)，那么我们就可以建立字符与ASCII的映射关系，从而实现重复字符的排除。
+
+
+
+```java
+public class Solution {
+    public static Integer lengthOfLongestSubstring(String s) {
+        int[] index = new int[128];
+        int maxLength = 0;
+        int length = s.length();
+        int i = 0;
+        for (int j = 0; j < length; j++) {
+            i = Math.max(index[s.charAt(j)], i);
+            index[s.charAt(j)] = j + 1;
+            maxLength = Math.max(maxLength, j + 1 - i);
+        }
+        return maxLength;
+    }
+}
+```
+
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md" "b/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
index 166994ce..a3f2b9c9 100644
--- "a/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
+++ "b/KotlinCourse/2.Kotlin_\351\253\230\351\230\266\345\207\275\346\225\260&Lambda&\345\206\205\350\201\224\345\207\275\346\225\260.md"
@@ -1,6 +1,17 @@
 2.Kotlin_高阶函数&Lambda&内联函数
 ===
 
+## 函数还是属性
+
+在某些情况下，不带参数的函数可与只读属性互换。 虽然语义相似，但是在某种程度上有一些风格上的约定。
+
+底层算法优先使用属性而不是函数：
+
+- 不会抛异常
+- 计算开销小（或者在首次运行时缓存）
+- 如果对象状态没有改变，那么多次调用都会返回相同结果
+
+
 ## 高阶函数
 
 

From da95ba3cb9deaea08ca7daf28f86a029604fd1aa Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Sat, 14 Sep 2024 17:38:48 +0800
Subject: [PATCH 192/213] update

---
 ...60\346\215\256\347\273\223\346\236\204.md" |  31 +++
 .../\347\256\227\346\263\225.md"              |  36 +++-
 Jetpack/ui/Jetpack Compose_Modifier.md        | 180 ++++++++++++++++++
 ...etpack Compose\347\256\200\344\273\213.md" | 104 +++++++++-
 MobileAIModel/TensorFlow Lite                 |  33 ++++
 5 files changed, 378 insertions(+), 6 deletions(-)
 create mode 100644 Jetpack/ui/Jetpack Compose_Modifier.md
 create mode 100644 MobileAIModel/TensorFlow Lite

diff --git "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\346\225\260\346\215\256\347\273\223\346\236\204.md" "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\346\225\260\346\215\256\347\273\223\346\236\204.md"
index f8e8413f..1a75ec60 100644
--- "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\346\225\260\346\215\256\347\273\223\346\236\204.md"
+++ "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\346\225\260\346\215\256\347\273\223\346\236\204.md"
@@ -10,8 +10,24 @@
 
 按照视点的不同，我们把数据结构分为逻辑结构和物理结构。
 
+数据结构（data structure）是组织和存储数据的方式，涵盖数据内容、数据之间关系和数据操作方法，它具有以下设计目标。
+
+- 空间占用尽量少，以节省计算机内存。
+- 数据操作尽可能快速，涵盖数据访问、添加、删除、更新等。
+- 提供简洁的数据表示和逻辑信息，以便算法高效运行。
+- 数据结构设计是一个充满权衡的过程。如果想在某方面取得提升，往往需要在另一方面作出妥协。
+
+下面举两个例子:   
+
+- 链表相较于数组，在数据添加和删除操作上更加便捷，但牺牲了数据访问速度。
+- 图相较于链表，提供了更丰富的逻辑信息，但需要占用更大的内存空间。
+
+
+
 #### 逻辑结构
+
 逻辑结构：是指数据对象中数据元素之间的相互关系。其实这也是我们今后最需要关注的问题。逻辑结构分为以下四种：
+
 - 集合结构
     集合结构：集合结构中的数据元素除了同属于一个集合外，它们之间没有其他关系。各个数据元素是“平等”的，它们的共同属性是"同属于一个集合"。
     数据结构中的集合关系就类似于数学中的集合
@@ -23,7 +39,9 @@
     图形结构：图形结构的数据元素是多对多的关系            
 
 #### 物理结构
+
 物理结构(也称为存储结构)：是指数据的逻辑结构在计算机中的存储形式。
+
 - 顺序存储结构
     顺序存储结构：是把数据元素存放在地址连续的存储单元里，其数据间的逻辑关系和物理关系是一致的
     这种存储结构其实很简单，说白了，就是排队占位。大家都按顺序排好，每个人占一小段空间，大家谁也别插谁的队。数组就是这
@@ -168,8 +186,21 @@ int[] arr = new int[10];
 #### 栈的应用-递归
 
 把一个直接调用自己或通过一系列的调用语句间接地调用自己的函数，称做递归函数。
+
 当然，写递归程序最怕的就是陷入永不结束的无穷递归中，所以，每个递归定义必须至少有一个条件，满足时递归不再进行，即不再引用自身而是返回值退出。
 
+递归（recursion）是一种算法策略，通过函数调用自身来解决问题。它主要包含两个阶段：  
+
+- 递：程序不断深入地调用自身，通常传入更小或更简化的参数，直到达到“终止条件”。
+- 归：触发“终止条件”后，程序从最深层的递归函数开始逐层返回，汇聚每一层的结果。
+
+而从实现的角度看，递归代码主要包含三个要素：   
+
+- 终止条件：用于决定什么时候由“递”转“归”。
+- 递归调用：对应“递”，函数调用自身，通常输入更小或更简化的参数。
+- 返回结果：对应“归”，将当前递归层级的结果返回至上一层。
+
+
 那么我们讲了这么多递归的内容，和栈有什么关系呢？这得从计算机系统的内部说起。前面我们已经看到递归是如何执行它的前行和退回阶段的。
 递归过程退回的顺序是它前行顺序的逆序。在退回过程中，可能要执行某些动作，包括恢复在前行过程中存储起来的某些数据。这种存储某些数据，
 并在后面又以存储的逆序恢复这些数据，以提供之后使用的需求，显然很符合栈这样的数据结构，因此，编译器使用栈实现递归就没什么好惊讶的了。
diff --git "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\347\256\227\346\263\225.md" "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\347\256\227\346\263\225.md"
index 3347d083..b33352bd 100644
--- "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\347\256\227\346\263\225.md"
+++ "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/\347\256\227\346\263\225.md"
@@ -1,7 +1,12 @@
 算法
 ===
 
-算法(Algorithm)是解决特定问题求解步骤的描述，在计算机中表现为指令的有限序列，并且每条指令表示一个或多个操作。
+
+算法（algorithm）是在有限时间内解决特定问题的一组指令或操作步骤，它具有以下特性:   
+
+- 问题是明确的，包含清晰的输入和输出定义。
+- 具有可行性，能够在有限步骤、时间和内存空间下完成。
+- 各步骤都有确定的含义，在相同的输入和运行条件下，输出始终相同。
 
 
 算法具有五个基本特性：
@@ -17,6 +22,21 @@
     算法的每一步都必须是可行的，也就是说，每一步都能够通过执行有限次数完成
 
 
+在算法设计中，我们先后追求以下两个层面的目标。
+
+- 找到问题解法：算法需要在规定的输入范围内可靠地求得问题的正确解。
+- 寻求最优解法：同一个问题可能存在多种解法，我们希望找到尽可能高效的算法。
+
+也就是说，在能够解决问题的前提下，算法效率已成为衡量算法优劣的主要评价指标，它包括以下两个维度:    
+
+- 时间效率：算法运行时间的长短。
+- 空间效率：算法占用内存空间的大小。
+
+简而言之，我们的目标是设计“既快又省”的数据结构与算法。而有效地评估算法效率至关重要，因为只有这样，我们才能将各种算法进行对比，进而指导算法设计与优化过程。
+
+
+
+
 
 ### 算法时间复杂度
 
@@ -291,7 +311,19 @@ public static int[] merge(int[] a, int[] b) {
     }
     return result;
 }
-````
+```
+
+
+数据结构与算法高度相关、紧密结合，具体表现在以下三个方面:     
+
+- 数据结构是算法的基石。数据结构为算法提供了结构化存储的数据，以及操作数据的方法。
+- 算法是数据结构发挥作用的舞台。数据结构本身仅存储数据信息，结合算法才能解决特定问题。
+- 算法通常可以基于不同的数据结构实现，但执行效率可能相差很大，选择合适的数据结构是关键。
+
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/algorithm_datasturcture.jpg?raw=true)
+
 
 
 ---
diff --git a/Jetpack/ui/Jetpack Compose_Modifier.md b/Jetpack/ui/Jetpack Compose_Modifier.md
new file mode 100644
index 00000000..fefee653
--- /dev/null
+++ b/Jetpack/ui/Jetpack Compose_Modifier.md	
@@ -0,0 +1,180 @@
+# Jetpack Compose_Modifier
+
+在传统开发中，使用XML文件来描述组件的样式，而Jetpack Compose设计了一个精妙的东西，它叫作Modifier。Modifier允许我们通过链式调用的写法来为组件应用一系列的样式设置，如边距、字体、位移等。在Compose中，每个基础的Composable组件都有一个modifier参数，通过传入自定义的Modifier来修改组件的样式。
+
+
+
+- Modifier.size
+
+设置被修饰组件的大小。
+
+- Modifier.background
+
+添加背景色，支持使用color设置纯色背景，也可以使用brush设置渐变色背景。     
+
+传统视图中View的background属性可以用来设置图片格式的背景，Compose的background修饰符只能设置颜色背景，图片背景需要使用Box布局配合Image组件实现。   
+
+- Modifier.fillMaxSize
+
+组件在高度或宽度上填满父空间，此时可以使用fillMaxXXX系列方法：  
+
+Box(Modifier.fillMaxSize().background(Color.Red))
+Box(Modifier.fillMaxWidth().height(60.dp))
+Box(Modifier.fillMaxHeight().width(60.dp))
+
+
+```kotlin
+setContent {
+    Image(
+        painter = painterResource(id = R.drawable.ic_launcher_background),
+        contentDescription = null,
+        modifier = Modifier
+            .size(width = 60.dp, height = 50.dp)
+            .background(
+                brush = Brush.verticalGradient(
+                    colors = listOf(
+                        Color.Red,
+                        Color.Yellow,
+                        Color.White
+                    )
+                )
+            )
+    )
+}
+```
+
+
+- Modifier.border & Modifier.padding
+
+border用来为组件添加边框。   
+边框可以指定颜色、粗细以及通过Shape指定形状，比如圆角矩形等。    
+
+padding用来为被修饰组件增加间隙，可以在border前后各插入一个padding用来为为组件增加对外和对内的间距，例如:   
+
+```kotlin
+@Preview
+@Composable
+fun BoxTest() {
+    Box(
+        modifier = Modifier
+            .padding(10.dp)
+            .border(2.dp, Color.Red, shape = RoundedCornerShape(2.dp))
+            .padding(20.dp)
+    ) {
+        Spacer(
+            modifier = Modifier
+                .size(10.dp, 10.dp)
+                .background(Color.Green)
+        )
+    }
+}
+```
+
+相对于传统布局有Margin和Padding之分，Compose中只有padding这一种修饰符，根据在调用链中的位置不同发挥不同的作用。     
+
+Modifier调用顺序会影响最终UI的呈现效果。    
+这是因为Modifier会由于调用顺序不同而产生不同的Modifier链，Compose会按照Modifier链来顺序完成页面测量布局和渲染。      
+
+
+## 作用域限定
+
+Compose充分发挥了Kotlin的语法特性，让某些Modifier修饰符只能在特定作用域中使用，有利于类型安全的调用它们。      
+
+所谓的作用域，在Kotlin中就是一个带有Receiver的代码块。     
+
+例如Box组件参数中的content就是一个Receiver类型为BoxScope的代码块，因此其子组件都处于BoxScope作用域中。    
+
+```kotlin
+inline fun Box(
+    modifier: Modifier = Modifier, 
+    contentAlignment: Alignment = Alignment.TopStart,
+    propagateMinConstraints: Boolean = false,
+    content: @Composable BoxScope.() -> Unit
+)    
+
+Box {
+    // 该代码块Receiver类型即为BoxScope
+}
+```
+
+
+- matchParentSize
+
+matchParentSize是只能在BoxScope中使用的作用域限定修饰符。     
+当使用matchParentSize设置尺寸时，可以保证当前组件的尺寸与父组件相同。     
+而父组件默认的是wrapContent，会根据子组件的尺寸确定自身的尺寸。   
+
+而如果使用fillMaxSize取代matchParentSize，那么该组件的尺寸会被设置为父组件所允许的最大尺寸，这样会导致铺满整个屏幕。 
+```kotlin
+@Composable 
+// 只把UserInfo区域设置背景
+fun MatchParentModifierDemo() {
+    Box {
+        Box(modifier = Modifier
+            .matchParentSize()
+            .background(Color.RED)
+        )
+        UserInfo()
+    }
+}
+
+
+// 使用fillMaxSize取代matchParentSize，那么该组件的尺寸会被设置为父组件所允许的最大尺寸，这样会导致整个背景铺满整个屏幕
+@Composable
+fun MatchParentModifierDemo() {
+    Box {
+        Box(modifier = Modifier
+            .fillMaxSize()
+            .background(Color.READ)
+        )
+        UserInfo()
+    }
+}
+```
+
+
+- weight
+
+在RowScope和ColumnScope中，可以使用专属的weight修饰符来设置尺寸。      
+
+与size修饰符不同的是，weight修饰符允许组件通过百分比设置尺寸，也就是允许组件可以自适应适配各种屏幕尺寸。    
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/Jetpack/ui/Jetpack Compose\347\256\200\344\273\213.md" "b/Jetpack/ui/Jetpack Compose\347\256\200\344\273\213.md"
index 150ccb9e..ada5182a 100644
--- "a/Jetpack/ui/Jetpack Compose\347\256\200\344\273\213.md"	
+++ "b/Jetpack/ui/Jetpack Compose\347\256\200\344\273\213.md"	
@@ -15,8 +15,104 @@ GogleAndroid团队的Anna-Chiara表示，他们对已经实现的一些API感到
 这就是为什么Jetpack Compose 让我们看到了曙光。
 
 
+### 精简代码
 
-作者：依然范特稀西
-链接：https://www.jianshu.com/p/19c4e10370ba
-来源：简书
-著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
\ No newline at end of file
+编写更少的代码会影响到所有开发阶段:作为代码撰写者，需要测试和调试的代码会更少，出现bug的可能性也更小。
+
+与使用Android View系统(按钮、列表或动画)相比，Compose可让您使用更少的代码实现更多的功能。      
+而且编写代码只需要采用Kotlin，而不必拆分成Kotlin和XML部分。
+
+### 直观易读
+
+Compose使用声明性API，这意味着您只需描述界面，Compose会负责完成其余工作。    
+
+
+### 加速开发
+
+Compose与您所有的现有代码兼容：您可以从View调用Compose代码，也可以从Compose调用View。    
+
+
+### 旧项目支持Compose
+
+以Android平台而言，Compose实际上都承载在ComposeView上，如果想要在旧项目中使用Compose开发，就需要在使用处添加一个ComposeView。   
+
+可以在XML中静态声明或在程序中动态构造出一个ComposeView实例，例如在activity_main.xml中添加ComposeView，如下所示:      
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.compose.ui.platform.ComposeView xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/root"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
+
+</androidx.compose.ui.platform.ComposeView>
+```
+
+```kotlin
+class MainActivity2 : AppCompatActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_main2)
+        findViewById<ComposeView>(R.id.root).setContent {
+            Text("Hello World")
+        }
+    }
+}
+```
+
+
+### 简单的可组合函数
+
+使用Compose，您可以通过定义一组接受数据而发出界面元素的可组合函数来构建界面。     
+下面是一个简单的示例，接受一个字符串并现实一个问号信息:    
+
+```kotlin
+@Composable
+fun Greeting(name: String) {
+    Text("Hello $name)
+}
+```
+
+- 此函数带有@Composable注释。所有可组合函数都必须带有此注释。此注释可告知Compose编译器:此函数旨在将数据转换为界面。     
+- 此函数可以在界面中显示文本。为此，它会调用Text()可组合函数，该函数实际上会创建文本界面元素。可组合函数通过调用其他可组合函数来发出界面层次结构。 
+
+
+
+### 在Composet中使用View组件
+
+不少功能性的传统视图控件在Compose中没有对应的Composable实现，例如SurfaceView、
+WebView、MapView等。     
+
+因此在Compose中可能会有使用传统View控件的需求。     
+Compose提供了名为AndroidView的Composable组件，允许在Composable中插入任意基于继承自View的传统试图控件。   
+
+```kotlin
+class MainActivity2 : AppCompatActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContent {
+            AndroidView(factory = {context ->
+                WebView(context).apply {
+                    settings.javaScriptEnabled = true
+                    webViewClient = WebViewClient()
+                    loadUrl("https://www.baidu.com")
+                }
+            }, modifier = Modifier.fillMaxSize())
+        }
+    }
+}
+```
+AndroidView中传入一个工厂的实现，工厂方法中可以获取Composable所在的Context，并基于其构建View视图控件。  
+
+### Modifier
+
+Modifier是一个装饰或者添加行为的有序的，不变的集合。     
+例如background、padding、宽高、焦点点击事件等。   
+例如给Text设置单行、给Button设置个中点击状态等行为。    
+其实就是所有控件的通用属性都在Modifier中。  
+
+
+在Compose中，每个组件都是一个带有@Composable注解的函数，被称为Composable。   
+Compose中已经预置了很多基础的Composable组件，他们都是基于Material Design规范设计，例如Button、TextField、TopAppBar等。   
+
+在布局方面，Compose提供了Column、Row、Box三种布局组件，类似于传统视图开发中的LinearLayout(Vertical)、LinearLayout(Horizontal)、RelativeLayout。   
diff --git a/MobileAIModel/TensorFlow Lite b/MobileAIModel/TensorFlow Lite
new file mode 100644
index 00000000..dc7054e3
--- /dev/null
+++ b/MobileAIModel/TensorFlow Lite	
@@ -0,0 +1,33 @@
+TensorFlow Lite
+---
+
+[TensorFlow Lite](https://tensorflow.google.cn/lite?hl=zh-cn) 是一个移动端库，可用于在移动设备、微控制器和其他边缘设备上部署模型。
+
+
+[TensorFlow Lite](https://tensorflow.google.cn/lite?hl=zh-cn) 是一组工具，可帮助开发者在移动设备、嵌入式设备和 loT 设备上运行模型，以便实现设备端机器学习。
+
+主要特性:  
+
+- 通过解决以下 5 项约束条件，针对设备端机器学习进行了优化：延时（数据无需往返服务器）、隐私（没有任何个人数据离开设备）、连接性（无需连接互联网）、大小（缩减了模型和二进制文件的大小）和功耗（高效推断，且无需网络连接）。
+- 支持多种平台，涵盖 Android 和 iOS 设备、嵌入式 Linux 和微控制器。
+- 支持多种语言，包括 Java、Swift、Objective-C、C++ 和 Python。
+高性能，支持硬件加速和模型优化。
+- 提供多种平台上的常见机器学习任务的端到端示例，例如图像分类、对象检测、姿势估计、问题回答、文本分类等。
+
+
+1. 创建 TensorFlow Lite 模型
+TensorFlow Lite 模型以名为 FlatBuffer 的专用高效可移植格式（由“.tflite”文件扩展名标识）表示。与 TensorFlow 的协议缓冲区模型格式相比，这种格式具有多种优势，例如可缩减大小（代码占用的空间较小）以及提高推断速度（可直接访问数据，无需执行额外的解析/解压缩步骤），这样一来，TensorFlow Lite 即可在计算和内存资源有限的设备上高效地运行。
+
+TensorFlow Lite 模型可以选择包含元数据，并在元数据中添加人类可读的模型说明和机器可读的数据，以便在设备推断过程中自动生成处理前和处理后流水线。如需了解详情，请参阅添加元数据。
+
+您可以通过以下方式生成 TensorFlow Lite 模型：
+
+使用现有的 TensorFlow Lite 模型：若要选择现有模型，请参阅 TensorFlow Lite 示例。模型可能包含元数据，也可能不含元数据。
+
+创建 TensorFlow Lite 模型：使用 TensorFlow Lite Model Maker，利用您自己的自定义数据集创建模型。默认情况下，所有模型都包含元数据。
+
+将 TensorFlow 模型转换为 TensorFlow Lite 模型：使用 TensorFlow Lite Converter 将 TensorFlow 模型转换为 TensorFlow Lite 模型。在转换过程中，您可以应用量化等优化措施，以缩减模型大小和缩短延时，并最大限度降低或完全避免准确率损失。默认情况下，所有模型都不含元数据。
+
+
+
+

From e6bd892680d9e26a2784190076bb90cb8d650ae2 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Fri, 27 Sep 2024 17:00:54 +0800
Subject: [PATCH 193/213] update

---
 .../Parcelable\345\217\212Serializable.md"    |  63 ++++++++++-
 ...\347\256\200\344\273\213(\344\270\213).md" |  27 +++++
 ...etpack Compose\347\273\204\344\273\266.md" | 106 ++++++++++++++++++
 ...7&\345\205\263\351\224\256\345\255\227.md" |  36 ++++++
 ...2\344\270\276&\345\247\224\346\211\230.md" |  21 ++++
 MobileAIModel/TensorFlow Lite                 |   7 +-
 6 files changed, 258 insertions(+), 2 deletions(-)
 create mode 100644 "Jetpack/ui/Jetpack Compose\347\273\204\344\273\266.md"

diff --git "a/BasicKnowledge/Parcelable\345\217\212Serializable.md" "b/BasicKnowledge/Parcelable\345\217\212Serializable.md"
index 73a927a1..de220416 100644
--- "a/BasicKnowledge/Parcelable\345\217\212Serializable.md"
+++ "b/BasicKnowledge/Parcelable\345\217\212Serializable.md"
@@ -1,6 +1,15 @@
 Parcelable及Serializable
 ===
 
+
+
+### Serializable
+
+在Java中Serializable接口是一个允许将对象转换为字节流(序列化)然后重新构造回对象(反序列化)的标记接口。   
+
+它会使用反射，并且会创建许多临时对象，导致内存使用率升高，并可能产生性能问题。  
+
+
 `Serializable`的作用是为了保存对象的属性到本地文件、数据库、网络流、`rmi`以方便数据传输，
 当然这种传输可以是程序内的也可以是两个程序间的。而`Parcelable`的设计初衷是因为`Serializable`效率过慢，
 为了在程序内不同组件间以及不同`Android`程序间(`AIDL`)高效的传输数据而设计，这些数据仅在内存中存在，`Parcelable`是通过`IBinder`通信的消息的载体。
@@ -11,6 +20,58 @@ Parcelable及Serializable
 
 Parcelable不同于将对象进行序列化，Parcelable方式的实现原理是将一个完整的对象进行分解，而分解后的每一部分都是Intent所支持的数据类型，这样也就实现传递对象的功能了。
 
+
+### Parcelable实现
+
+```kotlin
+data class Developer(val name: String, val age: Int) : Parcelable {
+
+    constructor(parcel: Parcel) : this(
+        parcel.readString(),
+        parcel.readInt()
+    )
+
+    override fun writeToParcel(parcel: Parcel, flags: Int) {
+        parcel.writeString(name)
+        parcel.writeInt(age)
+    }
+
+    // code removed for brevity
+
+    companion object CREATOR : Parcelable.Creator<Developer> {
+        override fun createFromParcel(parcel: Parcel): Developer {
+            return Developer(parcel)
+        }
+
+        override fun newArray(size: Int): Array<Developer?> {
+            return arrayOfNulls(size)
+        }
+    }
+}
+
+```
+上面是实现Parcelable的代码，可以看到有很多重复的代码。      
+为了避免写这些重复的代码，可以使用kotlin-parcelize插件，并在类上使用@Parcelize注解。
+
+```kotlin
+@Parcelize
+data class Developer(val name: String, val age: Int) : Parcelable
+```
+
+当在一个类上声明`@Parcelize`注解后，就会自动生成对应的代码。     
+
+
+
+
+
+Parcelable不会使用反射，并且在序列化过程中会产生更少的临时对象，这样就会减少垃圾回收的压力:    
+
+- Parcelable不会使用反射
+- Parcelable是Android平台特定的接口
+
+所以Parcelable比Serializable更快。    
+
+
 区别:    
 - Parcelable is faster than serializable interface
 - Parcelable interface takes more time for implemetation compared to serializable interface
@@ -20,4 +81,4 @@ Parcelable不同于将对象进行序列化，Parcelable方式的实现原理是
 
 ----
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/ImageLoaderLibrary/Glide\347\256\200\344\273\213(\344\270\213).md" "b/ImageLoaderLibrary/Glide\347\256\200\344\273\213(\344\270\213).md"
index 5456759f..7c246365 100644
--- "a/ImageLoaderLibrary/Glide\347\256\200\344\273\213(\344\270\213).md"
+++ "b/ImageLoaderLibrary/Glide\347\256\200\344\273\213(\344\270\213).md"
@@ -420,6 +420,33 @@ builder.setDiskCache(
 - `Disk cache needs to implement: DiskCache`
 
 
+
+
+Let's take Glide as an example. To optimize memory usage and use less memory, Glide does downsampling.
+
+Downsampling means scaling the bitmap(image) to a smaller size which is actually required by the view.
+
+Assume that we have an image of size 2000*2000, but the view size is 400*400. So why load an image of 2000*2000, Glide down-samples the bitmap to 400*400, and then show it into the view.
+
+We use Glide like this:
+```
+Glide.with(fragment)
+    .load(url)
+    .into(imageView);
+```
+As we are passing the imageView as a parameter to the Glide, it knows the dimension of the imageView.
+
+Glide down-samples the image without loading the whole image into the memory.
+
+This way, the bitmap takes less memory, and the out-of-memory error is solved. Similarly, other Image Loading libraries like Fresco also do it.
+
+This was all about how the Android Image Loading library optimizes memory usage.
+
+
+
+
+
+
 参考
 ===
 
diff --git "a/Jetpack/ui/Jetpack Compose\347\273\204\344\273\266.md" "b/Jetpack/ui/Jetpack Compose\347\273\204\344\273\266.md"
new file mode 100644
index 00000000..3ffcb46e
--- /dev/null
+++ "b/Jetpack/ui/Jetpack Compose\347\273\204\344\273\266.md"	
@@ -0,0 +1,106 @@
+# Jetpack Compose组件
+
+### Text组件
+
+```kotlin
+Text(text = "Hello World")
+Text(
+    text = stringResource(id = R.string.next),
+    style = TextStyle(
+        fontSize = 25.sp,
+        fontWeight = FontWeight.Bold,
+        lineHeight = 35.sp,
+        color = Color.Red,
+        textDecoration = TextDecoration.LineThrough,
+        fontStyle = FontStyle.Italic
+    )
+)
+```
+
+#### AnnotatedString多样式文字
+
+在很多应用场景中，我们需要在一段文字中对局部内容应用特别格式以示突出，比如一个超链接或者一个电话号码等，此时需要用到AnnotatedString。AnnotatedString是一个数据类，除了文本值，它还包含了一个SpanStyle和ParagraphStyle的Range列表。SpanStyle用于描述在文本中子串的文字样式，ParagraphStyle则用于描述文本中子串的段落样式，Range确定子串的范围。
+
+```kotlin
+val annotedText = buildAnnotatedString {
+    withStyle(style = SpanStyle(fontSize = 23.sp)) {
+        pushStringAnnotation(tag = "url", annotation = "https://www.baidu.com")
+        append("haha")
+    }
+
+    withStyle(SpanStyle(fontSize = 30.sp)) {
+        append("A")
+    }
+}
+
+ClickableText(
+    text = annotedText,
+    onClick = { offset ->
+        annotedText.getStringAnnotations(tag = "url", start = offset, end = offset)
+            .firstOrNull()?.let {
+            Log.e("@@@", it.item)
+        }
+    }
+)
+```
+
+Compose提供了一种可点击文本组件ClickedText，可以响应我们对文字的点击，并返回点击位置。可以让AnnotatdString子串在相应的ClickedText中点击后，做出不同的动作。
+
+
+
+
+
+### SelectionContainer
+
+选中文字Text自身默认是不能被长按选择的，否则在Button中使用时，又会出现那种“可粘贴的Button”的例子。       
+Compose提供了专门的SelectionContainer组件，对包裹的Text进行选中。可见Compose在组件设计上，将关注点分离的原则发挥到了极致。
+
+
+```kotlin
+SelectionContainer {
+    Text("hahah")
+}
+```
+
+
+
+### TextField输入框
+
+
+TextField有两种风格，一种是默认的，也就是filled，另一种是OutlinedTextField。      
+```kotlin
+var text by remember { mutableStateOf("") }
+
+TextField(value = text, onValueChange = {
+    text = it
+}, label = { Text("请输入用户名") })
+```
+
+这个text是一个可以变化的文本，用来显示TextField输入框中当前输入的文本内容。           在onValueChange回调中可以获取来自软键盘的最新输入，我们利用这个信息来更新可变状态text，驱动界面刷新显示最新的输入文本。
+
+
+***来自软键盘的输入内容不会直接更新TextField, TextField需要通过观察额外的状态更新自身，这也体现了声明式UI中“状态驱动UI”的基本理念。***
+
+
+
+
+
+### Column组件
+
+很多产品中都有展示一组数据的需求场景，如果数据数量是可以枚举的，则仅需通过Column组件来枚举列出。 
+
+
+然而很多时候，列表中的项目会非常多，例如通讯录、短信、音乐列表等，我们需要滑动列表来查看所有的内容，可以通过Column的Modifier添加verticalScroll()方法来让列表实现滑动。     
+
+
+#### LazyComposables
+
+给Column的Modifier添加verticalScroll()方法可以让列表实现滑动。    
+
+但是如果列表过长，众多的内容会占用大量的内存。然而更多的内容对于用户其实都是不可见的，没必要记载到内存。     
+
+所以Compose提供了专门用于处理长列表的组件，这些组件指挥在我们能看到的列表部分进行重组和布局，它们分别是LazyColumn和LazyRow。其作用类似于传统视图中的ListView或者RecyclerView。   
+
+
+
+
diff --git "a/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md" "b/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md"
index f922d625..159e419a 100644
--- "a/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md"
+++ "b/KotlinCourse/4.Kotlin_\350\241\250\350\276\276\345\274\217&\345\205\263\351\224\256\345\255\227.md"
@@ -218,6 +218,42 @@ for(num in nums) {
 
 
 
+### infix关键字   
+
+Kotlin中infix的中缀表示法允许在不使用点和括号的情况下调用函数。
+
+
+例如:   
+
+```kotlin
+infix fun Int.add(value: Int): Int = this + value
+
+val sum = 5 add 10
+```
+
+平时在使用map的时候经常会这样用:     
+
+```kotlin
+val map = mapOf(
+    1 to "A",
+    2 to "B",
+    3 to "C"
+)
+```
+而mapOf需要一个Pair<K, V>的列表。这里可以使用to关键字来实现就是因为infix。     
+
+我们可以检查一下Kotlin中的Pair的源码，就会发现:     
+```kotlin
+infix fun <A, B> A.to(that: B): Pair<A, B> = Pair(this, that)
+```
+
+使用infix的时候有个点需要注意:    
+
+- 它必须是一个函数
+- 必须只有一个参数
+- 参数不能是可变参数
+- 参数不能有默认值
+
 
 - [上一篇:3.Kotlin_数字&字符串&数组&集合](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/3.Kotlin_%E6%95%B0%E5%AD%97%26%E5%AD%97%E7%AC%A6%E4%B8%B2%26%E6%95%B0%E7%BB%84%26%E9%9B%86%E5%90%88.md)       
 - [下一篇:5.Kotlin_内部类&密封类&枚举&委托](https://github.com/CharonChui/AndroidNote/blob/master/KotlinCourse/5.Kotlin_%E5%86%85%E9%83%A8%E7%B1%BB%26%E5%AF%86%E5%B0%81%E7%B1%BB%26%E6%9E%9A%E4%B8%BE%26%E5%A7%94%E6%89%98.md)    
diff --git "a/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md" "b/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
index d738c4b2..7f4030b1 100644
--- "a/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
+++ "b/KotlinCourse/5.Kotlin_\345\206\205\351\203\250\347\261\273&\345\257\206\345\260\201\347\261\273&\346\236\232\344\270\276&\345\247\224\346\211\230.md"
@@ -411,6 +411,27 @@ object Resource {
 }
 ```
 
+
+Kotlin中除了object之外还有一个companion object，也可以替代Java中的static关键字，那他俩有什么区别呢？  
+
+
+#### Companion object
+
+- 必须在一个类中定义      
+- companion object会在类第一次加载的时候就创建好，这就意味着我们可能还没使用的时候就初始化好了
+- 它等同于Java中的static     
+- 如果我们不手动指定名字的话会有一个默认的Companion的名字      
+- 在调用方法或变量的时候可以省略名字
+
+#### object
+
+- 可以被定义到任何地方      
+- 在我们第一次使用它时才会创建。      
+- 主要被用作提供单例行为       
+- 必须提供一个命名          
+- 如果在一个类中定义object，那在调用方法或者变量的时候不能省略名字  
+
+
 ### 对象表达式
 
 对象也能用于创建匿名类实现。
diff --git a/MobileAIModel/TensorFlow Lite b/MobileAIModel/TensorFlow Lite
index dc7054e3..3e3be658 100644
--- a/MobileAIModel/TensorFlow Lite	
+++ b/MobileAIModel/TensorFlow Lite	
@@ -6,6 +6,9 @@ TensorFlow Lite
 
 [TensorFlow Lite](https://tensorflow.google.cn/lite?hl=zh-cn) 是一组工具，可帮助开发者在移动设备、嵌入式设备和 loT 设备上运行模型，以便实现设备端机器学习。
 
+
+TensorFlow Lite是TensorFlow在手机和嵌入设备上的一个轻量级框架。      
+
 主要特性:  
 
 - 通过解决以下 5 项约束条件，针对设备端机器学习进行了优化：延时（数据无需往返服务器）、隐私（没有任何个人数据离开设备）、连接性（无需连接互联网）、大小（缩减了模型和二进制文件的大小）和功耗（高效推断，且无需网络连接）。
@@ -16,7 +19,9 @@ TensorFlow Lite
 
 
 1. 创建 TensorFlow Lite 模型
-TensorFlow Lite 模型以名为 FlatBuffer 的专用高效可移植格式（由“.tflite”文件扩展名标识）表示。与 TensorFlow 的协议缓冲区模型格式相比，这种格式具有多种优势，例如可缩减大小（代码占用的空间较小）以及提高推断速度（可直接访问数据，无需执行额外的解析/解压缩步骤），这样一来，TensorFlow Lite 即可在计算和内存资源有限的设备上高效地运行。
+TensorFlow Lite 模型以名为 FlatBuffer 的专用高效可移植格式（由“.tflite”文件扩展名标识）表示。      
+
+与 TensorFlow 的协议缓冲区模型格式相比，这种格式具有多种优势，例如可缩减大小（代码占用的空间较小）以及提高推断速度（可直接访问数据，无需执行额外的解析/解压缩步骤），这样一来，TensorFlow Lite 即可在计算和内存资源有限的设备上高效地运行。
 
 TensorFlow Lite 模型可以选择包含元数据，并在元数据中添加人类可读的模型说明和机器可读的数据，以便在设备推断过程中自动生成处理前和处理后流水线。如需了解详情，请参阅添加元数据。
 

From 071c6288b4b424df948f06f29f2c17c8388c4e02 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Sat, 12 Oct 2024 17:29:06 +0800
Subject: [PATCH 194/213] update

---
 ...44\346\225\260\344\271\213\345\222\214.md" | 27 ++++++-------
 ...44\346\225\260\347\233\270\345\212\240.md" | 40 +++++++++----------
 2 files changed, 33 insertions(+), 34 deletions(-)

diff --git "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/1. LeetCode_\344\270\244\346\225\260\344\271\213\345\222\214.md" "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/1. LeetCode_\344\270\244\346\225\260\344\271\213\345\222\214.md"
index 72102238..b5d71dba 100644
--- "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/1. LeetCode_\344\270\244\346\225\260\344\271\213\345\222\214.md"	
+++ "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/1. LeetCode_\344\270\244\346\225\260\344\271\213\345\222\214.md"	
@@ -1,24 +1,28 @@
 1. LeetCode_两数之和
 ===
 
-给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。
+给定一个整数数组nums和一个整数目标值target，请你在该数组中找出和为目标值target的那两个整数，并返回它们的数组下标。
 
 你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
 
 你可以按任意顺序返回答案。
 
  
+---
 
-示例 1：
+示例 1           
 
 输入：nums = [2,7,11,15], target = 9
 输出：[0,1]
 解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
+
+
 示例 2：
 
 输入：nums = [3,2,4], target = 6
 输出：[1,2]
-示例 3：
+
+示例 3：        
 
 输入：nums = [3,3], target = 6
 输出：[0,1]
@@ -27,9 +31,6 @@
 
 提示：
 
-2 <= nums.length <= 104
--109 <= nums[i] <= 109
--109 <= target <= 109
 只会存在一个有效答案
  
 
@@ -89,11 +90,11 @@ public:
 
 ### 方法二： 哈希表
 
-注意到方法一的时间复杂度较高的原因是寻找 target - x 的时间复杂度过高。
+注意到方法一的时间复杂度较高的原因是寻找target - x的时间复杂度过高。
 
 因此，我们需要一种更优秀的方法，能够快速寻找数组中是否存在目标元素。如果存在，我们需要找出它的索引。
 
-使用哈希表，可以将寻找 target - x 的时间复杂度降低到从 O(N) 降低到 O(1)。
+使用哈希表，可以将寻找target - x的时间复杂度降低到从O(N)降低到O(1)。
 
 
 ---
@@ -104,17 +105,15 @@ public:
 - key: 存储数组里的值
 - value: 存储数组的下标index
 
-这样我们只需要通过target - nums[i]的值去Map中查找即可。
-但是这样存在一个问题，就是你需要先把数组中的值都放到Map中，需要多一步循环。
-
-
+这样我们只需要通过target - nums[i]的值去Map中查找即可。      
+但是这样存在一个问题，就是你需要先把数组中的值都放到Map中，需要多一步循环。       
 
 
 --- 
 
-其实我们可以先创建一个Map，在Map的初始化过程中什么元素都不放。    
+其实我们可以先创建一个Map，在Map的初始化过程中什么元素都不放。     
 
-对于每一个 x，我们首先查询哈希表中是否存在 target - x，如果已存在就返回，如果不存在那再将 x 插入到哈希表中，即可保证不会让 x 和自己匹配。
+对于每一个x，我们首先查询哈希表中是否存在target-x，如果已存在就返回，如果不存在那再将x插入到哈希表中，即可保证不会让x和自己匹配。
 
 这样只需要一次循环就可以了，而且Map数组不用提前初始化，在性能和内存占用率都比较低。  
 
diff --git "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/2. LeetCode_\344\270\244\346\225\260\347\233\270\345\212\240.md" "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/2. LeetCode_\344\270\244\346\225\260\347\233\270\345\212\240.md"
index 789a2a9f..03581f19 100644
--- "a/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/2. LeetCode_\344\270\244\346\225\260\347\233\270\345\212\240.md"	
+++ "b/JavaKnowledge/\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\347\256\227\346\263\225/2. LeetCode_\344\270\244\346\225\260\347\233\270\345\212\240.md"	
@@ -1,11 +1,11 @@
-2. LeetCode_两数相加
+2. LeetCode_两数相加       
 ===
 
-给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
+给你两个非空的链表，表示两个非负的整数。它们每位数字都是按照逆序的方式存储的，并且每个节点只能存储一位数字。
 
 请你将两个数相加，并以相同形式返回一个表示和的链表。
 
-你可以假设除了数字 0 之外，这两个数都不会以 0 开头。
+你可以假设除了数字0之外，这两个数都不会以0开头。
 
 
 输入：l1 = [2,4,3], l2 = [5,6,4]
@@ -18,31 +18,31 @@
 输出：[8,9,9,9,0,0,0,1]
 
 
-提示：
+提示:      
 
-- 每个链表中的节点数在范围 [1, 100] 内
+- 每个链表中的节点数在范围[1, 100]内
 - 0 <= Node.val <= 9
 - 题目数据保证列表表示的数字不含前导零
 
 
 
-想法：  
+想法:       
 
 我的想法是先把两个链表转成两个整数相加，然后把这个整数转成字符串再次生成链表。      
 
 这种方案是不可行的，因为链表的长度可能会很长，整数是操作不了的，例如:  
 
 
-方法： 
+方法:      
 
-由于输入的两个链表都是逆序存储数字的位数的，因此两个链表中同一位置的数字可以直接相加。      
+- 由于输入的两个链表都是逆序存储数字的位数的，因此两个链表中同一位置的数字可以直接相加。      
 
-我们同时遍历两个链表，逐位计算它们的和，并与当前位置的进位值相加。具体而言，如果当前两个链表处相应位置的数字为 n1,n2，进位值为 carry，则它们的和为 n1+n2+carry；      
+- 我们同时遍历两个链表，逐位计算它们的和，并与当前位置的进位值相加。具体而言，如果当前两个链表处相应位置的数字为 n1,n2，进位值为 carry，则它们的和为 n1+n2+carry；      
 其中，答案链表处相应位置的数字为 (n1+n2+carry)mod10，而新的进位值为 [(n1+n2+carry) / 10]
 
-如果两个链表的长度不同，则可以认为长度短的链表的后面有若干个 0 。
+- 如果两个链表的长度不同，则可以认为长度短的链表的后面有若干个 0 。
 
-此外，如果链表遍历结束后，有 carry>0，还需要在答案链表的后面附加一个节点，节点的值为 carry。
+- 此外，如果链表遍历结束后，有carry>0，还需要在答案链表的后面附加一个节点，节点的值为 carry。
 
 
 
@@ -50,12 +50,12 @@
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_2_twoaddsum.png?raw=true)    
 
 
-- 将链表反过来看，头结点在右侧
-- 横线上的数字为进位
-- 2 + 5 + 0(第一个进位默认为0) = 7 
+- 将链表反过来看，头结点在右侧          
+- 横线上的数字为进位         
+- 2 + 5 + 0(第一个进位默认为0) = 7       
 
-    - 7 % 10得到新节点中的元素为7
-    - 7 / 10得到下一个进位为0
+    - 7 % 10得到新节点中的元素为7      
+    - 7 / 10得到下一个进位为0      
 
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_2_twoaddsum_2.png?raw=true)    
@@ -123,11 +123,11 @@ class Solution {
 
 
 
-复杂度分析:    
+复杂度分析:         
 
-- 时间复杂度：O(max(m,n))，其中 m 和 n 分别为两个链表的长度。我们要遍历两个链表的全部位置，而处理每个位置只需要 O(1) 的时间。
+- 时间复杂度: O(max(m,n))，其中m和n分别为两个链表的长度。我们要遍历两个链表的全部位置，而处理每个位置只需要O(1)的时间。
 
-- 空间复杂度：O(1)。注意返回值不计入空间复杂度。
+- 空间复杂度: O(1)。注意返回值不计入空间复杂度。
 
 
 ### 改进： 递归
@@ -139,7 +139,7 @@ class Solution {
     }
 }
 
-    public ListNode add(ListNode l1, ListNode l2, int carry) {
+public ListNode add(ListNode l1, ListNode l2, int carry) {
         if (l1 == null && l2 == null && carry == 0) {
             return null;
         }

From 15e18a0332746dde75530ce0564a757c498eb8ab Mon Sep 17 00:00:00 2001
From: Charon <CharonChui@users.noreply.github.com>
Date: Mon, 14 Oct 2024 16:31:43 +0800
Subject: [PATCH 195/213] =?UTF-8?q?Update=20Android=E5=90=AF=E5=8A=A8?=
 =?UTF-8?q?=E6=A8=A1=E5=BC=8F=E8=AF=A6=E8=A7=A3.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...12\250\346\250\241\345\274\217\350\257\246\350\247\243.md" | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git "a/AdavancedPart/Android\345\220\257\345\212\250\346\250\241\345\274\217\350\257\246\350\247\243.md" "b/AdavancedPart/Android\345\220\257\345\212\250\346\250\241\345\274\217\350\257\246\350\247\243.md"
index 6c5ef656..eb958f00 100644
--- "a/AdavancedPart/Android\345\220\257\345\212\250\346\250\241\345\274\217\350\257\246\350\247\243.md"
+++ "b/AdavancedPart/Android\345\220\257\345\212\250\346\250\241\345\274\217\350\257\246\350\247\243.md"
@@ -33,7 +33,7 @@ Android启动模式详解
 顾名思义，是单一实例的意思，即任意时刻只允许存在唯一的`Activity`实例，而且该`Activity`所在的`task`不能容纳除该`Activity`之外的其他`Activity`实例！               
 它与`singleTask`有相同之处，也有不同之处。          
 相同之处：任意时刻，最多只允许存在一个实例。            
-不同之处：
+不同之处：       
     - `singleTask`受`android:taskAffinity`属性的影响，而`singleInstance`不受`android:taskAffinity`的影响。 
     - `singleTask`所在的`task`中能有其它的`Activity`，而`singleInstance`的`task`中不能有其他`Activity`。     
     - 当跳转到`singleTask`类型的`Activity`，并且该`Activity`实例已经存在时，会删除该`Activity`所在`task`中位于该`Activity`之上的全部`Activity`实例；而跳转到`singleInstance`类型的`Activity`，并且该`Activity`已经存在时，
@@ -59,4 +59,4 @@ Android启动模式详解
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 

From a9eac5a7f869e78bbac9bb32093db41f78c9809f Mon Sep 17 00:00:00 2001
From: Charon <CharonChui@users.noreply.github.com>
Date: Mon, 14 Oct 2024 16:32:16 +0800
Subject: [PATCH 196/213] =?UTF-8?q?Update=20Android=E5=90=AF=E5=8A=A8?=
 =?UTF-8?q?=E6=A8=A1=E5=BC=8F=E8=AF=A6=E8=A7=A3.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...250\346\250\241\345\274\217\350\257\246\350\247\243.md" | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git "a/AdavancedPart/Android\345\220\257\345\212\250\346\250\241\345\274\217\350\257\246\350\247\243.md" "b/AdavancedPart/Android\345\220\257\345\212\250\346\250\241\345\274\217\350\257\246\350\247\243.md"
index eb958f00..76a6fd8a 100644
--- "a/AdavancedPart/Android\345\220\257\345\212\250\346\250\241\345\274\217\350\257\246\350\247\243.md"
+++ "b/AdavancedPart/Android\345\220\257\345\212\250\346\250\241\345\274\217\350\257\246\350\247\243.md"
@@ -31,9 +31,10 @@ Android启动模式详解
 - `singleInstance`
 
 顾名思义，是单一实例的意思，即任意时刻只允许存在唯一的`Activity`实例，而且该`Activity`所在的`task`不能容纳除该`Activity`之外的其他`Activity`实例！               
-它与`singleTask`有相同之处，也有不同之处。          
-相同之处：任意时刻，最多只允许存在一个实例。            
-不同之处：       
+它与`singleTask`有相同之处，也有不同之处。           
+相同之处: 任意时刻，最多只允许存在一个实例。             
+不同之处:       
+
     - `singleTask`受`android:taskAffinity`属性的影响，而`singleInstance`不受`android:taskAffinity`的影响。 
     - `singleTask`所在的`task`中能有其它的`Activity`，而`singleInstance`的`task`中不能有其他`Activity`。     
     - 当跳转到`singleTask`类型的`Activity`，并且该`Activity`实例已经存在时，会删除该`Activity`所在`task`中位于该`Activity`之上的全部`Activity`实例；而跳转到`singleInstance`类型的`Activity`，并且该`Activity`已经存在时，

From dd55b6b78472c40f5602859468226060af302836 Mon Sep 17 00:00:00 2001
From: Charon <CharonChui@users.noreply.github.com>
Date: Mon, 14 Oct 2024 16:34:06 +0800
Subject: [PATCH 197/213] =?UTF-8?q?Update=20Android=E5=90=AF=E5=8A=A8?=
 =?UTF-8?q?=E6=A8=A1=E5=BC=8F=E8=AF=A6=E8=A7=A3.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...250\241\345\274\217\350\257\246\350\247\243.md" | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git "a/AdavancedPart/Android\345\220\257\345\212\250\346\250\241\345\274\217\350\257\246\350\247\243.md" "b/AdavancedPart/Android\345\220\257\345\212\250\346\250\241\345\274\217\350\257\246\350\247\243.md"
index 76a6fd8a..5008840f 100644
--- "a/AdavancedPart/Android\345\220\257\345\212\250\346\250\241\345\274\217\350\257\246\350\247\243.md"
+++ "b/AdavancedPart/Android\345\220\257\345\212\250\346\250\241\345\274\217\350\257\246\350\247\243.md"
@@ -35,15 +35,17 @@ Android启动模式详解
 相同之处: 任意时刻，最多只允许存在一个实例。             
 不同之处:       
 
-    - `singleTask`受`android:taskAffinity`属性的影响，而`singleInstance`不受`android:taskAffinity`的影响。 
-    - `singleTask`所在的`task`中能有其它的`Activity`，而`singleInstance`的`task`中不能有其他`Activity`。     
-    - 当跳转到`singleTask`类型的`Activity`，并且该`Activity`实例已经存在时，会删除该`Activity`所在`task`中位于该`Activity`之上的全部`Activity`实例；而跳转到`singleInstance`类型的`Activity`，并且该`Activity`已经存在时，
-	不需要删除其他`Activity`，因为它所在的`task`只有该`Activity`唯一一个`Activity`实例。
+- `singleTask`受`android:taskAffinity`属性的影响，而`singleInstance`不受`android:taskAffinity`的影响。 
+- `singleTask`所在的`task`中能有其它的`Activity`，而`singleInstance`的`task`中不能有其他`Activity`。     
+- 当跳转到`singleTask`类型的`Activity`，并且该`Activity`实例已经存在时，会删除该`Activity`所在`task`中位于该`Activity`之上的全部`Activity`实例；而跳转到`singleInstance`类型的`Activity`，并且该`Activity`已经存在时，不需要删除其他`Activity`，因为它所在的`task`只有该`Activity`唯一一个`Activity`实例。
 
 
-假设我们的程序中有一个Activity是允许其他程序调用的，如果想实现其他程序和我们的程序可以共享这个Activity的实例，应该如何实现呢？使用前面3种启动模式肯定是做不到的，因为每个应用程序都会有自己的返回栈，同一个Activity在不同的返回栈中入栈时必然创建了新的实例。而使用singleInstance模式就可以解决这个问题，在这种模式下，会有一个单独的返回栈来管理这个Activity，不管是哪个应用程序来访问这个Activity，都共用同一个返回栈，也就解决了共享Activity实例的问题。
+假设我们的程序中有一个Activity是允许其他程序调用的，如果想实现其他程序和我们的程序可以共享这个Activity的实例，应该如何实现呢？         
 
-假设现在有FirstActivity、SecondActivity、ThirdActivity三个Activity， SecondActivity的启动模式是SingleInstance。 
+使用前面3种启动模式肯定是做不到的，因为每个应用程序都会有自己的返回栈，同一个Activity在不同的返回栈中入栈时必然创建了新的实例。         
+而使用singleInstance模式就可以解决这个问题，在这种模式下，会有一个单独的返回栈来管理这个Activity，不管是哪个应用程序来访问这个Activity，都共用同一个返回栈，也就解决了共享Activity实例的问题。
+
+假设现在有FirstActivity、SecondActivity、ThirdActivity三个Activity， SecondActivity的启动模式是SingleInstance。      
 现在FirstActivity 启动SecondActivity，SecondActivity再启动ThirdActivity。 
 
 然后我们按下Back键进行返回，你会发现ThirdActivity竟然直接返回到了FirstActivity，再按下Back键又会返回到SecondActivity，再按下Back键才会退出程序，这是为什么呢？其实原理很简单，由于FirstActivity和ThirdActivity是存放在同一个返回栈里的，当在ThirdActivity的界面按下Back键时，ThirdActivity会从返回栈中出栈，那么FirstActivity就成为了栈顶Activity显示在界面上，因此也就出现了从ThirdActivity直接返回到FirstActivity的情况。然后在FirstActivity界面再次按下Back键，这时当前的返回栈已经空了，于是就显示了另一个返回栈的栈顶Activity，即SecondActivity。最后再次按下Back键，这时所有返回栈都已经空了，也就自然退出了程序。

From df2d625c4a3adc807babfb97ad21ed03d8c4d4df Mon Sep 17 00:00:00 2001
From: Charon <CharonChui@users.noreply.github.com>
Date: Fri, 18 Oct 2024 17:37:52 +0800
Subject: [PATCH 198/213] =?UTF-8?q?Update=201.OpenCV=E7=AE=80=E4=BB=8B.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 "VideoDevelopment/OpenCV/1.OpenCV\347\256\200\344\273\213.md" | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git "a/VideoDevelopment/OpenCV/1.OpenCV\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenCV/1.OpenCV\347\256\200\344\273\213.md"
index d9b77c6e..0a7a5eb1 100644
--- "a/VideoDevelopment/OpenCV/1.OpenCV\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenCV/1.OpenCV\347\256\200\344\273\213.md"
@@ -51,8 +51,8 @@ API：
 	默认的BGR 彩色图像加载方式，此外支持灰度图像和任意格式。注意：在OpenCV中颜色值写法是BGR，而不是RGB。
     imread() 函数默认加载图像文件，加载进来的是3 通道彩色图像，色彩空间是RGB 色彩空间。
     通道顺序是：BGR （蓝色、绿色、红色）。
-    通道分离函数：split（）
-    通道合并函数：merge（）
+    通道分离函数：split()
+    通道合并函数：merge()
 - imshow("namexx", ...url...)：显示图像
 - getStructuringElement(...)：获取腐蚀的内核矩阵
 - erode(...)：腐蚀(源图像、目的图像、内核矩阵）

From 7e957935d1d7c69ad1f87c383b9a0637d9809086 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Fri, 20 Dec 2024 14:19:45 +0800
Subject: [PATCH 199/213] update

---
 ...345\217\212ANR\345\210\206\346\236\220.md" | 20 +++--
 AdavancedPart/Java                            |  0
 Gradle&Maven/kts.md                           | 52 ++++++++-----
 ...37\347\220\206\345\210\206\346\236\220.md" | 29 +++++---
 .../1.OpenCV\347\256\200\344\273\213.md"      |  2 +-
 ...16\351\242\234\346\273\244\351\225\234.md" | 43 +++++++++++
 ...01\351\245\261\345\222\214\345\272\246.md" | 74 +++++++++++++++++++
 7 files changed, 184 insertions(+), 36 deletions(-)
 create mode 100644 AdavancedPart/Java
 create mode 100644 "VideoDevelopment/OpenGL/15.\347\276\216\351\242\234\346\273\244\351\225\234.md"
 create mode 100644 "VideoDevelopment/OpenGL/16.\350\211\262\346\270\251\343\200\201\350\211\262\350\260\203\343\200\201\351\245\261\345\222\214\345\272\246.md"

diff --git "a/AdavancedPart/Crash\345\217\212ANR\345\210\206\346\236\220.md" "b/AdavancedPart/Crash\345\217\212ANR\345\210\206\346\236\220.md"
index df4d8ccf..54dcdcfa 100644
--- "a/AdavancedPart/Crash\345\217\212ANR\345\210\206\346\236\220.md"
+++ "b/AdavancedPart/Crash\345\217\212ANR\345\210\206\346\236\220.md"
@@ -4,9 +4,13 @@
 ## Java Crash流程
 
 1、首先发生crash所在进程，在创建之初便准备好了defaultUncaughtHandler，用来处理Uncaught Exception，并输出当前crash的基本信息；
+
 2、调用当前进程中的AMP.handleApplicationCrash；经过binder ipc机制，传递到system_server进程；
+
 3、接下来，进入system_server进程，调用binder服务端执行AMS.handleApplicationCrash；
+
 4、从mProcessNames查找到目标进程的ProcessRecord对象；并将进程crash信息输出到目录/data/system/dropbox；
+
 5、执行makeAppCrashingLocked：
 
 创建当前用户下的crash应用的error receiver，并忽略当前应用的广播；
@@ -19,8 +23,11 @@
 当1分钟内同一进程未发生连续crash两次时，则执行结束栈顶正在运行activity的流程。
 
 7、通过mUiHandler发送消息SHOW_ERROR_MSG，弹出crash对话框；
+
 8、到此，system_server进程执行完成。回到crash进程开始执行杀掉当前进程的操作；
+
 9、当crash进程被杀，通过binder死亡通知，告知system_server进程来执行appDiedLocked()；
+
 10、最后，执行清理应用相关的四大组件信息。
 
 
@@ -35,12 +42,15 @@
 
 
 
-Native Crash
+Native Crash:    
+
+- 崩溃过程：native crash 时操作系统会向进程发送信号，崩溃信息会写入到 data/tombstones 下，并在 logcat 输出崩溃日志
+
+- 定位：so 库剥离调试信息的话，只有相对位置没有具体行号，可以使用 NDK 提供的 addr2line 或 ndk-stack 来定位
+
+- addr2line：根据有调试信息的 so 和相对位置定位实际的代码处
 
-    崩溃过程：native crash 时操作系统会向进程发送信号，崩溃信息会写入到 data/tombstones 下，并在 logcat 输出崩溃日志
-    定位：so 库剥离调试信息的话，只有相对位置没有具体行号，可以使用 NDK 提供的 addr2line 或 ndk-stack 来定位
-    addr2line：根据有调试信息的 so 和相对位置定位实际的代码处
-    ndk-stack：可以分析 tombstone 文件，得到实际的代码调用栈
+- ndk-stack：可以分析 tombstone 文件，得到实际的代码调用栈
 
 
 
diff --git a/AdavancedPart/Java b/AdavancedPart/Java
new file mode 100644
index 00000000..e69de29b
diff --git a/Gradle&Maven/kts.md b/Gradle&Maven/kts.md
index a12bb7ca..c6a2e26c 100644
--- a/Gradle&Maven/kts.md
+++ b/Gradle&Maven/kts.md
@@ -4,60 +4,72 @@ Gradle 支持使用 Groovy DSL 或 Kotlin DSL 来编写脚本。所以在学习
 
 所以下面来学习一下这两种语言的差异。
 
-1. Groovy 和 Kotlin 的差异
+1. Groovy 和 Kotlin 的差异     
+
 1.1 语言差异
-Groovy
-Groovy是一种基于 JVM 的面向对象的编程语言，它可以作为常规编程语言，但主要是作为脚本的语言（为了解决 Java 在写脚本时过于死板）。它是一个动态语言，可以不指定变量类型。它的特性是支持闭包，闭包的本质很简单，简单的说就是定义一个匿名作用域，这个作用域内部可以封装函数和变量，外部不可以访问这个作用域内部的东西，但是可以通过调用这个作用域来完成一些任务。
-Kotlin
-Kotlin 则是 Java 的优化版，在解决 Kotlin 很多痛点的情况下，不引入过多的新概念。它具有强大的类型推断系统，使得语言有良好的动态性，其次是其语言招牌 —— 语法糖，Kotlin 的代码可以写的非常简洁。这使得 Kotlin 不仅做为常规编程语言能大放异彩，作为脚本语言也深受很多开发者喜爱。
+
+Groovy是一种基于 JVM 的面向对象的编程语言，它可以作为常规编程语言，但主要是作为脚本的语言（为了解决 Java 在写脚本时过于死板）。      
+
+它是一个动态语言，可以不指定变量类型。它的特性是支持闭包，闭包的本质很简单，简单的说就是定义一个匿名作用域，这个作用域内部可以封装函数和变量，外部不可以访问这个作用域内部的东西，但是可以通过调用这个作用域来完成一些任务。
+     
+Kotlin则是Java的优化版，在解决Kotlin很多痛点的情况下，不引入过多的新概念。它具有强大的类型推断系统，使得语言有良好的动态性，其次是其语言招牌 —— 语法糖，Kotlin 的代码可以写的非常简洁。这使得 Kotlin 不仅做为常规编程语言能大放异彩，作为脚本语言也深受很多开发者喜爱。
+
 它们共同特点就是基于JVM，可以和 Java 互操作。Gradle 能提供的东西， Kotlin 也能通过提供（闭包）。在功能上，两者能做的事情都是一样的。此外一些简单的差异有：
 
-groovy 字符串可以使用单引号，而 kotlin 则必须为双引号
-groovy 在方法调用时可以省略扩号，而 kotlin 不可省略
-groovy 分配属性时可以省略 = 赋值运算符，而 kotlin 不可省略
+groovy 字符串可以使用单引号，而 kotlin 则必须为双引号。    
+groovy 在方法调用时可以省略扩号，而 kotlin 不可省略。    
+groovy 分配属性时可以省略 = 赋值运算符，而 kotlin 不可省略。   
 groovy 是动态语言，不用导包，而 kotlin 则需要。
 
 
 
-为什么要用Kotlin DSL写gradle脚本
+为什么要用Kotlin DSL写gradle脚本?     
+
 撇开其他方面，就单从提高程序员生产效率方面就有很多优点：
 
-脚本代码自动补全
-跳转查看源码
-动态显示注释
-支持重构(Refactoring)
+- 脚本代码自动补全
+- 跳转查看源码
+- 动态显示注释
+- 支持重构(Refactoring)
 …
 怎么样，要是你经历过groovy那令人蛋疼的体验，kotlin会让你爽的起飞，接下来让我们开始吧。
 
 从Groovy到Kotlin
+
 让我们使用Android Studio 新建一个Android项目，AS默认会为我们生成3个gradle脚本文件。
 
-settings.gradle (属于 project)
-build.gradle (属于 project)
-build.gradle (属于 module)
+- settings.gradle (属于 project)
+- build.gradle (属于 project)
+- build.gradle (属于 module)
+
 我们的目的就是转换这3个文件
 
-第一步: 修改groovy语法到严格格式
+- 第一步: 修改groovy语法到严格格式
+
 groovy既支持双引号""也支持单引号''，而kotlin只支持双引号，所以首先将所有的单引号改为双引号。
 
 例如 include ':app' -> include ":app"
 
 groovy方法调用可以不使用() 但是kotlin方法调用必须使用(),所以将所有方法调用改为()方式。
 
-例如
+例如:     
 
+```java
 implementation "androidx.appcompat:appcompat:1.0.2"
 改为
 
  implementation ("androidx.appcompat:appcompat:1.0.2")
 groovy 属性赋值可以不使用=，但是kotlin属性赋值需要使用=，所以将所有属性赋值添加=。
+```
 
-例如
-
+例如:     
+```
 applicationId "com.ss007.gradlewithkotlin"
 改为
 
 applicationId = "com.ss007.gradlewithkotlin"
+```
+
 完成以上几步，准备工作就完成了。
 
 
diff --git "a/JavaKnowledge/HashMap\345\256\236\347\216\260\345\216\237\347\220\206\345\210\206\346\236\220.md" "b/JavaKnowledge/HashMap\345\256\236\347\216\260\345\216\237\347\220\206\345\210\206\346\236\220.md"
index a5192325..02f9c51c 100644
--- "a/JavaKnowledge/HashMap\345\256\236\347\216\260\345\216\237\347\220\206\345\210\206\346\236\220.md"
+++ "b/JavaKnowledge/HashMap\345\256\236\347\216\260\345\216\237\347\220\206\345\210\206\346\236\220.md"
@@ -49,10 +49,20 @@ HashMap是无序的，因为HashMap无法保证内部存储的键值对的有序
 获取对象时，我们将K传给get()方法，它调用hashCode()计算hash从而得到bucket位置，并进一步调用equals()方法确定键值对。
 
 扩容前后，哈希桶的长度一定会是2的次方。这样在根据key的hash值寻找对应的哈希桶时，可以用位运算替代取余操作，更加高效。
+
 而key的hash值，并不仅仅只是key对象的hashCode()方法的返回值，还会经过扰动函数的扰动，以使hash值更加均衡。
-因为hashCode()是int类型，取值范围是40多亿，只要哈希函数映射的比较均匀松散，碰撞几率是很小的。 但就算原本的hashCode()取的很好，每个key的hashCode()不同，但是由于HashMap的哈希桶的长度远比hash取值范围小，默认是16，所以当对hash值以桶的长度取余，以找到存放该key的桶的下标时，由于取余是通过与操作完成的，会忽略hash值的高位。因此只有hashCode()的低位参加运算，
-发生不同的hash值，但是得到的index相同的情况的几率会大大增加，这种情况称之为hash碰撞。即碰撞率会增大。
-扰动函数就是为了解决hash碰撞的。它会综合hash值高位和低位的特征，并存放在低位，因此在与运算时，相当于高低位一起参与了运算，以减少hash碰撞的概率。（在JDK8之前，扰动函数会扰动四次，JDK8简化了这个操作）扩容操作时，会new一个新的Node数组作为哈希桶，然后将原哈希表中的所有数据(Node节点)移动到新的哈希桶中，相当于对原哈希表中所有的数据重新做了一个put操作。所以性能消耗很大，可想而知，在哈希表的容量越大时，性能消耗越明显。扩容时，如果发生过哈希碰撞，节点数小于8个。则要根据链表上每个节点的哈希值，依次放入新哈希桶对应下标位置。因为扩容是容量翻倍，所以原链表上的每个节点，现在可能存放在原来的下标，即low位， 或者扩容后的下标，即high位。 high位= low位+原哈希桶容量如果追加节点后，链表数量 >=8，且只有数组长度大于64才处理，则转化为红黑树由迭代器的实现可以看出，遍历HashMap时，
+
+因为hashCode()是int类型，取值范围是40多亿，只要哈希函数映射的比较均匀松散，碰撞几率是很小的。      
+
+但就算原本的hashCode()取的很好，每个key的hashCode()不同，但是由于HashMap的哈希桶的长度远比hash取值范围小，默认是16，所以当对hash值以桶的长度取余，以找到存放该key的桶的下标时，由于取余是通过与操作完成的，会忽略hash值的高位。      
+
+因此只有hashCode()的低位参加运算，发生不同的hash值，但是得到的index相同的情况的几率会大大增加，这种情况称之为hash碰撞。即碰撞率会增大。
+
+扰动函数就是为了解决hash碰撞的。它会综合hash值高位和低位的特征，并存放在低位，因此在与运算时，相当于高低位一起参与了运算，以减少hash碰撞的概率。（在JDK8之前，扰动函数会扰动四次，JDK8简化了这个操作）扩容操作时，会new一个新的Node数组作为哈希桶，然后将原哈希表中的所有数据(Node节点)移动到新的哈希桶中，相当于对原哈希表中所有的数据重新做了一个put操作。所以性能消耗很大，可想而知，在哈希表的容量越大时，性能消耗越明显。       
+
+扩容时，如果发生过哈希碰撞，节点数小于8个。则要根据链表上每个节点的哈希值，依次放入新哈希桶对应下标位置。因为扩容是容量翻倍，所以原链表上的每个节点，现在可能存放在原来的下标，即low位， 或者扩容后的下标，即high位。     
+
+high位= low位+原哈希桶容量,如果追加节点后，链表数量>=8，且只有数组长度大于64才处理，则转化为红黑树由迭代器的实现可以看出，遍历HashMap时，
 顺序是按照哈希桶从低到高，链表从前往后，依次遍历的。
 
 数组的特点：查询效率高，插入删除效率低。
@@ -70,7 +80,7 @@ HashMap在JDK1.8中发生了改变，下面的部分是基于JDK1.7的分析。H
 ```java
 transient Entry[] table;
 ```
-可以看到Map是通过数组的方式来储存Entry那Entry是神马呢？就是HashMap存储数据所用的类，它拥有的属性如下:   
+可以看到Map是通过数组的方式来储存Entry,那Entry是神马呢？就是HashMap存储数据所用的类，它拥有的属性如下:   
 ```java
 static class Entry implements Map.Entry {
     final K key;
@@ -177,12 +187,11 @@ public V get(Object key) {
 
 ## JDK1.8
 
-在Jdk1.8中HashMap的实现方式做了一些改变，但是基本思想还是没有变的，只是在一些地方做了优化，下面来看一下这些改变的地方,
-数据结构的存储由数组+链表的方式，变化为数组+链表+红黑树的存储方式，当链表长度超过阈值（8）时,且只有数组长度大于64才处理，将链表转换为红黑树。
-利用红黑树快速增删改查的特点来提高HashMap的性能，其中会用到红黑树的插入、删除、查找等算法。HashMap中，
-如果key经过hash算法得出的数组索引位置全部不相同，即Hash算法非常好，那样的话，getKey方法的时间复杂度就是O(1)，
-如果Hash算法技术的结果碰撞非常多，假如Hash算法极其差，所有的Hash算法结果得出的索引位置一样，那样所有的键值对都集中到一个桶中，
-或者在一个链表中，或者在一个红黑树中，时间复杂度分别为O(n)和O(lgn)。
+在Jdk1.8中HashMap的实现方式做了一些改变，但是基本思想还是没有变的，只是在一些地方做了优化，下面来看一下这些改变的地方,数据结构的存储由数组+链表的方式，变化为数组+链表+红黑树的存储方式，当链表长度超过阈值（8）时,且只有数组长度大于64才处理，将链表转换为红黑树。     
+
+利用红黑树快速增删改查的特点来提高HashMap的性能，其中会用到红黑树的插入、删除、查找等算法。     
+
+HashMap中，如果key经过hash算法得出的数组索引位置全部不相同，即Hash算法非常好，那样的话，getKey方法的时间复杂度就是O(1)，如果Hash算法技术的结果碰撞非常多，假如Hash算法极其差，所有的Hash算法结果得出的索引位置一样，那样所有的键值对都集中到一个桶中，或者在一个链表中，或者在一个红黑树中，时间复杂度分别为O(n)和O(lgn)。
 
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/hashmap_data_structure.jpg)
 
diff --git "a/VideoDevelopment/OpenCV/1.OpenCV\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenCV/1.OpenCV\347\256\200\344\273\213.md"
index 0a7a5eb1..f9dd0282 100644
--- "a/VideoDevelopment/OpenCV/1.OpenCV\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenCV/1.OpenCV\347\256\200\344\273\213.md"
@@ -127,7 +127,7 @@ copyTo()。
 在早期的OpenCV1.x 版本中，图像的处理是通过IplImage（该名称源于Intel 的另一个
 开源库Intel Image Processing Library ，缩写成IplImage）结构来实现的。
 
-早期的OpenCV 是用C 语言编写，因此提供的借口也是C 语言接口，其源代码完全是C
+早期的OpenCV 是用C 语言编写，因此提供的接口也是C 语言接口，其源代码完全是C
 的编程风格。IplImage 结构是OpenCV 矩阵运算的基本数据结构。
 
 到OpenCV2.x 版本，OpenCV 开源库引入了面向对象编程思想，大量源代码用C++重写。
diff --git "a/VideoDevelopment/OpenGL/15.\347\276\216\351\242\234\346\273\244\351\225\234.md" "b/VideoDevelopment/OpenGL/15.\347\276\216\351\242\234\346\273\244\351\225\234.md"
new file mode 100644
index 00000000..043db19f
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/15.\347\276\216\351\242\234\346\273\244\351\225\234.md"
@@ -0,0 +1,43 @@
+美颜滤镜
+---
+
+美颜的基本原理就是深度学习加计算机图形学。    
+
+- 深度学习用来人脸检测和人脸关键点检测。    
+- 计算机图形学用来磨皮、瘦脸和化妆容。   
+- 一般在Android上使用OpenGL ES，iOS使用Metal。   
+
+## 美颜算法的原理
+
+
+美颜算法主要是基于图像处理技术，包括人脸检测、皮肤平滑、肤色调整、瘦脸大眼瞪。     
+其中，人脸检测是美颜的第一步，通过算法识别出照片中的人脸区域，然后针对该区域进行后续的美化处理。   
+
+### 关键技术点
+
+- 人脸检测：利用OpenCV(强大的计算机视觉库，支持人脸检测等)、Dlib等库实现。 
+- 皮肤平滑：通过高斯模糊、双边滤波等技术减少皮肤瑕疵。    
+- 肤色调整：调整肤色饱和度、亮度等，使肤色更加自然。
+- 瘦脸大眼：基于人脸关键点定位，通过变形算法实现。   
+
+
+
+### 人脸检测
+
+- 人脸检测指的是对图片或者视频流中的人脸进行检测，并定位到图片中的人脸。   
+- 人脸关键点检测是对人脸中五官和脸的轮廓进行关键点定位，一般情况下它紧接在人脸检测后。    
+
+
+- 加载OpenCV库，在项目中集成OpenCV库，并加载本地人脸检测模型。 
+- 实时处理：在相机预览的回调中，对每一帧图像进行人脸检测，并应用美颜算法。  
+
+
+
+
+
+https://zhuanlan.zhihu.com/p/163604590
+
+
+
+
+
diff --git "a/VideoDevelopment/OpenGL/16.\350\211\262\346\270\251\343\200\201\350\211\262\350\260\203\343\200\201\351\245\261\345\222\214\345\272\246.md" "b/VideoDevelopment/OpenGL/16.\350\211\262\346\270\251\343\200\201\350\211\262\350\260\203\343\200\201\351\245\261\345\222\214\345\272\246.md"
new file mode 100644
index 00000000..8dff2153
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/16.\350\211\262\346\270\251\343\200\201\350\211\262\350\260\203\343\200\201\351\245\261\345\222\214\345\272\246.md"
@@ -0,0 +1,74 @@
+
+- 色温: 图片的色温指的是图片中呈现出来的整体颜色偏暖或偏冷的程度。    
+
+色温可以影响图像的分为和情感表达。简单理解就是色彩的温度，越低越冷如蓝色，越高越暖如红色。 
+
+- 色调: 色调是指图片色彩的整体质感，包括主要色调的选择和组合。    
+
+通过调整色调，可以改变图像的整体色彩效果，营造特定的视觉风格或情绪。简单理解就是色彩倾向，倾向于红橙还是黄绿。    
+
+- 亮度: 亮度描述了图片中各个部分的明暗程度。增加亮度将使整体图像看起来更明亮，减小亮度则会使图片变得更暗。     
+
+亮度的调整可以影响图像的整体视觉效果和光线感。   
+增加就是给图片所有色彩增加白色，减少黑色。注意是只加黑白两种颜色，不然容易跟纯度弄混。   
+
+- 对比度: 对比度是描述图像中不同区域之间亮度差异的程度。    
+
+提高对比度会使图像中的明暗部分更加突出，增强图像的清晰度和视觉冲击力。   
+适当的对比度可以让图像更具有立体感和层次感。    
+增加就是让白的更白，黑的更黑。减少就是白的不那么白，黑的不那么黑。   
+
+- 饱和度: 饱和度表示图片中颜色的纯度和鲜艳程度。    
+
+增加饱和度会使颜色更加丰富饱满，减少饱和度会使颜色变得更加灰暗。     
+调整饱和度可以改变图像的整体色彩和视觉吸引力。     
+
+简单理解就是增加图片各种颜色的纯度。
+比如蓝色，增加纯度就是在蓝色上加蓝色，降低纯度就是键入蓝色的对比色，让它变灰色或黑色。  
+
+- 高光: 高光是指图片中最亮的部分，通常实在光线照射下产生的明亮区域。    
+
+调整高光可以改变图像中亮部的强度和反射效果，从而影响图像的细节和光影效果。   
+增加就是给图片白色的部分再加点白色，减少就是减少点白色。  
+
+
+
+
+
+### RGB颜色模型
+
+RGB颜色模型是一种用于创建各种颜色的方法，它基于红色、绿色、蓝色三种颜色的组合。    
+
+通过调节这三种颜色的强度和比例，可以生成多种不同的颜色。 
+
+### HSV颜色模型
+
+HSV代表色相(Hue)、饱和度(Saturation)、明度(Value)，或色相(Hue)、饱和度(Saturation)、亮度(Brightness)。   
+
+在HSV模型中，色相同样表示颜色本身，饱和度表示颜色的纯度或浓淡程度，而明度或亮度则表示颜色的亮度程度。     
+
+HSV模型有时也被称为HSB(色相、饱和度、亮度)模型。  
+
+
+HSV（HSB）颜色模型根据下图对应说明可以得知：
+
+- H(Hue)：色调,用角度度量,取值范围为0°～360° ,从红色开始按逆时针方向计算
+- S(Saturation)：饱和度,表示颜色接近光谱色的程度.一种颜色,可以看成是某种光谱色不白色混合的结果.通常取值范围为0%～100%,值越大,颜色越饱和.光谱色的白光成分为0,饱和度达到最高.
+- V(Value或Brightness)：明度,表示颜色明亮的程度.
+
+
+
+### HSL颜色模型
+
+HSL代表色相(Hue)、饱和度(Stauration)、亮度(Lightness)。   
+
+在HSL模型中，色相表示颜色本身，饱和度表示颜色纯度或浓淡程度，亮度则表示颜色的明暗程度。   
+
+- H: 色相，使用不水平轴之间的角度来表示，范围是从(0 ~ 360)度。从蓝色开始。   
+- S: 饱和度，说明颜色的相对浓度。     
+- L: 亮度，在L=0处为黑色，在L=1处为白色。灰色沿着L轴分布。   
+
+
+
+
+

From a782cd797f46c5a4826445c37dc04097499e9243 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Tue, 11 Feb 2025 15:51:04 +0800
Subject: [PATCH 200/213] add notes

---
 ...36\346\224\266\346\234\272\345\210\266.md" |  38 +++-
 ...14Synchronized\345\214\272\345\210\253.md" |   6 +
 ...01\350\231\232\345\274\225\347\224\250.md" |  15 ++
 .../1.OpenGL\347\256\200\344\273\213.md"      |  74 +++++++-
 VideoDevelopment/OpenGL/12.FBO.md             | 165 ++++++++++++++++
 ....GLSurfaceView\347\256\200\344\273\213.md" |  11 +-
 ...66\344\270\211\350\247\222\345\275\242.md" |   4 +
 ...45\231\250\350\257\255\350\250\200GLSL.md" |  16 +-
 ...\261\273\345\217\212Matrix\347\261\273.md" | 176 +++++++++++++++++-
 .../9.OpenGL ES\347\272\271\347\220\206.md"   |  71 ++++++-
 ...26\347\240\201\346\240\274\345\274\217.md" |   5 +
 11 files changed, 562 insertions(+), 19 deletions(-)

diff --git "a/JavaKnowledge/JVM\345\236\203\345\234\276\345\233\236\346\224\266\346\234\272\345\210\266.md" "b/JavaKnowledge/JVM\345\236\203\345\234\276\345\233\236\346\224\266\346\234\272\345\210\266.md"
index 7c964b63..6e1a10a4 100644
--- "a/JavaKnowledge/JVM\345\236\203\345\234\276\345\233\236\346\224\266\346\234\272\345\210\266.md"
+++ "b/JavaKnowledge/JVM\345\236\203\345\234\276\345\233\236\346\224\266\346\234\272\345\210\266.md"
@@ -1,5 +1,41 @@
 # JVM垃圾回收机制
 
+
+当前主流的商用程序语言(Java、C#)的内存管理子系统都是通过可达性分析(Reachability Analysis)算法来判定对象是否存活的。      
+
+这个算法的基本思路就是通过一系列被称为"GC Roots"的根对象作为起始节点集，从这些节点开始，根据引用关系向下搜索，搜索过程所做过的路径称为"引用链"(Reference Chain)，
+如果某个对象到GC Roots间没有任何引用链相连，或者用图论的话来说就是从GC Roots到这个对象不可达时，则证明此对象是不可能再被使用的。  
+
+
+如下图:  对象object5、object6、object7虽然互有关联，但是它们到GC Roots是不可达的，因此它们将会被判定为可回收的对象。   
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/reachability_analysis.png)
+
+
+在Java技术体系里面，固定可作为GC Roots的对象包括以下几种:    
+
+- 在虚拟机栈(栈帧中的本地变量表)中引用的对象，譬如各个线程被调用的方法堆栈中使用到的参数、局部变量、临时变量等。   
+
+- 在方法区中类静态属性引用的对象，譬如Java类的引用类型静态变量。    
+
+- 在方法区中常量引用的对象，譬如字符串常量池(String Table)中的引用。   
+
+- 在本地方法栈中JNI(即通常所说的Native方法)引用的对象。    
+
+- Java虚拟机内部的引用，如基本数据类型对应的Class对象，一些常驻的异常对象(比如NullPointException、OutOfMemoryError)等，还有系统类加载器。   
+
+- 所有被同步锁(synchronized关键字)持有的对象。   
+
+- 反应Java虚拟机内部情况的JMXBean、JVMTI中注册的回调、本地代码缓存等。    
+
+
+除了这些固定的GC Roots集合以外，根据用户所选用的垃圾收集器以及当前回收的内存区域不同，还可以有其他对象“临时性”地加入，共同构成完整GC Roots集合。譬如后文将会提到的分代收集和局部回收(Partial GC)，如果只针对Java堆中某一块区域发起垃圾收集时（如最典型的只针对新生代的垃圾收集）​，必须考虑到内存区域是虚拟机自己的实现细节（在用户视角里任何内存区域都是不可见的）​，更不是孤立封闭的，所以某个区域里的对象完全有可能被位于堆中其他区域的对象所引用，这时候就需要将这些关联区域的对象也一并加入GC Roots集合中去，才能保证可达性分析的正确性。
+
+
+
+
+
 [Java内存模型](https://github.com/CharonChui/AndroidNote/blob/master/JavaKnowledge/Java%E5%86%85%E5%AD%98%E6%A8%A1%E5%9E%8B.md)如下图所示，**堆和方法区是所有线程共有的**，而虚拟机栈，本地方法栈和程序计数器则是线程私有的。
 
 ![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/jvm.png)
@@ -460,4 +496,4 @@ NUMA 是一种多核服务器的架构，简单来讲，一个多核服务器（
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
diff --git "a/JavaKnowledge/volatile\345\222\214Synchronized\345\214\272\345\210\253.md" "b/JavaKnowledge/volatile\345\222\214Synchronized\345\214\272\345\210\253.md"
index 82801018..8894decc 100644
--- "a/JavaKnowledge/volatile\345\222\214Synchronized\345\214\272\345\210\253.md"
+++ "b/JavaKnowledge/volatile\345\222\214Synchronized\345\214\272\345\210\253.md"
@@ -183,6 +183,12 @@ ctorInstance(memory);  //2.初始化对象
 
 指令重排序后，在多线程情况下，可能会发生A线程正在new对象，执行了3，但还没有执行2。此时B线程进入方法获取单例对象，执行同步代码块外的非空判断，发现变量非空，但此时对象还未初始化，B线程获取到的是一个未被初始化的对象。使用volatile修饰后，禁止指令重排序。即，先初始化对象后，再设置instance指向刚分配的内存地址。这样就就不存在获取到未被初始化的对象。
 
+
+
+那为何说它禁止指令重排序呢？从硬件架构上讲，指令重排序是指处理器采用了允许将多条指令不按程序规定的顺序分开发送给各个相应的电路单元进行处理。但并不是说指令任意重排，处理器必须能正确处理指令依赖情况保障程序能得出正确的执行结果。譬如指令1把地址A中的值加10，指令2把地址A中的值乘以2，指令3把地址B中的值减去3，这时指令1和指令2是有依赖的，它们之间的顺序不能重排——(A+10)*2与A*2+10显然不相等，但指令3可以重排到指令1、2之前或者中间，只要保证处理器执行后面依赖到A、B值的操作时能获取正确的A和B值即可。所以在同一个处理器中，重排序过的代码看起来依然是有序的。因此，lock addl$0x0，(%esp)指令把修改同步到内存时，意味着所有之前的操作都已经执行完成，这样便形成了“指令重排序无法越过内存屏障”的效果。
+
+
+
 ## synchronized
 
 **synchronized实现同步的基础是：Java中的每个对象都可作为锁。所以synchronized锁的都对象，只不过不同形式下锁的对象不一样。**
diff --git "a/JavaKnowledge/\345\274\272\345\274\225\347\224\250\343\200\201\350\275\257\345\274\225\347\224\250\343\200\201\345\274\261\345\274\225\347\224\250\343\200\201\350\231\232\345\274\225\347\224\250.md" "b/JavaKnowledge/\345\274\272\345\274\225\347\224\250\343\200\201\350\275\257\345\274\225\347\224\250\343\200\201\345\274\261\345\274\225\347\224\250\343\200\201\350\231\232\345\274\225\347\224\250.md"
index 48d014de..c656ea7f 100644
--- "a/JavaKnowledge/\345\274\272\345\274\225\347\224\250\343\200\201\350\275\257\345\274\225\347\224\250\343\200\201\345\274\261\345\274\225\347\224\250\343\200\201\350\231\232\345\274\225\347\224\250.md"
+++ "b/JavaKnowledge/\345\274\272\345\274\225\347\224\250\343\200\201\350\275\257\345\274\225\347\224\250\343\200\201\345\274\261\345\274\225\347\224\250\343\200\201\350\231\232\345\274\225\347\224\250.md"
@@ -66,6 +66,21 @@
 
 ![](https://raw.githubusercontent.com/CharonChui/Pictures/master/reference_compare.jpg)
 
+
+无论是通过引用计数算法判断对象的引用数量，还是通过可达性分析算法判断对象是否引用链可达，判定对象是否存活都和“引用”离不开关系。在JDK 1.2版之前，Java里面的引用是很传统的定义：如果reference类型的数据中存储的数值代表的是另外一块内存的起始地址，就称该reference数据是代表某块内存、某个对象的引用。
+
+
+在JDK 1.2版之后，Java对引用的概念进行了扩充，将引用分为强引用(Strongly Re-ference)、软引用(Soft Reference)、弱引用(Weak Reference)和虚引用(Phantom Reference)4种，这4种引用强度依次逐渐减弱。
+
+
+- 强引用是最传统的“引用”的定义，是指在程序代码之中普遍存在的引用赋值，即类似“Object obj=new Object()”这种引用关系。无论任何情况下，只要强引用关系还存在，垃圾收集器就永远不会回收掉被引用的对象。
+
+- 软引用是用来描述一些还有用，但非必须的对象。只被软引用关联着的对象，在系统将要发生内存溢出异常前，会把这些对象列进回收范围之中进行第二次回收，如果这次回收还没有足够的内存，才会抛出内存溢出异常。在JDK 1.2版之后提供了SoftReference类来实现软引用。
+
+- 弱引用也是用来描述那些非必须对象，但是它的强度比软引用更弱一些，被弱引用关联的对象只能生存到下一次垃圾收集发生为止。当垃圾收集器开始工作，无论当前内存是否足够，都会回收掉只被弱引用关联的对象。在JDK 1.2版之后提供了WeakReference类来实现弱引用。
+
+- 虚引用也称为“幽灵引用”或者“幻影引用”，它是最弱的一种引用关系。一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来取得一个对象实例。为一个对象设置虚引用关联的唯一目的只是为了能在这个对象被收集器回收时收到一个系统通知。在JDK 1.2版之后提供了PhantomReference类来实现虚引用。
+
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
index a347c9e6..e84f18ce 100644
--- "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -43,6 +43,10 @@ OpenGL ES由OpenGL裁剪而来，因此有必要了解一下两者版本的对
 
 
 
+图像数据无非是一个个的像素点，对图像数据的处理无非是对每个像素点进行计算后重新赋值，一般来说对每个像素点的计算都比较独立，计算也相对简单。CPU虽然计算能力强大，但是并行处理能力有限，对一张720P的图片，一共包含720*1280=921600个像素，要进行这么多次运算，CPU也要望洋兴叹了。GPU与CPU相比最大的优势就是并行处理能力，一般移动端的GPU也要包含数千个处理单元，这些处理单元虽然计算能力比不上CPU，但是却可以同时处理几千个像素点。像素点数据的计算相对简单，而且可以同时处理几千个像素点，图像数据用GPU来做计算就非常适合了。而怎么使用GPU呢？这就要介绍到目前使用最广泛的2D、3D矢量图形沉浸API：OpenGL了。
+
+
+
 ### Android中的OpenGL ES
 
 Android中OpenGL ES的版本支持如下:  
@@ -69,8 +73,8 @@ OpenGL ES的实现有2中方式：
 
 - OpenGL自身是一个巨大的状态机: 描述该如何操作的所有变量的大集合
 - OpenGL的状态通常被称为上下文(Context)
-- 状态设置函数(State-changing Function)
-- 状态应用的函数(State-using Function)
+- 状态设置函数(State-changing Function): 该类函数将会改变上下文	
+- 状态应用的函数(State-using Function): 该类函数会根据当前OpenGL的状态执行一些操作。    
 
 ![image](https://github.com/CharonChui/Pictures/blob/master/opengl_state_machine.png?raw=true)
 
@@ -109,7 +113,21 @@ struct object_Window_Target {
 }
 ```
 
-通常把OpenGL上下文比作一个大的结构体，包含很多子集。  
+
+但是，这样也有问题:        
+
+- 当前状态只有一份，如果每次显示不同的效果，都重新配置会很麻烦。 
+- 这时候我们就需要一些小助理(对象)，来帮忙记录某些状态信息，以便复用。  
+
+如果我们有10种子集，那就需要10个小助理(对象)，而当前状态(Context，只有一份)可以通过装配这些对象来完成。 
+
+![image](https://github.com/CharonChui/Pictures/blob/master/opengl_zhuli.jpg?raw=true)
+
+
+通常把OpenGL上下文比作一个大的结构体，包含很多子集。
+
+在OpenGL中一个对象是指一些选项的集合，它代表OpenGL状态的一个子集。     
+比如，我们可以用一个对象来代表绘制窗口的设置，之后我们就可以设置它的大小等。      
 
 ```C
 // OpenGL的状态
@@ -120,20 +138,48 @@ struct OpenGL_Context {
 }
 ```
 
-但是，这样也有问题:        
 
-- 当前状态只有一份，如果每次显示不同的效果，都重新配置会很麻烦。 
-- 这时候我们就需要一些小助理(对象)，来帮忙记录某些状态信息，以便复用。  
 
-如果我们有10种子集，那就需要10个小助理(对象)，而当前状态(Context，只有一份)可以通过装配这些对象来完成。 
+```c++
+// 创建对象    
+unsigned int objectId = 0;
+glGenObject(1, &objectId);
 
-![image](https://github.com/CharonChui/Pictures/blob/master/opengl_zhuli.jpg?raw=true)
+// 绑定对象至上下文
+glBindObject(GL_WINDOW_TARGET, objectId);
+// 设置当前绑定到GL_WINDOW_TARGET的对象的一些选项
+glSetObjectOption(GL_WINDOW_TARGET, GL_OPTION_WINDOW_WIDTH, 800);
+glSetObjectOption(GL_WINDOW_TARGET, GL_OPTION_WINDOW_HEIGHT, 600);
+// 将上下文对象设回默认
+glBindObject(GL_WINDOW_TARGET, 0);
+```
+上面这一小段代码展示了以后使用OpenGL时常见的工作流。    
+
+- 我们首先创建一个对象，然后用一个id保存它的引用(实际数据被存储在后台)。     
+- 然后我们将对象绑定至上下文的目标位置(例子中窗口对象目标的位置被定义成GL_WINDOW_TARGET)     
+- 接下来我们设置窗口的选项。     
+- 最后我们将目标位置的对象id设回0，解绑这个对象。   
 
+**设置的选项将被保存在objectId所引用的对象中，一旦我们重新绑定这个对象到GL_WINDOW_TARGET位置，这些选项就会重新生效。**      
+
+使用对象的一个好处是在程序中，我们不止可以定义一个对象，并设置它们的选项，每个对象都可以是不同的设置。     
+
+在我们执行一个使用OpenGL状态的操作的时候，只需要绑定含有需要的设置的对象即可。       
 
 
 
 ###  渲染管线
 
+
+渲染管线有时也称为渲染流水线，一般由显示芯片(GPU)内部处理图形信号的并行处理单元组成。      
+这些并行处理单元两两之间是相互独立的，在不同型号的硬件上独立处理单元的数量也有很大的差异。一般越高端型号的硬件，其中独立处理单元的数量也就越多。   
+
+
+与普通应用程序通过CPU串行执行不同的是，渲染工作是通过渲染管线由多个相互独立的处理单元进行并行处理的，这种模式极大的提升了渲染效率。  
+
+从另一个角度看，OpenGLES中的渲染管线实际上指的是一系列绘制过程。   
+这些过程输入的是待渲染3D物体的相关描述信息数据，经过渲染管线，输出的是一帧想要的图像。      
+
 在OpenGL中，任何事物都在3D空间中，而屏幕和窗口却是2D像素数组，这导致OpenGL的大部分工作都是关于把3D坐标转变为适应你屏幕的2D像素。        
 
 3D坐标转为2D坐标的处理过程是由OpenGL的图形渲染管线（Graphics Pipeline，大多译为管线，实际上指的是一堆原始图形数据途经一个输送管道，期间经过各种变化处理最终出现在屏幕的过程）管理的。        
@@ -448,6 +494,16 @@ OpenGL中最基础且唯一的多边形就是三角形，所有更复杂的图
 
 ### 片段着色器或片元着色器(Fragment Shader)
 
+
+显示设备屏幕都是离散化的(由一个一个的像素组成)，因此还需要将投影的结果离散化。    
+将其分解为一个个离散化的小单元，这些小单元一版称为片元。    
+
+其实每个片元都对应于帧缓冲中的一个像素，之所以不直接称为像素是因为3D空间中的物体是可以相互遮挡的。而一个3D场景最终显示到屏幕上虽然是一个整体，但每个3D物体的每个图元是独立处理的。这就可能出现这样的情况，系统先处理的是位于离观察点较远的图元，其光栅化成为了一组图元，暂时送入帧缓冲的对应位置。    
+
+但后面继续处理离观察点较近的图元时也光栅化出了一组片元，两组片元中有对应到帧缓冲中同一个位置的，这时距离近的片元将覆盖距离远的片元(如何覆盖的检测是在深度检测阶段完成的)。      
+
+因此，某片元就不一定能成为最终屏幕上的像素，称为像素就不准确了，可以将其理解为候选像素。    
+
 使用颜色或纹理(texture)渲染图形表面的OpenGLES代码。
 
 
@@ -606,7 +662,7 @@ EGL为双缓冲工作模式(Double Buffer)，既有一个Back Frame Buffer和一
 
 6. 设置OpenGL的渲染环境
 
-   eglMakeCurrent(EGLDisplay display, EGLSurface draw, EGLSurface read, EGLContext context);该方法的参数意义很明确，该方法在异步线程中被调用，该线程也会被成为GL线程，一旦设定后，所有OpenGL渲染相关的操作都必须放在该线程中执行。
+   eglMakeCurrent(EGLDisplay display, EGLSurface draw, EGLSurface read, EGLContext context);该方法的参数意义很明确，该方法在异步线程中被调用，该线程也会被称为GL线程，一旦设定后，所有OpenGL渲染相关的操作都必须放在该线程中执行。
 
 通过上述操作，就完成了EGL的初始化设置，便可以进行OpenGL的渲染操作。所有EGL命令都是以egl前缀开始，对组成命令名的每个单词使用首字母大写(如eglCreateWindowSurface)。
 
diff --git a/VideoDevelopment/OpenGL/12.FBO.md b/VideoDevelopment/OpenGL/12.FBO.md
index 736c7f9c..dcbb6993 100644
--- a/VideoDevelopment/OpenGL/12.FBO.md
+++ b/VideoDevelopment/OpenGL/12.FBO.md
@@ -1,14 +1,107 @@
 ## 12.FBO
 
+
+什么是 EGL
+
+EGL 是 OpenGL ES 和本地窗口系统（Native Window System）之间的通信接口，它的主要作用：
+与设备的原生窗口系统通信；
+
+查询绘图表面的可用类型和配置；
+
+创建绘图表面；
+
+在OpenGL ES 和其他图形渲染API之间同步渲染；
+
+管理纹理贴图等渲染资源。
+
+OpenGL ES 的平台无关性正是借助 EGL 实现的，EGL 屏蔽了不同平台的差异（Apple 提供了自己的 EGL API 的 iOS 实现，自称 EAGL）。
+
+本地窗口相关的 API 提供了访问本地窗口系统的接口，而 EGL 可以创建渲染表面 EGLSurface ，同时提供了图形渲染上下文 EGLContext，用来进行状态管理
+
+
+当前屏幕渲染(onscreen rendering)和离屏渲染(offscreen rendering) 默认的测试其实就是onscreen rendering，顾名思义，渲染的场景是需要呈现在屏幕上眼睛可见的，而offscreen则是不需要呈现的。 当前屏幕渲染绘制流程是:    ``` eglCreateXXXSurface eglCreateContext Draw eglSwapbuffers ``` 离屏渲染流程则是:    ``` glGenFramebuffers glBindFramebuffer
+glFramebufferTexture2D/glFramebufferRenderbuffer
+
+Draw
+
+glFlush (or internal flush)
+```
+
+
+我们知道eglSwapbuffer是为了把EGL当前渲染的surface给呈现到屏幕上，glFlush是为了把GLES当前渲染的结果绘制到和FBO绑定的Texture或者Render Buffer里面。所以简单的说，onscreen rendering是EGL surface的渲染，而offscreen rendering是GLES FBO的渲染。
+
+
+
+当然并不是所有的EGL surface都是onscreen的，一个例外就是EGL pbuffer surface，这是EGL为了offscreen rendering专门定制的。
+
+
+
+### Onscreen和Offscreen的关系
+
+
+
+那么问题来了，这两者到底有什么关系呢？
+
+下图是一个benchmark某一帧的流程图，
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/onscreen_offscreen.webp?raw=true)
+
+
+
+图中的FBO0是最终的屏幕渲染输出，而其他用于离屏渲染的FBO都是为了叠加最后的Blur效果和提供背景模版。通常对于复杂的场景，最终的onscreen rendering是由众多的offscreen rendering的结果组合而成的。
+
+Offscreen有什么好处吗
+
+
+
+Onscreen rendering的一个限制因素是当前屏幕的分辨率，比如显示器最多只支持1080p，那么EGL surface大小最大只能是1080p。而offscreen rendering则宽松多了，它只受GPU硬件本身的限制，通常可以支持4K分辨率。所以如果需要不同于当前屏幕分辨率的渲染，反锯齿或者添加新的renderpass，通常会先渲染到offscreen来获取更好的渲染效果。
+
+
+
+因为offscreen是不可见的，GPU可能会有一定的优化。举个例子，原点(0, 0)对于DirectX来讲，通常在左上角，而对于OpenGLES则在左下角。如果GPU是为DirectX设计的，GPU默认的(0, 0)当然是左上角，那么对于OpenGLES的onscreen rendering，就需要做一个Y坐标的翻转，让原点从左下角映射到左上角。然而对于offscreen rendering，GPU就可以默认其原点在左上角，从而避免坐标转换的损耗。
+
+
+
+
+
 FBO（Frame Buffer Object）即帧缓冲区对象，实际上是一个可添加缓冲区的容器，可以为其添加纹理或渲染缓冲区对象（RBO）。
 
+
+顾名思义，它就是能缓存一帧的这么个东西，它有什么用呢？     
+
+大家回想我们之前的教程，我们都是通过一次渲染把内容渲染到屏幕(严格来说是渲染到GLSurfaceview上)。      
+如果我们的渲染由多个步骤组成，而每个步骤的渲染结果会给到下一个步骤作为输入，那么就要用到frame buffer。      
+
+比如一个效果：先把图片的蓝色通道全都设置为0.5，得到的结果再去做一个水平方向的模糊，这时渲染过程就由2步组成，第一步的操作不应该显示到屏幕上，应该有个地方存着它的结果，作为第二步的输入，然后第二步的渲染结果才直接显示到屏幕上。实际上这两步可以合成一步，大家可以思考一下如何用一步实现，这里分成两步主要是为了展示如果使用frame buffer。
+
+
+FBO从名字上看，往往很容易让人误解这是一个缓存空间，但实际上，FBO很重要的在后面的Object上。    
+
+这是一个缓存对象，包含了多个缓冲索引，分别是颜色缓冲(Color buffers)、深度缓冲(Depth buffer)、模板缓冲(Stencil buffer)。之所以说是缓冲索引，是因为FBO并不包含这些缓冲数据，仅仅保存了缓冲数据的索引地址。    
+
+FBO和这些缓冲区则通过附着点进行连接。     
+
+frame buffer本身其实并不会存储数据，都是通过attachment去绑定别的东西来存储相应的数据，我们今天要讲的就是color attachment，我们会将frame buffer中的一个attachment绑定到一个texture上，然后先将第一步的效果渲染到这个frame buffer上作为中间结果，然后将这个texture作为第二步的输入。
+
+
 FBO本身不能用于渲染，只有添加了纹理或者渲染缓冲区之后才能作为渲染目标，它仅且提供了3种附着（Attachment），分别是颜色附着、深度附着和模板附着。
 
+只有color buffer用于最后的像素显示，其他的都是用来辅助fragment的处理。
+
+
 RBO（Render Buffer Object）即渲染缓冲区对象，是一个由应用程序分配的2D图像缓冲区。渲染缓冲区可以用于分配和存储颜色、深度或者模板值，可以用作FBO中的颜色、深度或者模板附着。
 
 使用FBO作为渲染目标时，首先需要为FBO的附着添加连接对象，如颜色附着需要连接纹理或者渲染缓冲区对象的颜色缓冲区。
 
 
+FBO可以绑定到纹理对象或者RenderBuffer对象，RenderBuffer是以内部格式存储的经过渲染优化的对象，它的渲染速度更快，缺点是无法对渲染进果进行重采样。如果不需要对FBO的输出再做下一步采样处理，就可以用RenderBuffer。在我们的例子中，因为我们要暂存相机流处理着色器的渲染结果，并作为灰度黑着色器程序的输入，即要对此输出结果进行采样，所以我们必须要用FBO绑定纹理对象的方式。
+
+
+GLSurfaceView的onDrawFrame回调中，默认是绑定了window系统生成的FBO的，这个FBO对应屏幕显示，即0号FBO。只要我们中间不切换FBO，所有的glDrawArray或glDrawElements指令调用都是将目标渲染到这个0号FBO的。
+
+
+
+
 #### 为什么用 FBO
 
 默认情况下，OpenGL ES通过绘制到窗口系统提供的帧缓冲区，然后将帧缓冲区的对应区域复制到纹理来实现渲染到纹理，但是此方法只有在纹理尺寸小于或等于帧缓冲区尺寸才有效。       
@@ -20,6 +113,78 @@ Android OpenGL ES开发中，一般使用GLSurfaceView将绘制结果显示到
 使用FBO可以让渲染操作不用再渲染到屏幕上，而是渲染到离屏Buffer中，然后可以使用glReadPixels或者HardwareBuffer将渲染后的图像数据读出来，从而实现在后台利用GPU完成对图像的处理。
 
 
+在OpenGL ES中，调用: 
+```java
+GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0);
+```
+表示将当前的帧缓冲绑定切换回默认帧缓冲，即屏幕帧缓冲。这意味着后续的绘图操作将直接渲染到屏幕，而不是一个自定义的 FrameBuffer Object (FBO)。
+
+1. 默认帧缓冲
+	•	默认帧缓冲由 OpenGL 创建，并与窗口系统关联。
+	•	默认帧缓冲的内容直接显示在屏幕上。
+	•	调用 glBindFramebuffer 将目标设置为 0 时：
+	•	GL_FRAMEBUFFER 绑定到默认的屏幕渲染目标。
+
+2. 切换渲染目标
+
+在 OpenGL 中，你可以使用自定义的帧缓冲对象（FBO）来进行离屏渲染，例如将渲染结果存储到纹理或处理后的数据中。当你完成对自定义 FBO 的渲染任务后，通常需要将绑定切换回默认帧缓冲，这样后续的渲染操作会直接绘制到屏幕。
+
+3. 操作流程
+
+通常操作流程如下：
+	1.	创建并绑定 FBO，进行离屏渲染。
+	2.	渲染完成后，解绑 FBO，将绘图切换回屏幕。
+	3.	渲染其他内容或将离屏渲染的结果作为纹理在屏幕上显示。
+
+示例代码：
+
+```java
+// 绑定自定义 FBO，进行离屏渲染
+GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, customFbo);
+renderToTexture();
+
+// 解绑 FBO，切换回屏幕渲染
+GLES20.glBindFramebuffer(GLES20.GL_FRAMEBUFFER, 0);
+renderToScreen();
+```
+
+ 解除FBO绑定，将窗口大小、纹理坐标、矩阵都恢复回原来的配置。
+将渲染重新切换到原来的系统窗口上，画面将重新显示到系统窗口上。
+
+
+作用场景
+
+1. 屏幕显示
+
+完成离屏渲染后，使用默认帧缓冲可以将最终结果显示到屏幕上。
+
+2. 渲染链切换
+
+当使用多个渲染目标（如多个 FBO）时，通过解绑 FBO，可以轻松地切换回屏幕渲染或默认的绘图目标。
+
+3. 调试和测试
+
+解绑 FBO 也方便直接在屏幕上观察渲染结果，便于调试。
+
+
+
+
+首先，Fbo 的概念性的东西，大家可以上网查查，这里就直接说说Fbo的作用
+
+Oes纹理转换2D纹理
+
+预览相机、播放视频等这些通过SurfaceTexture方式渲染的，一般都是使用Oes纹理，而当需要在相机预览或者播放视频中添加水印/贴纸，则需要先将Oes纹理转化成2D纹理，因为Oes纹理和2D纹理是不能同时使用
+
+保留帧
+
+让当前渲染的纹理保留在一个帧缓存里，而不显示在屏幕上
+
+
+
+
+
+
+
 
 ---
 - [上一篇: 11.OpenGL ES滤镜](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/11.OpenGL%20ES%E6%BB%A4%E9%95%9C.md)
diff --git "a/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
index be25becb..0647b7ea 100644
--- "a/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/2.GLSurfaceView\347\256\200\344\273\213.md"
@@ -40,7 +40,12 @@ GLSurfaceView继承自SurfaceView，它主要是在SurfaceView的基础上加入
 
 GLSurfaceView.Renderer接口要求您实现以下方法:     
 - onSurfaceCreated():系统会在创建GLSurface时调用一次此方法。使用此方法可执行仅需发生一次的操作，例如设置OpenGL环境参数或初始化OpenGL图形对象。          
-- onDrawFrame():完成绘制工作，每一帧图像的渲染都要在这里完成，系统会在每次重新绘制GLSurfaceView时调用此方法。请将此方法作为绘制（和重新绘制）图形对象的主要执行点。
+在GLSurfaceView attach到父View后，此方法会被调用。    
+
+- onDrawFrame(): 完成绘制工作，每一帧图像的渲染都要在这里完成，系统会在每次重新绘制GLSurfaceView时调用此方法。请将此方法作为绘制（和重新绘制）图形对象的主要执行点。
+
+在任意时间调用GLSurfaceView的requestRender()方法后，GLSurfaceView会优先执行已保存在GL线程队列中的Runnable,然后调用此onDrawFrame()方法渲染图像。GL线程队列中的所有Runnable和onDrawFrame()方法的调用都执行在GL线程中。   
+
 - onSurfaceChanged():系统会在GLSurfaceView几何图形发生变化（包括GLSurfaceView大小发生变化或设备屏幕方向发生变化）时调用此方法。例如，系统会在设备屏幕方向由纵向变为横向时调用此方法。使用此方法可响应GLSurfaceView容器中的更改。          
 
 使用GLSurfaceView和GLSurfaceView.Renderer为OpenGL ES建立容器视图后，您便可以开始使用以下类调用 OpenGL API：
@@ -69,7 +74,7 @@ GLSurfaceView的特性:
 - 管理一个surface，这个surface就是一块特殊的内存，能直接排版到android的视图view上。
 - 管理一个EGL Display，它能让OpenGL把内容渲染到surface上
 - 用户自定义渲染器render
-- 让渲染器在独立的变成里运作(与UI线程分离)
+- 让渲染器在独立的线程里运作(与UI线程分离)
 - 支持按需渲染(on-demand)和连续渲染(continuous)
 - 可以封装、跟踪并且排查渲染器的问题
 
@@ -191,7 +196,7 @@ GLSurfaceView默认采用的是RENDERMODE_CONTINUOUSLY连续渲染的方式，
 
 说到GLSurfaceView就一定要提一下SurfaceTexture。
 
-和SurfaceView功能类似，区别是，SurfaceTexure可以不显示在界面中。使用OpenGl对图片流进行美化，添加水印，滤镜这些操作的时候我们都是通过SurfaceTexre去处理，处理完之后再通过GlSurfaceView显示。
+和SurfaceView功能类似，区别是，SurfaceTexure可以不显示在界面中。使用OpenGL对图片流进行美化，添加水印，滤镜这些操作的时候我们都是通过SurfaceTexre去处理，处理完之后再通过GLSurfaceView显示。
 
 缺点，可能会导致个别帧的延迟。本身管理着BufferQueue,所以内存消耗会多一点。  
 
diff --git "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md" "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"
index 1fb4a6e7..ab251b38 100644
--- "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
@@ -149,6 +149,10 @@ GLES30.glVertexAttribPointer(0, 3, GLES30.GL_FLOAT, false, 3 * 4, vertexBuffer);
 GLES30.glEnableVertexAttribArray(0);
 ```
 
+
+glEnableVertexAttribArray调用后允许顶点着色器读取句柄对应的GPU数据。默认情况下，出于性能考虑，所有顶点着色器的attribute变量都是关闭的，意味着数据在着色器端是不可见的，哪怕数据已经上传到GPU.由glEnableVertexAttribArray启用指定属性，才可在顶点着色器中访问逐顶点的attribute数据。glVertexAttribPointer或VBO只是建立CPU和GPU之间的逻辑连接，从而实现了CPU数据上传至GPU。但是，数据在GPU端是否可见，即着色器能否读取到数据，由是否启用了对应的属性决定，这就是glEnableVertexAttribArray的功能，允许顶点着色器读取GPU数据。
+
+
   glVertexAttribPointer函数的参数非常多，所以我会逐一介绍它们：
 
   - 第一个参数指定我们要配置的顶点属性。还记得我们在顶点着色器中使用`layout(location = 0)`定义了position顶点属性的位置值(Location)吗？它可以把顶点属性的位置值设置为`0`。因为我们希望把数据传递到这一个顶点属性中，所以这里我们传入`0`。
diff --git "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md" "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
index 7d5b2fb6..3bfe537b 100644
--- "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
+++ "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
@@ -66,6 +66,20 @@ OpenGL ES版本有自己的着色器语言，其中OpenGL ES的版本与GLSL的
 
 - 可直接使用layout制定属性值。 300版本中布局限定符可以声明顶点着色器输入和片段着色器输出的问题，例如layout(location = 2) in vec3 values[4];，如果不限定该属性的位置为2，需要通过glGetAttribuLocation()查询
 
+片元着色器中，layout限定符通过location值将输出变量和指定编号的绘制缓冲绑定起来。每一个输出变量的索引(引用)值都会对应到一个相应编号的绘制缓冲，而这个输出变量的值将写入相应缓冲。    
+
+layout限定符的location值是有范围的，其范围为[0, MAX_DRAW_BUFFERS-1]。不同手持设备的范围有可能不同，最基本的范围是[0, 3]。  
+
+```glsl
+// 此输出变量写入到0号绘制缓冲
+layout(location = 0) out vec4 fragColor;
+// 此输出变量写入到1号绘制缓冲
+layout(location = 1) out vec4 colors[2];
+
+```
+顶点着色器不允许有layout输出限定符。 如果在片元着色器中只有一个输出变量，则不需要用layout修饰符说明其对应绘制缓冲，在这种情况下，默认值为0。     
+如果片元着色器中有多个输出变量，则不允许重复使用相同的location值。   
+
 - 舍弃了gl_FragColor和gl_FragData内置属性，变成我们需要自己使用out关键字定义的属性，例如out vec4 fragColor，这就是为什么你从网还是哪个找到的代码换成GLSL ES 300版本后报错的原因。不过保留了gl_Position
 
 - GL_OES_EGL_image_external被废弃
@@ -367,7 +381,7 @@ vec4 transformedVector = myMatrix * myVector; // Yeah, it's pretty much the same
 
 - 采样器
 
-  采样器是专门用来对纹理进行采样工作的，在GLSL中一般来说，一个采样器变量表示一副或者一套纹理贴图。所谓的纹理贴图可以理解为我们看到的物体上的皮肤。
+  采样器是着色语言中不同于C语言的一种特殊的基本数据类型，采样器是专门用来对纹理进行采样工作的，在GLSL中一般来说，一个采样器变量表示一副或者一套纹理贴图。所谓的纹理贴图可以理解为我们看到的物体上的皮肤。
 
 - 结构体
 
diff --git "a/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md" "b/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
index 103439cb..f4278a1c 100644
--- "a/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
+++ "b/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
@@ -148,7 +148,7 @@ Matrix是专门为处理4*4矩阵和4元素向量设计的，其中的方法都
 
 
 
-OpenGL ES中使用的是列向量。列向量和矩阵相乘实现变换时，只能再列向量前面乘以矩阵。    
+OpenGL ES中使用的是列向量。列向量和矩阵相乘实现变换时，只能在列向量前面乘以矩阵。    
 而行向量则反之，否则乘法没有意义。   
 
 - multiplyMM
@@ -175,6 +175,40 @@ OpenGL ES中使用的是列向量。列向量和矩阵相乘实现变换时，
   获取逆矩阵
 
 
+
+平移、旋转、缩放等基本变换都是通过将表示点坐标的向量与特定的变换矩阵相乘完成的，进行基于矩阵的变换时，三维空间中点的位置需要表示成齐次坐标形式。   
+
+所谓齐次坐标形式也就是在x、y、z 3个坐标值后面增加第四个量w，未变换时w值一般为1。
+
+所谓齐次坐标表示就是用N+1维坐标表示N维坐标。采用齐次坐标是由于很多在N维空间中难以解决的问题在N+1维空间中会变得比较简单。
+
+
+##### 旋转变换
+
+OpenGL ES中，旋转角度的正负可以用右手螺旋定则来确定。  
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/gl_rotate_youshou.png?raw=true)
+
+所谓右手螺旋定则是指:    
+
+右手握住旋转轴，使大拇指指向旋转轴的正方向，4指环绕的方向即为旋转的正方向，也就是旋转角度为正值。       
+
+
+
+### 基本变换的实质    
+
+上面说到的3中基本变换的实现方法，给人的感觉是通过矩阵直接实现了对物体的变换。    
+
+但在OpenGL ES中这并不完全准确，若仅仅这样来理解在非常简单的情况下可能没有问题，但在多个物体的组合变换中可能就会产生问题了。    
+
+这是因为变换实际上并不是直接针对物体的，而是针对坐标系进行的。    
+
+OpenGL ES中变换的实现机制可以理解为首先通过矩阵对坐标系进行变换，然后根据传入渲染管线的原始顶点坐标在最终变换结果坐标系中的位置来绘制。   
+
+
+
+
+
 ### 相机
 
 顶点着色器可赋予程序员一次操作一个顶点（“按顶点”处理）的能力，片段着色器（稍后会看到）可赋予程序员一次操作一个像素（“按片段”处理）的能力，几何着色器可赋予程序员一次操作一个图元（“按图元”处理）的能力。
@@ -184,6 +218,8 @@ OpenGL ES中使用的是列向量。列向量和矩阵相乘实现变换时，
 为了达成这个目标，我们需要找到一个有利点。       
 正如我们在现实世界通过眼睛从一点观察一样，我们也必须找到一点并确立观察方向作为我们观察虚拟世界的窗口。这个点叫作视图或视觉空间，或“合成相机”（简称相机）。
 
+
+
 观察3D世界需要:    
 
 - 将相机放入世界的某个位置；
@@ -200,6 +236,28 @@ OpenGL有一个固定在原点(0,0,0)并朝向z轴负方向的相机，如下图
 给定世界空间中的点PW，我们需要通过变换将它转换成相应相机空间中的点，从而让它看起来好像是从我们期望的相机位置CW看到的样子。    
 
 
+从日常生活的经验中可以很容易的了解到，随着摄像机位置、姿态的不同，就算是对同一个场景进行拍摄，得到的画面也是迥然不同的。    
+
+因此摄像机的位置、姿态在OpenGL应用程序的开发中就显得非常重要。
+
+摄像机的设置需要给出3个方面的信息，包括摄像机的位置、观察的方向以及up方向，
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/gl_shexiangji_1.png?raw=true)
+
+- 摄像机的位置很容易理解，用其在3D空间中的坐标来表示。   
+- 摄像机观察的方向可以理解为摄像机镜头的指向，用一个观察目标点来表示(通过摄像机位置与观察目标点可以确定一个向量，此向量即代表了摄像机观察的方向)。
+- 摄像机的up方向可以理解为摄像机顶端的指向，用一个向量来表示。   
+
+通过摄像机拍摄场景与人眼观察现实世界很类似，因此，通过人眼对现实世界观察的切身感受可以理解摄像机的哥哥参数:    
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/gl_renyan_1.png?raw=true)
+
+从上图可以看出，摄像机的位置、朝向、up方向可以有很多不同的组合。   
+例如: 同样的位置可以有不同的朝向，不同的up方向。   
+
+
+
+
 当我们设置好相机之后，就可以学习投影矩阵了。我们需要学习的两个重要的投影矩阵：透视投影矩阵和正射投影矩阵。    
 透视投影通过使用透视概念模仿我们看真实世界的方式，尝试让2D图像看起来像是3D的。物体近大远小，3D空间中有的平行线用透视法画出来就不再平行。我们可以通过使用变换矩阵将平行线变为恰当的不平行线来实现这个效果，这个矩阵叫作透视矩阵或者透视变换。           
 
@@ -214,9 +272,109 @@ OpenGL有一个固定在原点(0,0,0)并朝向z轴负方向的相机，如下图
 
   计算正交投影和透视投影
 
+
+
+### 正交投影
+
 - orthoM
 
-  计算正交投影矩阵
+  计算正交投影矩阵    
+
+OpenGL ES 3.0中，根据应用程序中提供的投影矩阵，管线会确定一个可视空间区域，称为视景体。视景体是由6个平面确定的，这6个平面分别为：上平面（up）、下平面（down）、左平面（left）、右平面（right）、远平面（far）、近平面（near）。场景中处于视景体内的物体会被投影到近平面上（视景体外面的物体将被裁剪掉），然后再将近平面上投影出的内容映射到屏幕上的视口中。
+
+
+OpenGL ES 3.0中，根据应用程序中提供的投影矩阵，管线会确定一个可视空间区域，称为视景体。视景体是由6个平面确定的，这6个平面分别为：上平面（up）、下平面（down）、左平面（left）、右平面（right）、远平面（far）、近平面（near）。场景中处于视景体内的物体会被投影到近平面上（视景体外面的物体将被裁剪掉），然后再将近平面上投影出的内容映射到屏幕上的视口中。
+
+
+对于正交投影而言，视景体及近平面的情况如下图所示:    
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/gl_zhengjiao_1.png?raw=true)
+
+视点为摄像机的位置；离视点较近（距离为near）​，垂直于观察方向向量的平面为近平面，离视点较远（距离为far）​，垂直于观察方向向量的平面为远平面。与观察向量平行，从上下左右4个方向约束视景体范围的4个平面分别为上平面、下平面、左平面、右平面，这4个平面与视景体中心轴线的距离分别为top、bottom、left、right。
+
+由于正交投影是平行投影的一种，其投影线（物体的顶点与近平面上投影点的连线）是平行的。故其视景体为长方体，投影到近平面上的图形不会产生真实世界中“近大远小”的效果:      
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/gl_zhengjiao_2.png?raw=true)
+
+通过Matrix类的orthoM方法完成对正交投影的设置，其基本代码如下:   
+
+```glsl
+Matrix.orthoM (
+    mProjMatrix,         // 生成矩阵元素的float[]类型数据
+    0,                   // 起始偏移量
+    left, right,         // near面的left right
+    bottom, top,         // near面的bottom, top
+    near, far,           // near面、far面与视点的距离
+)
+```
+
+
+orthoM方法的功能为根据接收的6个正交投影相关参数产生正交投影矩阵，并将矩阵的元素填充到指定的数组中。    
+
+参数left, right为近平面左右侧边对应的x坐标，top、bottom为近平面上下侧边对应的y坐标，分别用来确定左平面、右平面、上平面、下平面的位置。    
+
+参数near、far粉笔嗯为视景体近平面与远平面距视点的距离。    
+
+
+场景中的物体投影到近平面后，最终会映射到显示屏上的视口中。     
+
+视口也就是显示屏上指定的矩形区域，通过如下代码进行设置:    
+
+```glsl
+GLES30.glViewport(x, y, width, height);   
+```
+
+从近平面到视口的映射是由渲染管线自动完成的。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/gl_zhengjiao_sample.png?raw=true)
+
+上图是由一组距离观察点原来越远的相同尺寸的六角星构成。由于采用的投影方式为正交投影，因此，最终显示在屏幕上的每个六角星尺寸都相同。     
+
+
+### 透视投影
+
+现实世界中人眼观察物体时会有“近大远小”的效果。     
+
+因此，想要开发出更加真实的场景，仅使用正交投影是远远不够的，这时可以采用透视投影。    
+
+透视投影的投影线是不平行的，他们相交于视点。    
+
+通过透视投影，可以产生现实世界中“近大远小”的效果，大部分3D游戏采用的都是透视投影。    
+
+透视投影中，视景体位锥台形区域，如下图:    
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/gl_toushi_1.png?raw=true)
+
+视点为摄像机的位置；离视点较近（距离为near），垂直于观察方向向量的平面为近平面；离视点较远（距离为far），垂直于观察方向向量的平面为远平面。近平面左侧距中心的距离为left，右侧为right，上侧为top，下侧为bottom。由观察点与近平面左上、左下、右上、右下4个的点连线与远平面的交点可以确定上、下、左、右4个斜面，这4个斜面及远近平面确定了视景体的范围。
+
+
+
+透视投影的投影线互不平行，都相交于视点。因此，同样尺寸的物体，近处的投影出来大，远处的投影出来小，从而产生了现实世界中“近大远小”的效果
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/gl_toushi_2.png?raw=true)
+
+通过Matrix类的frustumM方法完成对透视投影的设置:   
+
+```glsl
+Matrix.frustumM (
+    mProjMatrix,          // 要填充矩阵元素的float[]类型数组
+    0,                    // 填充起始偏移量
+    left, right,          // near面的left、right
+    bottom, top,          // near面的bottom、top
+    near, far             // near面、far面与视点的距离
+)
+```
+
+从上述代码中可以看出，frustumM方法的功能是，根据接收的6个透视投影相关参数产生透视投影矩阵，并将矩阵的元素依次填充到指定的数组中。
+
+
+透视投影:    
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/gl_toushi_sample.png?raw=true)
+
+
+上图由一组距离观察点越来越远的相同尺寸的六角星构成。由于采用的投影方式为透视投影，因此，最终显示在屏幕上的多个六角星近大远小。
+
+
 
 - frustumM
 
@@ -251,8 +409,20 @@ OpenGL有一个固定在原点(0,0,0)并朝向z轴负方向的相机，如下图
     用来进行旋转变换的。第一个参数是需要变换的矩阵；第二参数是偏移量；第三个参数是旋转角度，这边是以角度制，也就是说是0-360这个范围；第四、五、六个参数分别代表旋转轴向量的x，y，z值。如果x=0，y=0,z = 1 就相当于以z轴为旋转轴进行旋转，其他类似。
 
 - setLookAtm
+    
+```glsl
+Matrix.setLookAtm(
+    mVMatrix,      // 存储生成矩阵元素的float[]类型数组
+    0,             // 填充起始偏移量
+    cx, cy, cz,    // 摄像机位置的x、y、z坐标
+    tx, ty, tz,    // 观察目标点的x、y、z坐标
+    upx, upy, upz, // up向量在x、y、z轴上的分量
+)
+```
+    
+ 定义相机视图: 从上面代码中可以看出，setLookAtM方法的功能为根据接收的9个摄像机相关参数产生摄像机的观察矩阵，并将矩阵的元素填充到指定的数组中。   
 
-  定义相机视图
+之所以产生矩阵是因为OpenGL ES渲染管线的需要。   
 
   
 
diff --git "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md" "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"
index 0b92ed52..6ada2cb3 100644
--- "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
+++ "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
@@ -5,8 +5,8 @@
 ### 纹理
 
 
-现实生活中，纹理（Texture）最通常的作用是装饰 3D 物体，它就像贴纸一样贴在物体表面，丰富了物体的表面和细节。 
-
+现实生活中，纹理（Texture）最通常的作用是装饰 3D 物体，它就像贴纸一样贴在物体表面，丰富了物体的表面和细节。
+ 
 在 OpenGLES 开发中，纹理除了用于装饰物体表面，还可以用来作为存储数据的容器。
 
 那么在 OpenGLES 中，纹理实际上是一个可以被采样的复杂数据集合，是 GPU 的图像数据结构，纹理分为 2D 纹理、 立方图纹理和 3D 纹理。
@@ -18,6 +18,33 @@
 3D 纹理可以看作 2D 纹理作为切面的一个数组，类似于立方图纹理，使用三维坐标对其进行访问。
 
 
+
+### 基本原理
+
+启用纹理映射功能后，如果想把一副纹理应用到相应的几何图元，就必须告知渲染系统如何进行纹理的映射。     
+
+告知的方式就是为图元中的顶点指定恰当的纹理坐标，纹理坐标用浮点数来表示，范围一般从0.0到1.0。    
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/gl_texture_0.png?raw=true)
+
+
+- 左侧是一幅纹理图，其位于纹理坐标系中。纹理坐标系原点在左上侧，向右为S轴，向下为T轴，两个轴的取值范围都是0.0～1.0。也就是说不论实际纹理图的尺寸如何，其横向、纵向坐标最大值都是1。若实际图为512像素×256像素，则横边第512个像素对应纹理坐标为1，竖边第256个像素对应纹理坐标为1，其他情况依此类推。
+
+- 右侧是一个三角形图元，其3个顶点A、B、C都指定了纹理坐标，3组纹理坐标正好在右侧的纹理图中确定了需要映射的三角形纹理区域。
+
+从上述两点可以看出，纹理映射的基本思想就是，首先为图元中的每个顶点指定恰当的纹理坐标，然后通过纹理坐标在纹理图中可以确定选中的纹理区域，最后将选中纹理区域中的内容根据纹理坐标映射到指定的图元上。
+
+从上述两点可以看出，纹理映射的基本思想就是，首先为图元中的每个顶点指定恰当的纹理坐标，然后通过纹理坐标在纹理图中可以确定选中的纹理区域，最后将选中纹理区域中的内容根据纹理坐标映射到指定的图元上。
+
+进行纹理映射的过程实际上就是为右侧三角形图元中的每个片元着色，用于着色的颜色需要从左侧的纹理图中提取，具体过程如下:     
+- 首先图元中的每个顶点都需要在顶点着色器中通过out变量将纹理坐标传入片元着色器。
+
+- 经过顶点着色器后渲染管线的固定功能部分会根据情况进行插值计算，产生对应到每个片元的用于记录纹理坐标的out变量值。
+
+- 最后每个片元在片元着色器中根据其接收到的记录纹理坐标的in变量值到纹理图中提取出对应位置的颜色即可，提取颜色的过程一般称为纹理采样。
+
+
+
 在OpenGL中简单理解就是一张图片，在学习之前需要明白这几个概念，不然很容易迷糊，不知道为什么要这样去调用api，到底是什么意思.
 
 - 纹理Id:句柄，纹理的直接引用
@@ -571,6 +598,46 @@ void main() {
 顶点着色器允许一次操作一个顶点，而片段着色器一次可以操作一个片段（实际上是一个像素），但几何着色器却可以一次操作一个图元。
 
 
+
+
+#### 纹理色彩通道灵活组合
+
+纹理色彩通道的灵活组合。通过其可以对输入的RGBA纹理颜色分量如何映射到着色器中对应的颜色分量进行细节控制。实现纹理色彩通道的灵活组合主要是通过glTexParameterf方法进行设置。
+
+实际设置时，glTexParameterf方法的第一个参数一般为“GLES30.GL_TEXTURE_2D”，表示对2D纹理进行设置。第二个参数有4种选择，具体含义如下所列:       
+- GL_TEXTURE_SWIZZLE_R表示映射到着色器中对应采样器的红色通道。
+- GL_TEXTURE_SWIZZLE_G表示映射到着色器中对应采样器的绿色通道。
+- GL_TEXTURE_SWIZZLE_B表示映射到着色器中对应采样器的蓝色通道。
+- GL_TEXTURE_SWIZZLE_A表示映射到着色器中对应采样器的透明度通道。
+
+第三个参数则有6种选择，具体含义如下所列:     
+- GL_RED表示是映射纹理图中的红色通道。
+- GL_GREEN表示是映射纹理图中的绿色通道。
+- GL_BLUE表示是映射纹理图中的蓝色通道。
+- GL_ALPHA表示是映射纹理图中的透明度通道。
+- GL_ONE表示采用1值进行映射。
+- GL_ZERO表示采用0值进行映射。
+
+
+
+#### 2D纹理数组
+
+从OpenGL ES 3.0开始支持的纹理类型——2D纹理数组。通过使用2D纹理数组，在同一个着色器中需要使用多个2D纹理的情况下可以简化开发。可以想象出，如果没有2D纹理数组技术，当一个着色器中需要使用多个2D纹理时就需要声明多个采样器变量。     
+
+而使用2D纹理数组实现，同样功能时只需声明一个sampler2DArray类型的变量即可，方便高效。对于2D纹理数组进行采样时，需要提供的纹理坐标有3个分量，前两个与普通2D纹理坐标含义相同，为S、T分量，第三个分量则为2D纹理数组中的索引。
+
+需要注意的是，使用2D纹理数组时，一般会使数组中的纹理保持相同的尺寸。
+
+
+需要注意的是，glBindTexture方法和glTexParameterf方法的第一个参数由原来的GLES30.GL_TEXTURE_2D变为GLES30.GL_TEXTURE_2D_ARRAY。
+
+
+
+
+
+
+
+
 ---
 - [上一篇: 8.GLES类及Matrix类](https://github.com/CharonChui/AndroidNote/blob/master/VideoDevelopment/OpenGL/8.GLES%E7%B1%BB%E5%8F%8AMatrix%E7%B1%BB.md)  
 
diff --git "a/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/\351\237\263\351\242\221\347\274\226\347\240\201\346\240\274\345\274\217.md" "b/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/\351\237\263\351\242\221\347\274\226\347\240\201\346\240\274\345\274\217.md"
index 84d9fe63..a0d2f54b 100644
--- "a/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/\351\237\263\351\242\221\347\274\226\347\240\201\346\240\274\345\274\217.md"
+++ "b/VideoDevelopment/\351\237\263\351\242\221\347\274\226\347\240\201/\351\237\263\351\242\221\347\274\226\347\240\201\346\240\274\345\274\217.md"
@@ -1,5 +1,10 @@
 ## 音频编码格式
 
+多媒体要想发声，就得加个喇叭，但是喇叭是靠模拟信号驱动的，所以在喇叭之前需要增加一个数字信号转模拟信号的“解码器”，
+将数字信号转换为模拟信号。      
+
+其次还需要增加一个信号放大器，将微弱的电流放大成足以驱动喇叭磁铁产生足够磁力从而震动纸盆的足够强的电流。
+
 原始的PCM音频数据也是非常大的数据量，因此也需要对其进行压缩编码。
 和视频编码一样，音频也有许多的编码格式，如：WAV、MP3、WMA、APE、FLAC等等，音乐发烧友应该对这些格式非常熟悉，特别是后两种无损压缩格式。
 

From 4458de9a1467924f1bff9287e40677f1d4f5a803 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 19 Feb 2025 16:46:24 +0800
Subject: [PATCH 201/213] udapte video development part

---
 .../python3\345\205\245\351\227\250.md"       |  9 ++
 .../CameraX\347\273\223\345\220\210OpenGL.md" | 84 +++++++++++++++++++
 2 files changed, 93 insertions(+)
 create mode 100644 "VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/CameraX\347\273\223\345\220\210OpenGL.md"

diff --git "a/JavaKnowledge/python3\345\205\245\351\227\250.md" "b/JavaKnowledge/python3\345\205\245\351\227\250.md"
index 985895a7..3408c295 100644
--- "a/JavaKnowledge/python3\345\205\245\351\227\250.md"
+++ "b/JavaKnowledge/python3\345\205\245\351\227\250.md"
@@ -732,4 +732,13 @@ dict_keys(['total_count', 'incomplete_results', 'items'])
 
 
 
+在Python中，还可以定义可变参数。可变参数也称不定长参数，即传入函数中的实际参数可以是零个、一个、两个到任意个。
+定义可变参数时，主要有两种形式，一种是*parameter，另一种是**parameter。下面分别进行介绍。
+1．*parameter
+这种形式表示接收任意多个实际参数并将其放到一个元组中。
+2．**parameter
+这种形式表示接收任意多个类似关键字参数一样显式赋值的实际参数，并将其放到一个字典中。
 
+
+
+在Python中，可以通过@property（装饰器）将一个方法转换为属性，从而实现用于计算的属性。将方法转换为属性后，可以直接通过方法名来访问方法，而不需要再添加一对小括号“()”，这样可以让代码更加简洁。
diff --git "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/CameraX\347\273\223\345\220\210OpenGL.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/CameraX\347\273\223\345\220\210OpenGL.md"
new file mode 100644
index 00000000..276f664d
--- /dev/null
+++ "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/CameraX\347\273\223\345\220\210OpenGL.md"
@@ -0,0 +1,84 @@
+CameraX结合OpenGL
+===
+
+
+CameraX 是一个 Jetpack 库，旨在帮助您更轻松地开发相机应用。如果您要开发新应用，我们建议您从 CameraX 开始。它提供了一个一致且易于使用的 API，该 API 适用于绝大多数 Android 设备，并向后兼容 Android 5.0（API 级别 21）。
+
+
+CameraX 着重于用例，使您可以专注于需要完成的任务，而无需花时间处理不同设备之间的细微差别。CameraX 支持大多数常见的相机用例：
+
+预览：在屏幕上查看图片。接受用于显示预览的 Surface，例如 PreviewView。
+图片分析：无缝访问缓冲区中的图片以便在算法中使用，例如将其传递到机器学习套件。为分析（例如机器学习）提供 CPU 可访问的缓冲区。
+图片拍摄：保存图片。拍摄并保存照片。
+视频拍摄：保存视频和音频。通过 VideoCapture 拍摄视频和音频
+
+
+
+版本 1.4.0
+2024 年 10 月 30 日
+
+发布了 androidx.camera:camera-*:1.4.0。版本 1.4.0 包含这些提交内容。
+
+自 1.3.0 以来的重要变更
+
+CameraX 1.4.0 包含众多精彩更新！下面是摘要：
+
+主打功能：10 位 HDR：
+
+轻松拍摄出令人惊艳的 HDR 照片和视频。
+支持 HLG 和 10 位 HEVC 编码。
+享受 10 位 HDR 预览，并查询设备功能。
+可在越来越多的设备上与 UltraHDR 图片和 HDR 视频搭配使用。
+其他酷炫功能：
+
+Kotlin 扩展：添加了 takePicture 和 awaitInstance 挂起函数。
+实时特效：应用水印和对象突出显示等特效。
+CameraController API：新增了视频拍摄配置控件。
+预览防抖：查询设备功能并启用防抖。
+增强了 VideoCapture 功能：可更精细地控制画质，并支持更高分辨率。
+CameraX 扩展程序集成：与 VideoCapture 和新的 ImageCapture 功能无缝集成。
+Shutter Sound API：轻松查看各个地区的快门提示音要求。
+屏幕闪光灯：改进了前置摄像头在弱光环境下的拍照效果。
+Camera Extensions Metadata API：支持在 ExtensionMode#AUTO 中调整扩展程序强度和获取当前扩展程序模式通知的 API。如需了解更多 bug 修复，请参阅我们的Beta 版和RC 版公告。
+
+
+
+
+同时选择多个摄像头
+从 CameraX 1.3 开始，您还可以同时选择多个摄像头。 例如，您可以对前置和后置摄像头进行绑定，以便从两个视角同时拍摄照片或录制视频。
+
+使用并发摄像头功能时，设备可以同时运行两个不同镜头方向的摄像头，或同时运行两个后置摄像头。以下代码块展示了如何在调用 bindToLifecycle 时设置两个摄像头，以及如何从返回的 ConcurrentCamera 对象中获取两个 Camera 对象。
+
+Kotlin
+Java
+
+// Build ConcurrentCameraConfig
+val primary = ConcurrentCamera.SingleCameraConfig(
+    primaryCameraSelector,
+    useCaseGroup,
+    lifecycleOwner
+)
+
+val secondary = ConcurrentCamera.SingleCameraConfig(
+    secondaryCameraSelector,
+    useCaseGroup,
+    lifecycleOwner
+)
+
+val concurrentCamera = cameraProvider.bindToLifecycle(
+    listOf(primary, secondary)
+)
+
+val primaryCamera = concurrentCamera.cameras[0]
+val secondaryCamera = concurrentCamera.cameras[1]
+
+
+
+
+
+
+​    
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file

From c9b2e7169d95207379c1b072c2c7ce539f4e348c Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Thu, 13 Mar 2025 17:08:41 +0800
Subject: [PATCH 202/213] update

---
 .../python3\345\205\245\351\227\250.md"       |  56 ++++
 JavaKnowledge/shell.md                        |  91 ++++++
 ...00\201MediaCodec\343\200\201MediaMuxer.md" |   2 +
 .../SurfaceView\344\270\216TextureView.md"    |  46 ++-
 .../1.OpenGL\347\256\200\344\273\213.md"      |  37 ++-
 ...\345\222\214GL\347\272\277\347\250\213.md" | 306 ++++++++++++++++++
 .../OpenGL/18.\345\205\266\344\273\226.md"    |  68 ++++
 .../9.OpenGL ES\347\272\271\347\220\206.md"   |   2 +-
 8 files changed, 597 insertions(+), 11 deletions(-)
 create mode 100644 JavaKnowledge/shell.md
 create mode 100644 "VideoDevelopment/OpenGL/17.EGL\345\222\214GL\347\272\277\347\250\213.md"
 create mode 100644 "VideoDevelopment/OpenGL/18.\345\205\266\344\273\226.md"

diff --git "a/JavaKnowledge/python3\345\205\245\351\227\250.md" "b/JavaKnowledge/python3\345\205\245\351\227\250.md"
index 3408c295..293961fb 100644
--- "a/JavaKnowledge/python3\345\205\245\351\227\250.md"
+++ "b/JavaKnowledge/python3\345\205\245\351\227\250.md"
@@ -454,6 +454,22 @@ make_pizza('pepperoni')
 make_pizza('mushrooms','green peppers','extra cheese')
 ```
 
+
+简单来说，Python中所有的函数参数传递，统统都是基于传递对象的引用进行的。这是因为，在Python中，一切皆对象。而传对象，实质上传的是对象的内存地址，而地址即引用。
+
+
+看起来，Python的参数传递方式是整齐划一的，但具体情况还得具体分析。在Python中，对象大致分为两类，即可变对象和不可变对象。可变对象包括字典、列表及集合等。不可变对象包括数值、字符串、不变集合等。如果参数传递的是可变对象，传递的就是地址，形参的地址就是实参的地址，如同“两套班子，一套人马”一样，修改了函数中的形参，就等同于修改了实参。如果参数传递的是不可变对象，为了维护它的“不可变”属性，函数内部不得不“重构”一个实参的副本。此时，实参的副本（即形参）和主调用函数提供的实参在内存中分处于不同的位置，因此对函数形参的修改，并不会对实参造成任何影响，在结果上看起来和传值一样。
+
+
+看起来，Python的参数传递方式是整齐划一的，但具体情况还得具体分析。在Python中，对象大致分为两类，即可变对象和不可变对象。可变对象包括字典、列表及集合等。不可变对象包括数值、字符串、不变集合等。如果参数传递的是可变对象，传递的就是地址，形参的地址就是实参的地址，如同“两套班子，一套人马”一样，修改了函数中的形参，就等同于修改了实参。如果参数传递的是不可变对象，为了维护它的“不可变”属性，函数内部不得不“重构”一个实参的副本。此时，实参的副本（即形参）和主调用函数提供的实参在内存中分处于不同的位置，因此对函数形参的修改，并不会对实参造成任何影响，在结果上看起来和传值一样。
+
+
+看起来，Python的参数传递方式是整齐划一的，但具体情况还得具体分析。在Python中，对象大致分为两类，即可变对象和不可变对象。可变对象包括字典、列表及集合等。不可变对象包括数值、字符串、不变集合等。如果参数传递的是可变对象，传递的就是地址，形参的地址就是实参的地址，如同“两套班子，一套人马”一样，修改了函数中的形参，就等同于修改了实参。如果参数传递的是不可变对象，为了维护它的“不可变”属性，函数内部不得不“重构”一个实参的副本。此时，实参的副本（即形参）和主调用函数提供的实参在内存中分处于不同的位置，因此对函数形参的修改，并不会对实参造成任何影响，在结果上看起来和传值一样。
+
+
+看起来，Python的参数传递方式是整齐划一的，但具体情况还得具体分析。在Python中，对象大致分为两类，即可变对象和不可变对象。可变对象包括字典、列表及集合等。不可变对象包括数值、字符串、不变集合等。如果参数传递的是可变对象，传递的就是地址，形参的地址就是实参的地址，如同“两套班子，一套人马”一样，修改了函数中的形参，就等同于修改了实参。如果参数传递的是不可变对象，为了维护它的“不可变”属性，函数内部不得不“重构”一个实参的副本。此时，实参的副本（即形参）和主调用函数提供的实参在内存中分处于不同的位置，因此对函数形参的修改，并不会对实参造成任何影响，在结果上看起来和传值一样。
+
+
 ### 将函数存储在模块中
 
 函数的优点之一是，使用它们可将代码块与主程序分离。通过给函数指定描述性名称，可让主程序容易理解得多。你还可以更进一步，将函数存储在被称为模块的独立文件中，再将模块导入到主程序中。import语句允许在当前运行的程序文件中使用模块中的代码。
@@ -673,6 +689,14 @@ title.split()
 
 Python有一个pass语句，可在代码块中使用它来让Python什么都不要做。    
 
+```python
+def donothing():    
+    pass    #空语句
+
+```
+
+
+pass语句如果啥事都不做，那要它有何用呢？实际上，pass可以作为一个占位符来用——视为未成熟代码的“预留地”。比如说，如果我们还没想好函数的内部实现，就可以先放一个pass，让代码先跑起来。
 
 ### json
 
@@ -733,6 +757,27 @@ dict_keys(['total_count', 'incomplete_results', 'items'])
 
 
 在Python中，还可以定义可变参数。可变参数也称不定长参数，即传入函数中的实际参数可以是零个、一个、两个到任意个。
+
+Python中的可变参数的表现形式为，在形参前添加一个星号（*），意为函数传递过来的实参个数不定，可能为0个、1个，也可能为n个（n≥2）。需要注意的是，不管可变参数有多少个，在函数内部，它们都被“收集”起来并统一存放在以形参名为某个特定标识符的元组之中。因此，可变参数也被称为“收集参数”。
+
+
+除了用单个星号（*）表示可变参数，其实还有另一种标定可变参数的形式，即用两个星号（**）来标定。通过前文的介绍，我们知道，一个星号（*）将多个参数打包为一个元组，而两个星号（**）的作用是什么呢？它的作用就是把可变参数打包成字典模样。
+
+这时调用函数则需要采用如“arg1=value1,arg2=value2”这样的形式。等号左边的参数好比字典中的键（key）[插图]，等号右边的数值好比字典中的值（value）​，
+
+```python
+def varFun(**x): 
+    if len(x) == 0:
+        print("None")
+    else:
+        print(x)
+
+
+varFun(a = 1, b = 3)
+
+
+```
+
 定义可变参数时，主要有两种形式，一种是*parameter，另一种是**parameter。下面分别进行介绍。
 1．*parameter
 这种形式表示接收任意多个实际参数并将其放到一个元组中。
@@ -740,5 +785,16 @@ dict_keys(['total_count', 'incomplete_results', 'items'])
 这种形式表示接收任意多个类似关键字参数一样显式赋值的实际参数，并将其放到一个字典中。
 
 
+除了用等号给可变关键字参数赋值，事实上，我们还可以直接用字典给可变关键字参数赋值:     
+
+```python
+def some_kwargs(name, age, sex):
+    print(f"name: ${name}")
+
+kdic = {'name' : 'Alice', 'age' : 11, 'sex' : 'nv'}
+some_kwargs(**kdic)
+
+```
+
 
 在Python中，可以通过@property（装饰器）将一个方法转换为属性，从而实现用于计算的属性。将方法转换为属性后，可以直接通过方法名来访问方法，而不需要再添加一对小括号“()”，这样可以让代码更加简洁。
diff --git a/JavaKnowledge/shell.md b/JavaKnowledge/shell.md
new file mode 100644
index 00000000..c6bf4a42
--- /dev/null
+++ b/JavaKnowledge/shell.md
@@ -0,0 +1,91 @@
+shell
+---
+
+
+
+
+### ls: 
+
+ls x* y*: 过滤文件中x和y开头的文件
+ls -F: 区分文件还是目录
+ls -l: 显示详细信息
+
+### touch: 创建或修改文件时间
+
+
+### cp: 复制文件
+
+cp sourceFile destinationFile，但是如果源文件存在会直接被覆盖，也不会提醒，
+如果想要提醒需要加上-i, 例如cp -i 1.txt 2.txt
+
+
+### mv移动重新命名
+
+用法和cp一致
+
+
+### rm删除
+
+rm -i xxx: -i会询问是否真的要删除
+rm -f xxx: 强制删除，不会询问
+
+注意　对于rm命令，-r选项和-R选项的效果是一样的，都可以递归地删除目录中的文件。shell命令很少会对相同的功能使用大小写不同的选项。
+一口气删除目录树的最终解决方案是使用rm -rf命令。该命令不声不响，能够直接删除指定目录及其所有内容。当然，这肯定是一个非常危险的命令，所以务必谨慎使用，并再三检查你要进行的操作是否符合预期。
+
+
+### mkdir 创建目录
+
+mkdir命令的-p选项可以根据需要创建缺失的父目录。父目录是包含目录树中下一级目录的目录。
+
+### rmdir 删除空目录
+
+### file
+
+file命令是一个方便的小工具，能够探测文件的内部并判断文件类型：
+$ file .bashrc
+.bashrc: ASCII text
+
+
+### cat 显示文本文件
+
+cat fileName
+
+-n 加上行号
+
+### more 
+cat的缺点是其开始运行后无法控制后续的操作，为了解决这个问题，有了more命令。    
+
+more命令会显示文件内容，但会在显示每页数据之后暂停下来。
+
+### ps 显示当前用户进程
+
+ps -ef显示系统中运行的所有进程    
+
+### top 实时监测进程
+
+ps命令虽然在收集系统中运行进程的信息时非常有用，但也存在不足之处：只能显示某个特定时间点的信息。如果想观察那些被频繁换入和换出内存的进程，ps命令就不太方便了。这正是top命令的用武之地。与ps命令相似，top命令也可以显示进程信息，但采用的是实时方式。
+
+
+
+### kill pid， 通过pid发送信号
+
+### pkill pname: pkill命令可以使用程序名代替PID来终止进程。除此之外，pkill命令也允许使用通配符。   
+
+
+### grep数据搜索
+
+经常需要在大文件中搜索
+
+### gzip压缩
+
+gzip: 压缩
+gzcat: 查看压缩过的文本文件内容
+gunzip:解压
+
+### tar归档
+
+ar命令最开始是用于将文件写入磁带设备以作归档，但它也可以将输出写入文件，这种用法成了在Linux中归档数据的普遍做法。tar命令的格式如下
+
+// 该命令创建了一个名为test.tar的归档文件，包含目录test和test2的内容。
+tar -cvf test.tar test/ test2/
+
diff --git "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/MediaExtractor\343\200\201MediaCodec\343\200\201MediaMuxer.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/MediaExtractor\343\200\201MediaCodec\343\200\201MediaMuxer.md"
index d2d01f24..204676f3 100644
--- "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/MediaExtractor\343\200\201MediaCodec\343\200\201MediaMuxer.md"
+++ "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/MediaExtractor\343\200\201MediaCodec\343\200\201MediaMuxer.md"
@@ -26,6 +26,8 @@ MediaMuxter通常与MediaExtractor一起使用，MediaExtractor用于从媒体
 MediaCodec是Android提供的用于对音视频进行编码的类，是Android Media基础框架的一部分，一般和MediaExtractor、MediaMuxer、Surface和AudioTrack一起使用。 
 
 
+MediaCodec可以处理原始的音视频数据，包括编码(将原始数据转换为压缩格式)和解码(将压缩格式转换为原始数据)。    
+
 
 
 MediaExtractor仅仅是解封装数据，不会对数据进行解码。要对媒体数据进行解码，需要使用MediaCodec类。    
diff --git "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/SurfaceView\344\270\216TextureView.md" "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/SurfaceView\344\270\216TextureView.md"
index de765b86..23739606 100644
--- "a/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/SurfaceView\344\270\216TextureView.md"
+++ "b/VideoDevelopment/Android\351\237\263\350\247\206\351\242\221\345\274\200\345\217\221/SurfaceView\344\270\216TextureView.md"
@@ -2,13 +2,21 @@ SurfaceView与TextureView
 ===
 
 
-## SurfaceView
+Android系统中图形系统是相当复杂的，包括WindowManager、SurfaceFlinger、OpenGL等。     
+
+其中SurfaceFlinger(表面合成器或表面渲染器)作为负责绘制应用UI的核心。
+
+但是不论使用什么渲染API，所有的东西最终都渲染到Surface上，Android平台所创建的Window都由Surface所支持，所有可见的Surface渲染到显示设备都是通过SurfaceFlinger来完成。    
+
+
+
 
-在说SurfaceView之前，需要先说一下几个相关的部分。
 
 ### `Surface`简介
 
-- `Surface`就是“表面”的意思，可以简单理解为内存中的一段绘图缓冲区。在`SDK`的文档中，对`Surface`的描述是这样的：“`Handle onto a raw buffer that is being managed by the screen compositor`”，
+- `Surface`就是“表面”的意思，可以简单理解为内存中的一段绘图缓冲区。
+
+    在`SDK`的文档中，对`Surface`的描述是这样的：“`Handle onto a raw buffer that is being managed by the screen compositor`”，
     翻译成中文就是“由屏幕显示内容合成器`(screen compositor)`所管理的原生缓冲器的句柄”，   这句话包括下面两个意思:     
 
     - 通过`Surface`（因为`Surface`是句柄）就可以获得原生缓冲器以及其中的内容。就像在`C`语言中，可以通过一个文件的句柄，就可以获得文件的内容一样；
@@ -19,6 +27,9 @@ SurfaceView与TextureView
 - `Surface`是一个用来画图形的地方，但是我们知道画图都是在一个`Canvas`对象上面进行的，*`Surface`中的`Canvas`成员，是专门用于提供画图的地方，就像黑板一样，其中的原始缓冲区是用来保存数据的地方，
     `Surface`本身的作用类似一个句柄，得到了这个句柄就可以得到其中的`Canvas`、原始缓冲区以及其他方面的内容，所以简单的说`Surface`是用来管理数据的(句柄)*。
     
+
+Surface是一个绘制目标，可以被系统的SurfaceFlinger直接合成显示在屏幕上。    
+
 ### `SurfaceView`简介      
 
 - 简单的说`SurfaceView`就是一个有`Surface`的`View`里面内嵌了一个专门用于绘制的`Surface`,`SurfaceView`控制这个`Surface`的格式和尺寸以及绘制位置。
@@ -84,16 +95,40 @@ TextureView是一个可以把内容流作为外部纹理输出在上面的View,
 
 ### SurfaceTexture
 
-SurfaceTexture是Surface和OpenGL ES(GLES)纹理的组合。SurfaceTexture用于提供输出到GLES 纹理的Surface。SurfaceTexture是从Android 3.0开始加入，与SurfaceView不同的是，它对图像流的处理并不直接显示，而是转为GL外部纹理，因此用于图像流数据的二次处理。比如Camera的预览数据，变成纹理后可以交给GLSurfaceView直接显示，也可以通过SurfaceTexture交给TextureView作为View heirachy中的一个硬件加速层来显示。首先，SurfaceTexture从图像流(来自Camera预览、视频解码、GL绘制场景等)中获得帧数据，当调用updateTexImage()时，根据内容流中最近的图像更新SurfaceTexture对应的GL纹理对象。
+SurfaceTexture 是一种 纹理对象，可以作为 OpenGL ES 纹理（OES 纹理）进行处理。它不会直接显示在屏幕上，而是可以将内容传递给 OpenGL 进行进一步处理或绘制。
+
+SurfaceTexture用于提供输出到GLES 纹理的Surface。SurfaceTexture是从Android 3.0开始加入，与SurfaceView不同的是，它对图像流的处理并不直接显示，而是转为GL外部纹理，因此用于图像流数据的二次处理。比如Camera的预览数据，变成纹理后可以交给GLSurfaceView直接显示，也可以通过SurfaceTexture交给TextureView作为View heirachy中的一个硬件加速层来显示。
+
+在Android系统重，SurfaceTexture是一个特殊的类，它将来自硬件纹理缓冲区(如相机预览流或视频解码输出)的图像数据转换为OpenGL ES可以直接使用的纹理。     
+
+updateTexImage()方法是SurfaceTexture类的核心方法之一，此方法的主要作用是从SurfaceTexture内部特有的图像缓冲区中取出最新一帧，
+并将其内容复制到与SurfaceTexture关联的OpenGL纹理上。    
+
+这对于实时图形渲染、视频播放以及从相机捕获并实时处理图像等场景至关重要。 
 
 
 
 SurfaceTexture 包含一个应用是其使用方的BufferQueue。当生产方将新的缓冲区排入队列时，onFrameAvailable() 回调会通知应用。然后，应用调用updateTexImage()，这会释放先前占有的缓冲区，从队列中获取新缓冲区并执行EGL调用，从而使GLES可将此缓冲区作为外部纹理使用。
 
+
+##### Surface与SurfaceTexture的关系
+
+- SurfaceTexture是一个OpenGL纹理对象，用于GPU处理视频流或相机数据，它不会直接显示在屏幕上，需要OpenGL渲染后才能看到。    
+- Surface是一个绘制目标，可以直接用于屏幕渲染，它可以基于SurfaceTexture创建，这样Surface就可以间接获取SurfaceTexture的数据。  
+
+例如相机使用OpenGL的渲染过程:   
+
+- 在相机预览时，Camera可以将相机数据输出到SurfaceTexture上，然后
+- SurfaceTexture采集相机数据，并将其存储到OpenGL纹理中(OES纹理)
+- SurfaceTexture触发onFrameAvailable()回调，通知OpenGL纹理更新。 
+- OpenGL使用该纹理进行渲染，最终显示在GLSurfaceView或TextureView上。    
+
+
 ## SurfaceView vs TextureView
 
 
 
+
 简单地说，SurfaceView是一个有自己Surface的View。它的渲染可以放在单独线程而不是主线程中。其缺点是不能做变形和动画。SurfaceTexture可以用作非直接输出的内容流，这样就提供二次处理的机会。与SurfaceView直接输出相比，这样会有若干帧的延迟。同时，由于它本身管理BufferQueue，因此内存消耗也会稍微大一些。TextureView是一个可以把内容流作为外部纹理输出在上面的View。它本身需要是一个硬件加速层。事实上TextureView本身也包含了SurfaceTexture。它与SurfaceView+SurfaceTexture组合相比可以完成类似的功能（即把内容流上的图像转成纹理，然后输出）。区别在于TextureView是在View hierachy中做绘制，因此一般它是在主线程上做的（在Android 5.0引入渲染线程后，它是在渲染线程中做的）。而SurfaceView+SurfaceTexture在单独的Surface上做绘制，可以是用户提供的线程，而不是系统的主线程或是渲染线程。
 
 
@@ -123,4 +158,5 @@ SurfaceTexture 包含一个应用是其使用方的BufferQueue。当生产方将
 ---
 
 - 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
\ No newline at end of file
+- Good Luck! 
+
diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
index e84f18ce..b560e1f5 100644
--- "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -32,9 +32,22 @@ OpenGL ES由OpenGL裁剪而来，因此有必要了解一下两者版本的对
 
 ### OpenGL的作用
 
-在手机或电脑上有两大元件，一个是CPU,一个是GPU。      
+在手机或电脑上有两大元件，一个是CPU,一个是GPU。
+
 显示图形界面也有两种方式，一个是使用CPU渲染，一个是使用GPU渲染。        
-但是目前为止最高效的方法就是有效的使用图形处理单元(GPU)，图像的处理和渲染就是在将要渲染到窗口上的像素上做很多的浮点运算，而GPU可以并行的做浮点运算，所以用GPU来分担CPU的部分，可以提高效率，可以说GPU渲染其实是一种硬件加速。
+
+CPU和GPU因为涉及之初需求就不一样，所以它们的组成不同，在计算机中的分工也不同。    
+GPU有更多的ALU(算术逻辑单元，能实现多组算术运算和逻辑运算的组合逻辑电路)，而CPU有Control单元和Cache单元，普通的业务代码因为逻辑复杂，数据类型复杂、跳转复杂、依赖性高等，就更适合CPU来做。    
+
+而GPU不擅长处理这些复杂的逻辑，它更擅长处理单一的运算，大量的算术逻辑单元可以保证做到真正的高并发，所以大量的计算任务是适合它的工作，就比如GLSL代码。    
+
+简单说就是CPU更像管理者，负责调度和控制，也进行小量的计算，而GPU则是单纯的打工人，负责大量的计算工作。      
+
+
+
+
+目前为止最高效的方法就是有效的使用图形处理单元(GPU)，图像的处理和渲染就是在将要渲染到窗口上的像素上做很多的浮点运算，而GPU可以并行的做浮点运算，所以用GPU来分担CPU的部分，可以提高效率，可以说GPU渲染其实是一种硬件加速。
+
 
 - 图片处理:比如图片色调转换、美颜等。
 - 摄像头预览效果处理。比如美颜相机、恶搞相机等。
@@ -96,7 +109,6 @@ OpenGL采用Client-Server模型来解释OpenGL程序，即Server存储OpenGL Con
 OpenGL ES API没有提及如何创建渲染上下文，或者渲染上下文如何连接到原生窗口系统。    
 
 EGL是Khronos渲染API(如OpenGL ES)和原生窗口系统之间的接口。
-
 ### 对象
 OpenGL在开发的时候引入了一些抽象层，对象(Object)就是其中的一个。 
 
@@ -525,7 +537,9 @@ OpenGL中最基础且唯一的多边形就是三角形，所有更复杂的图
 **在现代OpenGL中，我们必须定义至少一个顶点着色器和一个片段着色器（因为GPU中没有默认的顶点/片段着色器）。**  
 
 
-光栅化后产生了多少个片元，就会插值计算出多少套in变量。同时，渲染管线就会调用多少次片元着色器。可以看出，一般情况下对一个3D物体的渲染中，片元着色器执行的次数会大大超过顶点着色器。          因此，GPU硬件中配置的片元着色器硬件数量往往多于顶点着色器硬件数量，通过这些硬件单元的并行执行，提高渲染速度。
+光栅化后产生了多少个片元，就会插值计算出多少套in变量。同时，渲染管线就会调用多少次片元着色器。可以看出，一般情况下对一个3D物体的渲染中，片元着色器执行的次数会大大超过顶点着色器。
+
+因此，GPU硬件中配置的片元着色器硬件数量往往多于顶点着色器硬件数量，通过这些硬件单元的并行执行，提高渲染速度。
 
 整个处理过程又分为以下几个部分:     
 
@@ -559,6 +573,9 @@ OpenGL中最基础且唯一的多边形就是三角形，所有更复杂的图
 
 ### 帧缓冲区
 
+像素(pixel)是显示器上最小的可见单元。计算机系统将所有的像素保存到帧缓存(framebuffer)当中，后者是由图形硬件设备管理的一块独立内存区域，可以直接映射到最终的显示设备上。     
+
+
 OpenGL实际上并不是把图像直接绘制到计算机屏幕上，而是将之渲染到一个帧缓冲区，然后由计算机来负责把帧缓冲区中的内容绘制到屏幕上的一个窗口中。            
 
 OpenGL管线的最终渲染目的地被称为帧缓存(framebuffer也被记做FBO)
@@ -662,11 +679,21 @@ EGL为双缓冲工作模式(Double Buffer)，既有一个Back Frame Buffer和一
 
 6. 设置OpenGL的渲染环境
 
-   eglMakeCurrent(EGLDisplay display, EGLSurface draw, EGLSurface read, EGLContext context);该方法的参数意义很明确，该方法在异步线程中被调用，该线程也会被称为GL线程，一旦设定后，所有OpenGL渲染相关的操作都必须放在该线程中执行。
+   eglMakeCurrent(EGLDisplay display, EGLSurface draw, EGLSurface read, EGLContext context);该方法的参数意义很明确，该方法在异步线程中被调用，该线程也会被称为GL线程，一旦设定后，所有OpenGL渲染相关的操作都必须放在该线程中执行并且指定OpenGL绘制的结果最后输出到这个EGLSurface上。    
 
 通过上述操作，就完成了EGL的初始化设置，便可以进行OpenGL的渲染操作。所有EGL命令都是以egl前缀开始，对组成命令名的每个单词使用首字母大写(如eglCreateWindowSurface)。
 
+
+简单总结:    
+
+- EGLDisplay: 代表物理屏幕，可能支持多种配置(EGLConfig)
+- EGLContext: 线程相关上下文环境，存储数据如图片、顶点、着色器等，使用的时候只需要拿他们的id取用。  
+- EGLSurface: 绘制的模板Surface，用于指定在哪个view上显示OpenGL的绘制结果  
+
+
+
 #### 创建屏幕外渲染区域: EGL Pbuffer
+
 除了可以用OpenGL在屏幕上的窗口渲染之外，还可以渲染称作pbuffer(像素缓冲区Pixel buffer的缩写)的不可见屏幕外表面。          
 和窗口一样，Pbuffer可以利用OpenGL ES3.0中的任何硬件加速。      
 Pbuffer最常用于生成纹理贴图。如果你想要做的是渲染到一个纹理，那么我们建议使用帧缓冲区对象代替Pbuffer，因为帧缓冲区更高效。不过，在某些帧缓冲区对象无法使用的情况下，Pbuffer仍然有用，例如用OpenGL ES在屏幕外表面上渲染，然后将其作为其他API(如OpenVG)中的纹理。     
diff --git "a/VideoDevelopment/OpenGL/17.EGL\345\222\214GL\347\272\277\347\250\213.md" "b/VideoDevelopment/OpenGL/17.EGL\345\222\214GL\347\272\277\347\250\213.md"
new file mode 100644
index 00000000..fd4db0e9
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/17.EGL\345\222\214GL\347\272\277\347\250\213.md"
@@ -0,0 +1,306 @@
+EGL和GL线程
+---
+
+
+EGL是连接OpenGL ES与本地窗口系统的桥梁。   
+
+OpenGL是跨平台的，但是不同平台上的窗口系统是不一样的，它就需要一个东西帮助OpenGL与本地窗口系统进行对接、管理及执行GL命令等。    
+
+OpenGL ES的平台无关性正是借助EGL实现的，EGL屏蔽了不同平台的差异(Apple提供了自己的EGL API的iOS实现，自称EAGL)。
+
+EGL可以创建渲染表面EGLSurface，同时提供了图形渲染上下文EGLContext，用来进行状态管理，接下来OpenGL ES就可以在这个渲染表面上绘制。   
+
+
+GL线程是一个与EGL环境绑定了的线程，绑定后可以在这个线程中执行GL操作。 
+
+
+比如将原视频进行OpenGL ES特效渲染然后编码保存，或者是解码原视频然后进行OpenGL ES特效渲染再显示出来。
+
+编码时需要将要编码的帧渲染到MediaCodec给你的一块surface上，而这些操作需要有EGL才能做，而解码时是解码到一块你自己指定的surface上，此时你也没有一个现成的EGL环境，如果你想解码出来先用OpenGL ES做些特效处理再显示出来，那么这时也需要EGL环境。
+
+
+### GLContext
+
+
+在我们的程序运行时，每一个方法的调用都是在CPU上的。
+OpenGL也不例外，与普通调用的区别在于这些调用会被转换为GPU驱动指令在GPU上执行，而CPU和GPU作为两个不同的处理单元，它们之间的指令是并行执行的。     
+
+OpenGL的设计模式是Client/Server，这里Client是指CPU、Server是指GPU。     
+
+在执行gl命令时会有一个队列用于暂存还未发送到GPU的命令，实际上我们调用的绝大多数OpenGL方法，只是在往命令队列中插入命令，在CPU中并不一定会等待命令执行完。    
+
+
+![image](https://github.com/CharonChui/Pictures/blob/master/opengl_cpu_gpu.png?raw=true)
+
+但并不是所有的线程都对应同一个命令队列，命令队列是和EGL Context对应的，而一个线程又只能同时绑定到一个EGL Context。      
+因此可以理解为命令队列是和绑定的EGL Context的线程对应的。     
+
+CommandQueue：在CPU和GPU分别有各自的CommanQueue，当一个OpenGL命令在CPU执行时，会先添加到CPU的CommanQueue，在CPU切换到burst mode后，CPU 
+CommanQueue中的命令被依次发送到GPU CommanQueue，GPU会在合适的时机执行CommanQueue里的命令。     
+
+GLContext: OpenGL的状态机，保存有渲染管线用到的状态和资源，OpenGL命令的宿主环境。    
+
+GLContext是和线程强相关的，这是因为绝大部分驱动的设计中，都是一个线程一个CommanQueue，而这个线程中的当前GLContext中发生的命令才会被添加到CommanQueue。      
+
+绝大多数OpenGL命令在CPU上是异步执行的，在CPU上是同步执行的。    
+
+这一切得益于CommanQueue的存在，让CPU可以更高效地完成命令发送，毕竟总线的资源是珍贵的，尤其在移动端的总线带宽是非常小的(内存64/128bit，显存128/256bit)。      
+但这样的代价是在渲染有问题时，在CPU无法定位到真正的现场。     
+
+
+
+
+
+为了让大家直接感觉一下EGL所起的作用，我们来试试几段代码，一段是我们很熟悉的GLSurfaceView的Renderer的代码，我们可以在回调中做GL操作，比如这里我们创建一个texture：
+
+```kotlin	
+glSurfaceView.setRenderer(object : GLSurfaceView.Renderer {
+            
+    override fun onDrawFrame(gl: GL10?) {
+    }
+
+    override fun onSurfaceChanged(gl: GL10?, width: Int, height: Int) {
+    }
+
+    override fun onSurfaceCreated(gl: GL10?, config: EGLConfig?) {
+        
+        val textures = IntArray(1)
+        GLES30.glGenTextures(textures.size, textures, 0)
+        val imageTexture = textures[0]
+        
+    }
+
+})
+
+```
+如果你查看这个texture的值，会发现它大于0，也就是创建成功了，另外也可以通过OpenGL ES的方法GLES30.glIsTexture(imageTexture)来判断一个texture是不是合法的texture。
+
+如果我们把上述创建texture的操作放到主线程中会怎样？
+
+```kotlin
+class MainActivity : AppCompatActivity() {
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        val textures = IntArray(1)
+        GLES30.glGenTextures(textures.size, textures, 0)
+        val imageTexture = textures[0]
+    }
+}
+```
+
+我们会发现，这时创建出来的texture是0，也就是创建失败了，其实不只是创建texture失败，其它GL操作一律会失败。
+
+如果放到一个子线程中呢？
+
+效果是一样的，也会失败，为什么？
+
+**原因就是在一个没有EGL环境的线程中调用了OpenGL ES API。**   
+
+ 那如何让一个线程拥有EGL环境？创建EGL环境，步骤还不少，一共有以下几个步骤：
+
+
+- 获取显示设备
+```
+eglDisplay = EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY)
+```
+
+这里获取的是default的显示设备，大多数情况下我们都是获取default，因为大多数情况下设备只有一个屏幕，本文也只讨论这种情况。
+
+- 初始化显示设备
+
+```
+val version = IntArray(2)
+EGL14.eglInitialize(eglDisplay, version, 0, version, 1)
+```
+这里初始化完成后，会返回给我们支持的EGL的最大和最小版本号。
+
+
+这里初始化完成后，会返回给我们支持的EGL的最大和最小版本号。
+
+- 选择config
+
+```
+val attribList = intArrayOf(
+    EGL14.EGL_RED_SIZE, 
+    8, 
+    EGL14.EGL_GREEN_SIZE, 
+    8, 
+    EGL14.EGL_BLUE_SIZE, 
+    8, 
+    EGL14.EGL_ALPHA_SIZE, 
+    8,
+    EGL14.EGL_RENDERABLE_TYPE, 
+    EGL14.EGL_OPENGL_ES2_BIT or EGLExt.EGL_OPENGL_ES3_BIT_KHR, 
+    EGL14.EGL_NONE
+)
+val eglConfig = arrayOfNulls<EGLConfig>(1)
+val numConfigs = IntArray(1)
+EGL14.eglChooseConfig(
+    eglDisplay, 
+    attribList, 
+    0, 
+    eglConfig, 
+    0, 
+    eglConfig.size,
+    numConfigs, 
+    0
+)
+```
+
+这步操作告诉系统我们期望的EGL配置，然后系统返回给我们一个列表，按配置的匹配程度排序，因为系统不一定有我们期望的配置，因此要通过查询让系统返回尽可能接近的配置。
+
+attribList是我们期望的配置，我们这里的配置是将RGBA颜色深度设置为8位，并将OpenGL ES版本设置为2和3，表示同时支持OpenGL 2和OpenGL 3，最后以一个EGL14.EGL_NONE作为结束符。
+
+eglConfig是返回的尽可能接近我们期望的配置的列表，通常我们取第0个来使用，即最符合我们期望配置。
+
+- 创建EGL Context
+
+```
+eglContext = EGL14.eglCreateContext(
+    eglDisplay, 
+    eglConfig[0], 
+    EGL14.EGL_NO_CONTEXT,
+    intArrayOf(EGL14.EGL_CONTEXT_CLIENT_VERSION, 3, EGL14.EGL_NONE), 
+    0
+)
+```
+
+eglDisplay即是之前创建的显示设备，注意第三个参数，它是指定一个共享的EGL Context，共享后，2个EGL Context可以相互使用对方创建的texture等资源，默认情况下是不共享的，但不是所有资源都能共享，例如program就是不共享的。
+
+
+- 创建EGL Surface
+
+```
+val surfaceAttribs = intArrayOf(EGL14.EGL_NONE)
+eglSurface = EGL14.eglCreatePbufferSurface(
+    eglDisplay, 
+    eglConfig[0], 
+    surfaceAttribs, 
+    0
+)
+```
+
+EGL Surface是什么东西？可以理解成是一个用于承载显示内容的东西，这里有2种EGL Surface可以选择，一种是window surface，一种是pbuffer surface。
+
+如果我们创建这个EGL环境是为了跟一块Surface绑定，例如希望给Surface View创建一个EGL环境，使用OpenGL ES渲染到Surface View上，那么就要选择window surface，对应的创建方法为：
+```
+EGL14.eglCreateWindowSurface(
+    eglDisplay, 
+    eglConfig[0], 
+    surface, 
+    surfaceAttribs, 
+    0
+)
+```
+其中surface就是这个Surface View对应的surface。如果我们不需要渲染出来看，那么就可以创建一个pbuffer surface，它不和surface绑定，不需要传surface给它，这也称为离屏渲染，本文中将创建pbuffer surface。
+
+这里提一个细节，现在的surface所对应的buffer一般都是双buffer，以便于一个buffer正在显示的时候，有另一个buffer可用于渲染， 正在显示的buffer称为front buffer，正在渲染的buffer称为back buffer。
+
+如果要渲染到surface上，必须在渲染后调EGL14.eglSwapBuffers(eglDisplay, eglSurface) 将显示buffer和渲染buffer进行交换才会生效，否则会一直渲染到back buffer上，这个buffer无法变成front buffer显示到surface上。
+
+
+
+- 绑定EGL
+前面的几个步骤，我们把一些需要创建的东西都创建好了，下面就要将EGL绑定到线程上让它具体有EGL环境：
+```
+EGL14.eglMakeCurrent(
+    eglDisplay, 
+    eglSurface, 
+    eglSurface, 
+    eglContext
+)
+```
+
+注意，一个线程只能绑定一个EGL环境，如果之前绑过其它的，后面又绑了一个，那就会是最后绑的那个。至此，就能让一个线程拥有EGL环境了，此后就可以顺利地做GL操作了。
+
+好，我们看一下我们的例子代码：
+```
+Thread {
+
+    val egl = EGL()
+    egl.init()
+
+    egl.bind()
+
+    val textures = IntArray(1)
+    GLES30.glGenTextures(textures.size, textures, 0)
+    val imageTexture = textures[0]
+    assert(GLES30.glIsTexture(imageTexture))
+
+    egl.release()
+
+}.start()
+```
+代码很简单，只是为了验证是否有了EGL环境，就不写复杂的操作了，EGL就是对前文所述的操作的一个封装类，init()方法对应了获取显示设备、初始化显示设备、选择config、创建EGL Context和创建EGL Surface，bind()方法对应了eglMakeCurrent()。
+
+
+
+
+### 共享上下文
+
+![image](https://github.com/CharonChui/Pictures/blob/master/opengl_share_context.png?raw=true)
+
+共享上下文时，可以跨线程共享哪些资源?    
+
+可共享的资源:    
+
+- 纹理
+- shader
+- program着色器程序
+- buffer类对象，如VBO、EBO、RBO等
+
+不可以共享的资源:    
+
+- FBO帧缓冲区对象(不属于buffer类)
+- VAO顶点数组对象(不属于buffer类)
+
+
+在不可以共享的资源中，FBO和VAO属于资源管理型对象，FBO负责管理几种缓冲区，本身不占用资源，VAO负责管理VBO或EBO，本身也不占用资源。    
+
+
+注意：每个线程同时只能绑定(eglMakeCurrent)一个Context，但可以按顺序切换不同Context。
+
+
+### glFinish()、glFlush()、glFence()
+
+但是在跨线程的共享中也会带来一些同步问题，比如两个线程对同一个纹理进行操作，thread0在纹理上绘制，thread1使用thread0提供的纹理，这时候如果thread0的线程没有渲染完，而thread1就开始使用，就会造成黑屏或者花屏的问题。    
+
+要解决这个问题有一个简单的方案就是使用glFinish()，glFinish()是一个同步方法，运行时会等待该线程中所有的GL命令(包括所有改变GL状态的命令，所有改变连接状态的命令和所有改变Frame buffer内容的命令)都执行完，从而保证绘制的完整性。    
+
+
+与glFinish()比较相近的还有一个glFlush()方法，它的作用是将命令队列中的命令全部刷到GPU，但并不等它执行完成。    
+
+在实际使用中，各个厂家的GPU实现差异很大，但都要求符合OpenGL标准，glFlush可以异步实现，也可以同步实现，但glFinish必须同步实现，所以调用glFlush并返回时，只能说是渲染命令都下发了，但不能保证一定完成，而glFinish返回时是保证了命令已经执行完成的。    
+
+glFinish虽然能保证命令的完整执行，但是会对性能有一定的影响，因为它会使得GPU和CPU之间的并行性丧失。    
+
+一般，我们提交给驱动的任务被分组，然后被送到硬件上(再缓冲区交换的时候)，如果调用glFinish，就强制驱动将命令送到GPU。然后CPU等待直到被传送的命令全部执行完成。这样在GPU工作的整个期间内，CPU没有工作(至少在这个线程上)。而在CPU工作时(通常是在对命令分组)，GPU没有工作，因此造成性能上的下降。   
+
+有些厂商在实现中已经做了一些保证操作完整性的处理(比如高通部分Soc)，并不需要使用到glFinish，过度的使用glFinish反而降低了渲染的效率，相比于glFinish在OpenGL 3.0中有了更好的方案glFence。  
+
+
+
+GLFence 的原理是在同步过程中创建一个 Fence 同步对象并将 Fence 命令插入 GL 命令队列中，当 Fence 命令满足同步对象的指定条件时，GL 发出解除信号，解除由glWaitSync 或 glClientWaitSync命令造成的阻塞。
+
+
+
+同时，glFenceSync 或相关 Fence 命令的执行不会影响其他 GL 状态。
+
+
+glFence 中包含两个 Sync 命令 glWaitSync 和 glClientWaitSync，glWaitSync 是在 GPU 上等待，而 glClientWaitSync 是在 CPU 上等待，实际使用中只有 glClientWaitSync 起到了阻止闪屏的作用。
+
+
+
+
+
+
+
+如果说OpenGL ES是画笔，那Android的Surface就是画布。我们是可以使用OpenGL ES将图像画到 Surface中去的。但是OpenGL并不能直接在Android的Surface中画画，需要借助 EGLSurface 来将 Android的Surface关联起来。  
+
+
+
+
+
+
diff --git "a/VideoDevelopment/OpenGL/18.\345\205\266\344\273\226.md" "b/VideoDevelopment/OpenGL/18.\345\205\266\344\273\226.md"
new file mode 100644
index 00000000..72202177
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/18.\345\205\266\344\273\226.md"
@@ -0,0 +1,68 @@
+18.其他
+---
+
+
+视觉暂留： 人眼在观察景物时，光信号传入大脑神经，需经过一段短暂的时间，光的作用结束后，视觉形象并不立即消失，这种残留的视觉称“后像”，视觉的这一现象则被称为“视觉暂留”。   
+
+物体在快速运动时，当人眼所看到的影像消失后，人眼仍能继续保留其影像0.1 ~ 0.4秒左右的图像，所以当图像的刷新帧率高于每秒16帧时，在人眼看来就是不间断的显示。     
+
+
+#### 光栅扫描
+
+
+光栅扫描显示是目前的主流。     
+
+在光栅扫描显示中，电子束横向扫描屏幕，一次一行，从顶到底依次进行。      
+
+电子束在屏幕上逐点移动时，从被称为帧缓存的存储区取出每个像素点的强度值控制其显示状态。       
+这种实现原理决定了光栅扫描显示的刷新频率和图像复杂度无关，刷新频率可以是恒定的。    
+
+
+光栅扫描显示对屏幕上的每个点都有存储强度信息的能力(除颜色信息外，其他的像素信息也存在帧缓存中)，从而使得适用于包含阴影和彩色模式的逼真场景。    
+
+
+GPU的渲染流程:   
+
+GPU进行渲染时，会把数据先存储在帧缓冲区里，然后视频控制器读取帧缓冲区里的数据，完成数模转化，逐行扫描显示画面。   
+
+理论上，完美情况时，每扫描一张图，就显示一张，然后下一张也扫描完成等待刷新。   
+
+一次反复，屏幕就会保持流畅，那为什么有时候屏幕还会出现不流畅的现象？   
+
+
+- 撕裂:  
+
+当视频控制器读取完一帧画面显示后，会去帧缓存读取下一帧，如果帧缓存仍然保持着上一帧的数据没有被刷新，视频控制器照常工作读取帧缓存中的数据。     
+
+当寄存器工作到某一行时，帧缓存的数据被更新为下一帧，视频控制器就读取到新的数据，而此时已经显示的画面是上一帧的数据，后续将要显示的是下一帧的数据，撕裂也就产生了。    
+
+所以，撕裂的产生是因为帧缓存的刷新频率没有跟上屏幕的刷新频率，根本原因就是CPU或GPU工作超时。
+
+
+为了解决撕裂的问题，会使用垂直同步Vsync + 双缓冲的机制。  
+
+
+
+在VSync信号到来后，会在CPU中计算显示内容，比如视图的创建、布局计算、图片解码、文本绘制等。
+
+然后CPU会将计算好的数据提交到GPU，由GPU进行变换、合成、渲染。然后GPU会把渲染结果提交到帧缓存，等待下一次VSync信号到来时显示到屏幕上。
+
+由于垂直同步的机制，如果在一个VSync时间内，CPU或者GPU没有完成内容提交，则那一帧就会被丢弃，等待下一次机会再显示，而这时屏幕会刷新显示上一帧的内容。
+
+
+
+通过这种机制，就解决了撕裂的问题，但同时引入了新的问题 -- 掉帧。
+
+
+
+当CPU或GPU渲染流⽔线耗时过⻓，前后显示同一帧时，也就出现了掉帧现象(所以掉帧不是不渲染数据，而是重复渲染同一帧数据)。
+
+
+
+至于掉帧无法被完全解决，因为CPU或GPU的工作是不可预估的。只能尽量合理的使用CPU或GPU减少掉帧次数。
+
+
+
+
+
+ 
diff --git "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md" "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"
index 6ada2cb3..b1d5de88 100644
--- "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
+++ "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
@@ -9,7 +9,7 @@
  
 在 OpenGLES 开发中，纹理除了用于装饰物体表面，还可以用来作为存储数据的容器。
 
-那么在 OpenGLES 中，纹理实际上是一个可以被采样的复杂数据集合，是 GPU 的图像数据结构，纹理分为 2D 纹理、 立方图纹理和 3D 纹理。
+那么在 OpenGLES 中，***纹理实际上是一个可以被采样的复杂数据集合，是 GPU 的图像数据结构，纹理分为 2D 纹理、 立方图纹理和 3D 纹理。***
 
 2D 纹理是 OpenGLES 中最常用和最常见的纹理形式，是一个图像数据的二维数组。纹理中的一个单独数据元素称为纹素或纹理像素。
 

From 428cb4eed395020e4c6828c1e96ab35a0c17dad6 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Fri, 14 Mar 2025 17:03:51 +0800
Subject: [PATCH 203/213] update

---
 .../1.OpenGL\347\256\200\344\273\213.md"      | 15 ++++-
 ...45\231\250\350\257\255\350\250\200GLSL.md" |  7 ++
 ...\261\273\345\217\212Matrix\347\261\273.md" | 64 +++++++++++++++++++
 .../9.OpenGL ES\347\272\271\347\220\206.md"   | 28 +++++++-
 4 files changed, 111 insertions(+), 3 deletions(-)

diff --git "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md" "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
index b560e1f5..ec827301 100644
--- "a/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
+++ "b/VideoDevelopment/OpenGL/1.OpenGL\347\256\200\344\273\213.md"
@@ -366,7 +366,20 @@ GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, vbo.get(0));
 ```
 从调用glBindBuffer()这一刻起，我们使用的任何(在GL_ARRAY_BUFFER目标上的)缓冲调用都会用来配置当前绑定的缓冲(VBO)。      
 然后我们可以调用glBufferData()函数，它会把之前定义的顶点数据复制到缓冲的内存中(小助理把对应的数据单独记录下来了)。   
-      
+     
+
+
+绑定对象的过程有点类似设置铁路的道岔开关。     
+一旦设置了开关，从这条线路通过的所有列车都会驶向对应的轨道。    
+如果我们将开关设置到另一个状态，那么所有之后经过的列车都会驶向另一条轨道。OpenGL的对象也是如此。     
+
+总体上来说，在两种情况下我们需要绑定一个对象:   
+- 创建对象并初始化它所对应的数据是。   
+- 每次我们准备使用这个对象，而它并不是当前绑定的对象时。   
+
+
+
+ 
 ```C
 // glBufferData creates a new data store for the buffer object currently bound to target. 
 // glBufferData为当前绑定到的目标缓冲区对象创建一个新的数据存储
diff --git "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md" "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"
index 3bfe537b..12bb9706 100644
--- "a/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
+++ "b/VideoDevelopment/OpenGL/7.OpenGL ES\347\235\200\350\211\262\345\231\250\350\257\255\350\250\200GLSL.md"	
@@ -174,6 +174,13 @@ precision mediump int;
 
 #### Uniform
 
+Uniform是一种从CPU中的应用向GPU中的着色器发送数据的方式，但uniform和顶点属性有些不同： 
+
+- uniform是全局的(Global)。全局意味着uniform变量必须在每个着色器程序对象中都是独一无二的，而且它可以被着色器程序的任意着色器在任意阶段访问。   
+
+- 无论你把uniform值设置成什么，uniform会一直保存它们的数据，直到它们被重置或更新。    
+
+
 CPU在处理并行线程的时候，每个线程负责给完整图像的一部分配置颜色。    
 尽管每个线程和其他线程之间不能有数据交换，但我们能从CPU给每个线程输入数据。    
 因为显卡的架构，所有线程的输入值必须统一(uniform)，而且必须设为只读。      
diff --git "a/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md" "b/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
index f4278a1c..0df4bcff 100644
--- "a/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
+++ "b/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
@@ -138,6 +138,70 @@ GLES30.glVertexAttribPointer(1, 4, GLES30.GL_FLOAT, false, 0, colorBuffer);
 
 如果启用，那么当GLES30.glDrawArrays或者GLES30.glDrawElements被调用时，顶点属性数组会被使用。
 
+
+
+
+尽管现在已经知道了如何创建一个物体、着色、加入纹理，给它们一些细节的表现，但因为它们都还是静态的物体，仍不够有趣。      
+
+我们可以尝试着在每一帧改变物体的顶点并且重配置缓冲区从而使它移动，但这太繁琐了，而且会消耗很多的处理时间。     
+我们现在有一个更好的解决方案，使用(多个)矩阵(Matrix)对象可以更好的变换(Transform)一个物体。     
+
+为了更好的了解矩阵，需要先了解向量.   
+
+## 向量
+
+向量有一个方向(Direction)和大小(Magnitude，也叫强度或长度)。      
+
+你可以把向量想象成一个藏宝图上的指示: 向左走10步，向北走3步，然后向右走5步。    
+
+这里面左就是方向，10步就是向量的长度。       
+
+向量可以在任何维度(Dimension)上，但是我们通常只使用2至4维。    
+如果一个向量有2个维度，它表示一个平面的方向(想象一下2D的图像)。    
+当它有3个维度的时候它可以表达一个3D世界的方向。      
+
+
+
+![image](https://github.com/CharonChui/Pictures/blob/master/glsl_vector_0.png?raw=true)
+
+上图中有3个向量，每个向量在2D图像中都用一个箭头(x, y)表示。    
+***由于向量表示的是方向，起始于何处并不会改变它的值。***
+例如上面的向量v和w是相等的，尽管他们的起始点不同。         
+
+
+由于向量是一个方向，所以有些时候会很难形象的将它们用位置(Position)表示出来。     
+为了让其更为直观，我们通常设定这个方向的原点为(0, 0, 0),然后指定一个方向，对应一个点，使其变为位置向量(Position Vector)。     
+你也可以把起点设置为其他的点，然后说这个向量从这个点起始指向另一个点。     
+
+比如说位置向量(3, 5)在图像中的起点会是(0, 0)，并会指向(3, 5)。我们可以使用向量在2D或3D空间中表示方向与位置。      
+
+
+### 向量相乘
+
+两个向量相乘是一种很奇怪的情况。     
+普通的乘法在向量上是没有定义的，因为它在视觉上是没有意义的。     
+
+但是在相乘的时候我们有两种特定情况可以选择:     
+
+- 一个是点乘(Dot Product)
+- 一个是叉乘(Cross Product)
+
+
+##### 点乘
+
+两个向量的点乘等于它们的数乘结果乘以两个向量之间夹角的余弦值。    
+
+##### 叉乘 
+
+叉乘只在3D空间中有定义，它需要两个不平行向量作为输入，生成一个正交于两个输入向量的第三个向量。    
+如果输入的两个向量也是正交的，那么叉乘之后将会产生3个相互正交的向量。   
+下面的图就是3D控件中叉乘的样子:     
+
+![image](https://github.com/CharonChui/Pictures/blob/master/opengl_chacheng.png?raw=true)
+
+
+
+
 ## Matrix
 
 Matrix就是专门设计出来帮助我们简化矩阵和向量运算操作的，里面所有的实现原理都是线性代数中的运算。
diff --git "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md" "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"
index b1d5de88..d8258366 100644
--- "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
+++ "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
@@ -11,7 +11,7 @@
 
 那么在 OpenGLES 中，***纹理实际上是一个可以被采样的复杂数据集合，是 GPU 的图像数据结构，纹理分为 2D 纹理、 立方图纹理和 3D 纹理。***
 
-2D 纹理是 OpenGLES 中最常用和最常见的纹理形式，是一个图像数据的二维数组。纹理中的一个单独数据元素称为纹素或纹理像素。
+***2D 纹理是 OpenGLES 中最常用和最常见的纹理形式，是一个图像数据的二维数组。纹理中的一个单独数据元素称为纹素或纹理像素。***
 
 立方图纹理是一个由 6 个单独的 2D 纹理面组成的纹理。立方图纹理像素的读取通过使用一个三维坐标（s,t,r）作为纹理坐标。
 
@@ -129,9 +129,29 @@ OpenGL不能直接加载jpg或者png这类被编码的压缩格式，需要加
 
 ### 纹理过滤
 
+纹理坐标不依赖于分辨率，它可以是任意浮点值，所以OpenGL需要知道怎样将纹理像素映射到纹理坐标。      
+
+当你有一个很大的物体但是纹理的分辨率很低的时候这就变得很重要了。
+
+
 当我们通过光栅化将图形处理成一个个小片段的时候，再将纹理采样，渲染到指定位置上时，通常会遇到纹理元素和小片段并非一一对应。      
 这时候，会出现纹理的压缩或者放大。那么在这两种情况下，就会有不同的处理方案，这就是纹理过滤了。
 
+
+纹理过滤有很多选项，这里只说最重要的两项: GL_NEAREST和GL_LINEAR。   
+
+- GL_NEAREST: 临近过滤，是OpenGL默认的纹理过滤方式，会选择中心点最接近纹理坐标的那个像素。      
+
+- GL_LINEAR: 线性过滤，会基于纹理坐标附近的纹理像素，计算出一个插值，近似出这些纹理像素之间的颜色。一个纹理像素的中心距离纹理坐标越近，那么这个纹理像素的颜色对最终的样本颜色的贡献越大。     
+
+
+
+如果在一个很大的物体上应用一张低分辨率的纹理会发生什么呢(纹理被放大了，每个纹理像素都能看到)？
+
+GL_NEAREST产生了颗粒状的图案，我们能够清晰看到组成纹理的像素。    
+而GL_LINEAR能够产生更平滑的图案，很难看出单个的纹理像素。GL_LINEAR可以产生更真实的输出。      
+
+
 ### 纹理对象和纹理的加载
 
 纹理应用的第一步是创建一个纹理对象。纹理对象是一个容器对象，保存渲染所需的纹理数据，例如图像数据、过滤模式和包装模式。         
@@ -352,7 +372,7 @@ color = texture(samp, tc);
 纹理的绘制:  
 
 ```java
-//激活纹理，设置当前活动的纹理单元为单元0
+//激活纹理单元，设置当前活动的纹理单元为单元0
 GLES30.glActiveTexture(GLES30.GL_TEXTURE0);
 //绑定纹理，将纹理id绑定到当前活动的纹理单元上
 GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, textureId);
@@ -365,6 +385,10 @@ GLES20.glUniform1i(aTextureLocation, 0);
 通过纹理单元赋值给采样器，我们可以一次绑定多个纹理，只要我们在使用的时候激活纹理。
 
 
+OpenGL至少保证有16个纹理单元供你使用，也就是说你可以激活从GL_TEXTURE0到GL_TEXTURE15。         
+它们都是按顺序定义的，所以我们也可以通过GL_TEXUTURE0 + 8的方式获得GL_TEXTURE8，这在需要循环一些纹理单元的时候会很有用。    
+
+
 ```java
   public class TextureRender extends BaseGLSurfaceViewRenderer {
       private final FloatBuffer vertextBuffer;

From 0e3f60b52ddf3a40c4e4755d1fbb2f282490731d Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 16 Jun 2025 19:45:42 +0800
Subject: [PATCH 204/213] add algorithm part

---
 ...11\345\272\217\346\225\260\347\273\204.md" |  85 +++++++
 ...\350\267\203\346\270\270\346\210\217II.md" |  64 +++++
 "Algorithm/11.H\346\214\207\346\225\260.md"   | 231 ++++++++++++++++++
 ...17\346\234\272\345\205\203\347\264\240.md" | 105 ++++++++
 ...04\347\232\204\344\271\230\347\247\257.md" | 127 ++++++++++
 ...4.\345\212\240\346\262\271\347\253\231.md" | 140 +++++++++++
 ...06\345\217\221\347\263\226\346\236\234.md" | 174 +++++++++++++
 ...6.\346\216\245\351\233\250\346\260\264.md" | 148 +++++++++++
 ...73\351\231\244\345\205\203\347\264\240.md" | 118 +++++++++
 ...04\351\207\215\345\244\215\351\241\271.md" |  78 ++++++
 ...\351\207\215\345\244\215\351\241\271II.md" |  80 ++++++
 ...32\346\225\260\345\205\203\347\264\240.md" |  86 +++++++
 ...56\350\275\254\346\225\260\347\273\204.md" |  87 +++++++
 ...00\344\275\263\346\227\266\346\234\272.md" |  76 ++++++
 ...\344\275\263\346\227\266\346\234\272II.md" | 105 ++++++++
 ...63\350\267\203\346\270\270\346\210\217.md" |  90 +++++++
 .../python3\345\205\245\351\227\250.md"       |  10 +-
 ...15\347\224\250\345\216\237\347\220\206.md" |  15 ++
 ...4.\345\256\236\344\276\213\345\214\226.md" |  16 ++
 .../OpenGL/18.\345\205\266\344\273\226.md"    |   6 +
 ...70\346\234\272\351\242\204\350\247\210.md" |  43 ++++
 ...25\345\210\266\350\247\206\351\242\221.md" |  50 ++++
 ...66\344\270\211\350\247\222\345\275\242.md" |  20 +-
 ...\261\273\345\217\212Matrix\347\261\273.md" |   8 +-
 .../9.OpenGL ES\347\272\271\347\220\206.md"   |  41 ++++
 25 files changed, 1992 insertions(+), 11 deletions(-)
 create mode 100644 "Algorithm/1.\345\220\210\345\271\266\344\270\244\344\270\252\346\234\211\345\272\217\346\225\260\347\273\204.md"
 create mode 100644 "Algorithm/10.\350\267\263\350\267\203\346\270\270\346\210\217II.md"
 create mode 100644 "Algorithm/11.H\346\214\207\346\225\260.md"
 create mode 100644 "Algorithm/12.O(1) \346\227\266\351\227\264\346\217\222\345\205\245\343\200\201\345\210\240\351\231\244\345\222\214\350\216\267\345\217\226\351\232\217\346\234\272\345\205\203\347\264\240.md"
 create mode 100644 "Algorithm/13.\351\231\244\350\207\252\350\272\253\344\273\245\345\244\226\346\225\260\347\273\204\347\232\204\344\271\230\347\247\257.md"
 create mode 100644 "Algorithm/14.\345\212\240\346\262\271\347\253\231.md"
 create mode 100644 "Algorithm/15.\345\210\206\345\217\221\347\263\226\346\236\234.md"
 create mode 100644 "Algorithm/16.\346\216\245\351\233\250\346\260\264.md"
 create mode 100644 "Algorithm/2.\347\247\273\351\231\244\345\205\203\347\264\240.md"
 create mode 100644 "Algorithm/3.\345\210\240\351\231\244\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271.md"
 create mode 100644 "Algorithm/4.\345\210\240\351\231\244\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271II.md"
 create mode 100644 "Algorithm/5.\345\244\232\346\225\260\345\205\203\347\264\240.md"
 create mode 100644 "Algorithm/6.\350\275\256\350\275\254\346\225\260\347\273\204.md"
 create mode 100644 "Algorithm/7.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.md"
 create mode 100644 "Algorithm/8.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272II.md"
 create mode 100644 "Algorithm/9.\350\267\263\350\267\203\346\270\270\346\210\217.md"
 create mode 100644 "SourceAnalysis/RecyclerView\345\244\215\347\224\250\345\216\237\347\220\206.md"
 create mode 100644 "VideoDevelopment/OpenGL/19.\347\233\270\346\234\272\351\242\204\350\247\210.md"
 create mode 100644 "VideoDevelopment/OpenGL/20.\351\200\232\350\277\207OpenGL\351\242\204\350\247\210\345\271\266\345\275\225\345\210\266\350\247\206\351\242\221.md"

diff --git "a/Algorithm/1.\345\220\210\345\271\266\344\270\244\344\270\252\346\234\211\345\272\217\346\225\260\347\273\204.md" "b/Algorithm/1.\345\220\210\345\271\266\344\270\244\344\270\252\346\234\211\345\272\217\346\225\260\347\273\204.md"
new file mode 100644
index 00000000..2dc0dda4
--- /dev/null
+++ "b/Algorithm/1.\345\220\210\345\271\266\344\270\244\344\270\252\346\234\211\345\272\217\346\225\260\347\273\204.md"
@@ -0,0 +1,85 @@
+1.合并两个有序数组
+===
+
+
+### 题目
+
+给你两个按`非递减顺序`排列的整数数组`nums1`和`nums2`，另有两个整数`m`和`n`，分别表示`nums1`和`nums2`中的元素数目。        
+
+请你`合并`nums2到nums1中，使合并后的数组同样按非递减顺序排列。     
+
+注意：最终，合并后数组不应由函数返回，而是存储在数组nums1中。为了应对这种情况，nums1的初始长度为`m + n`，其中前m个元素表示应合并的元素，后n个元素为0，应忽略。nums2的长度为n。
+
+
+
+示例 1：
+
+输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
+输出：[1,2,2,3,5,6]
+解释：需要合并 [1,2,3] 和 [2,5,6] 。
+合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。
+
+示例 2: 
+
+输入：nums1 = [1], m = 1, nums2 = [], n = 0
+输出：[1]
+解释：需要合并 [1] 和 [] 。
+合并结果是 [1] 。
+
+示例 3：
+
+输入：nums1 = [0], m = 0, nums2 = [1], n = 1
+输出：[1]
+解释：需要合并的数组是 [] 和 [1] 。
+合并结果是 [1] 。
+注意，因为 m = 0 ，所以 nums1 中没有元素。nums1 中仅存的 0 仅仅是为了确保合并结果可以顺利存放到 nums1 中。
+
+
+
+### 思路
+
+逆向双指针:   
+- nums1中是非递减的数组。
+- nums2中也是非递减数组。
+- 所以我们要做的就是把nums1中前m个元素与nums2中的元素进行倒序比较，将大的值倒序放到nums1中的后面。
+- 因为nums1中的数据已经是非递减的了，所以等nums2中的内容都放置完就可以结束。
+
+```python
+class Solution:
+    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
+        index = m + n - 1
+        p1 = m - 1
+        p2 = n - 1
+        while p2 >= 0:
+            if p1 >= 0 and nums1[p1] >= nums2[p2]:
+                nums1[index] = nums1[p1]
+                index += 1
+                p1 -= 1
+            else:
+                nums1[index] = nums2[p2]
+                index += 1
+                p2 -= 1
+```
+
+```kotlin
+class Solution {
+    fun merge(nums1: IntArray, m: Int, nums2: IntArray, n: Int): Unit {
+        var index = nums1.lastIndex
+        var r1 = m - 1
+        var r2 = n - 1
+        while(r2 >= 0) {
+            if (r1 >= 0 && nums1[r1] >= nums2[r2]) {
+                nums1[index --] = nums1[r1--]
+            } else {
+                nums1[index --] = nums2[r2 --]
+            } 
+        }
+    }
+}
+```
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/10.\350\267\263\350\267\203\346\270\270\346\210\217II.md" "b/Algorithm/10.\350\267\263\350\267\203\346\270\270\346\210\217II.md"
new file mode 100644
index 00000000..cd9ecad4
--- /dev/null
+++ "b/Algorithm/10.\350\267\263\350\267\203\346\270\270\346\210\217II.md"
@@ -0,0 +1,64 @@
+10.跳跃游戏II
+===
+
+
+### 题目
+
+给定一个长度为 n 的 0 索引整数数组 nums。初始位置为 nums[0]。
+
+每个元素 nums[i] 表示从索引 i 向后跳转的最大长度。换句话说，如果你在 nums[i] 处，你可以跳转到任意 nums[i + j] 处:
+
+0 <= j <= nums[i] 
+i + j < n
+返回到达 nums[n - 1] 的最小跳跃次数。生成的测试用例可以到达 nums[n - 1]。
+
+ 
+
+示例 1:
+
+输入: nums = [2,3,1,1,4]
+输出: 2
+解释: 跳到最后一个位置的最小跳跃数是 2。
+     从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。
+示例 2:
+
+输入: nums = [2,3,0,1,4]
+输出: 2
+
+
+### 思路
+
+
+贪心的思路，局部最优：当前可移动距离尽可能多走，如果还没到终点，步数再加一。整体最优：一步尽可能多走，从而达到最少步数。
+
+所以真正解题的时候，要从覆盖范围出发，不管怎么跳，覆盖范围内一定是可以跳到的，以最小的步数增加覆盖范围，覆盖范围一旦覆盖了终点，得到的就是最少步数！
+
+这里需要统计两个覆盖范围，当前这一步的最大覆盖和下一步最大覆盖。
+
+- 如下图，开始的位置是 2，可跳的范围是橙色的。然后因为 3 可以跳的更远，所以跳到 3 的位置。      
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/jump_2_1.png?raw=true)
+- 然后现在的位置就是 3 了，能跳的范围是橙色的，然后因为 4 可以跳的更远，所以下次跳到 4 的位置。     
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/jump_2_2.png?raw=true)
+
+
+```python
+
+class Solution:
+    def jump(self, nums: List[int]) -> int:
+        end = 0
+        maxPosition = 0
+        steps = 0
+        for i in range(len(nums) - 1):
+            maxPosition = max(maxPosition, i + nums[i])
+            if i == end:
+                steps += 1
+                end = maxPosition
+                
+        return steps       
+```
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/11.H\346\214\207\346\225\260.md" "b/Algorithm/11.H\346\214\207\346\225\260.md"
new file mode 100644
index 00000000..5be403e0
--- /dev/null
+++ "b/Algorithm/11.H\346\214\207\346\225\260.md"
@@ -0,0 +1,231 @@
+11.H指数
+===
+
+
+### 题目
+
+给你一个整数数组 citations ，其中 citations[i] 表示研究者的第 i 篇论文被引用的次数。计算并返回该研究者的 h 指数。
+
+根据维基百科上 h 指数的定义：h 代表“高引用次数” ，一名科研人员的 h 指数 是指他（她）至少发表了 h 篇论文，并且 至少 有 h 篇论文被引用次数大于等于 h 。如果 h 有多种可能的值，h 指数 是其中最大的那个。
+
+ 
+
+示例 1：
+
+输入：citations = [3,0,6,1,5]
+输出：3 
+解释：给定数组表示研究者总共有 5 篇论文，每篇论文相应的被引用了 3, 0, 6, 1, 5 次。
+     由于研究者有 3 篇论文每篇 至少 被引用了 3 次，其余两篇论文每篇被引用 不多于 3 次，所以她的 h 指数是 3。
+示例 2：
+
+输入：citations = [1,3,1]
+输出：1
+
+### 思路
+
+翻译： 数组中有h个不小于h的值，求最大的h
+
+
+至少有h篇论文，每一篇至少被引用次数为h，听起来很绕，但是以用例[0, 1, 3, 5, 6]来分析： 
+
+- h指数无非就是5或4或3或2或1或0
+
+- 那么如果数组中最小的引用次数都大于等于5，那么其他的不用看了，h就是取最大值5
+
+- 如果最小值不满足，那么如果数组中倒数第二小值如果大于等于4，那么一定有4个是大于等于4的
+
+- 这就是h指数
+
+
+
+
+
+##### 方法一：排序
+
+h肯定不会超过数组的长度。
+
+[0, 1, 3, 5, 6]
+
+- 从小到大排序。
+- 排序后从头开始遍历，如果最小的值，都大于数组的size，那就是size
+- 如果上面不满足，那第二小的值如果大于数组的size - 1，那就是size - 1
+- 所以遍历条件就是 for (int i = 0; i < size; i ++ ) { if (nums[i] >= size - 1)}
+- 遍历排序后的数组，如果数组中该位置的值>h，那就h++然后继续遍历下一个
+
+```java
+public int hIndex(int[] citations) {
+   Arrays.sort(citations);
+   for(int i = 0; i < citations.length; i++){
+       if( citations[i] >= (citations.length -i)){
+           return  citations.length -i;
+       }
+   }
+   return 0;
+}
+```
+
+
+最终的时间复杂度与排序算法的时间复杂度有关
+
+复杂度分析
+
+- 时间复杂度：O(nlogn)，其中 n 为数组 citations 的长度。即为排序的时间复杂度。
+
+- 空间复杂度：O(logn)，其中 n 为数组 citations 的长度。即为排序的空间复杂度。
+
+
+##### 方法二：计数排序
+
+根据上述解法我们发现，最终的时间复杂度与排序算法的时间复杂度有关。
+
+所以我们可以使用计数排序算法，新建并维护一个数组 counter 用来记录当前引用次数的论文有几篇。它的值可以是0 ~ n，所以数组的长度是n + 1
+
+[0, 1, 3, 5, 6]
+
+
+- 我们遍历数组 citations，将引用次数大于 n 的论文都当作引用次数为 n 的论文，然后将每篇论文的引用次数作为下标，将 cnt 中对应的元素值加 1。这样我们就统计出了每个引用次数对应的论文篇数。
+
+```
+counter[0] = 1
+counter[1] = 1
+counter[2] = 0
+counter[3] = 1
+// 无值，默认0
+counter[4] = 0
+// 引用次数为5的论文有2篇
+counter[5] = 2
+```
+
+- 最后我们可以从后向前遍历数组 counter，因为要找最大的H值，所以这个时候要倒序从n到0遍历遍历，找出从后往前遍历时第一个满足引用次数>i的值，就是最大的h值。
+
+- 注意要用累加，因为引用次数为5的2篇，一定也能满足引用次数>=3的条件
+
+```java
+public class Solution {
+    public int hIndex(int[] citations) {
+        int n = citations.length, tot = 0;
+        int[] counter = new int[n + 1];
+        for (int i = 0; i < n; i++) {
+            if (citations[i] >= n) {
+                counter[n]++;
+            } else {
+                counter[citations[i]]++;
+            }
+        }
+        for (int i = n; i >= 0; i--) {
+            tot += counter[i];
+            if (tot >= i) {
+                return i;
+            }
+        }
+        return 0;
+    }
+}
+```
+
+复杂度分析
+
+时间复杂度：O(n)，其中 n 为数组 citations 的长度。需要遍历数组 citations 一次，以及遍历长度为 n+1 的数组 counter 一次。
+
+空间复杂度：O(n)，其中 n 为数组 citations 的长度。需要创建长度为 n+1 的数组 counter。
+
+
+##### 方法三：二分法
+
+所谓的 h 指数是指一个具体的数值，该数值为“最大”的满足「至少发表了 x 篇论文，且每篇论文至少被引用 x 次」定义的合法数，重点是“最大”。
+
+给定所有论文的引用次数情况为[3,0,6,1,5]，可统计满足定义的数值有哪些：
+
+```
+h=0，含义为「至少发表了 0 篇，且这 0 篇论文至少被引用 0 次」，空集即满足，恒成立；
+
+h=1，含义为「至少发表了 1 篇，且这 1 篇论文至少被引用 1 次」，可以找到这样的组合，如 [3]，成立；
+
+h=2，含义为「至少发表了 2 篇，且这 2 篇论文至少被引用 2 次」，可以找到这样的组合，如 [3, 6]，成立；
+
+h=3，含义为「至少发表了 3 篇，且这 3 篇论文至少被引用 3 次」，可以找到这样的组合，如 [3, 6, 5]，成立；
+
+h=4，含义为「至少发表了 4 篇，且这 4 篇论文至少被引用 4 次」，找不到这样的组合，不成立；
+
+h=5，含义为「至少发表了 5 篇，且这 5 篇论文至少被引用 5 次」，找不到这样的组合，不成立；
+```
+实际上，当遇到第一个无法满足的数时，更大的数值就没必要找了。
+
+
+基于此分析，我们发现对于任意的 citations数组（论文总数量为该数组长度 n），都必然对应了一个最大的 h 值，且小于等于该 h 值的情况均满足，大于该 h 值的均不满足。
+
+那么，在以最大 h 值为分割点的数轴上具有「二段性」，可通过「二分」求解该分割点（答案）。
+
+最后考虑在什么值域范围内进行二分？
+
+一个合格的二分范围，仅需确保答案在此范围内即可。
+
+再回看我们关于 h 的定义「至少发表了 x 篇论文，且每篇论文至少被引用 x 次」
+综上，我们只需要在 [0,n] 范围进行二分即可。
+
+
+设查找范围的初始左边界 left 为 0，初始右边界 right 为 n。每次在查找范围内取中点 mid，同时扫描整个数组，判断是否至少有 mid 个数大于 mid。如果有，说明要寻找的 h 在搜索区间的右边，反之则在左边。
+
+二分的本质：前半部分符合要求、后半部分不符合要求，找出符合要求的最大索引
+
+
+```java
+class Solution {
+    public int hIndex(int[] cs) {
+        int n = cs.length;
+        int l = 0, r = n;
+        while (l < r) {
+        	// 加1 是为了防止死循环
+            int mid = (l + r + 1) >> 1;
+            if (check(cs, mid)) l = mid;
+            else r = mid - 1;
+        }
+        return r;
+    }
+    // 判断是否存在至少mid篇论文的引用次数至少为mid。
+    boolean check(int[] cs, int mid) {
+        int ans = 0;
+        for (int i : cs) if (i >= mid) ans++;
+        return ans >= mid;
+    }
+}
+```
+
+
+
+###### 上面为什么要加1
+
+- 这是因为整数除法的向下取整特性。
+- 在计算mid时，如果使用(l+r)/2，当l和r相邻时（例如l=2, r=3），则mid=(2+3)/2=2（整数除法向下取整）。
+- 如果此时check(mid)为真，那么我们会执行l=mid，即l=2，然后循环继续，再次计算mid=(2+3)/2=2，这样就进入了死循环。
+
+为了避免这种死循环，我们使用(l + r + 1) / 2，使得当l和r相邻时，mid会等于r（因为(2+3+1)/2=6/2=3），然后无论走哪个分支，循环都会结束（因为执行l=3后l等于r，或执行r=mid-1=2后l等于r）。
+所以，加1是为了避免在只剩两个数时陷入死循环，因为我们要找的是右边界（最大值）。
+
+
+
+###### 例子：
+
+- citations = [3,0,6,1,5]，用上述二分法：
+- 初始化：l=0, r=5
+- mid = (0+5+1)/2 = 3，检查check(3): 统计>=3的个数，为3（3,5,6）-> 满足，所以l=3
+- 接下来：l=3, r=5，mid=(3+5+1)/2=9/2=4（整数除法取整为4），检查check(4):统计>=4的个数，有2篇（5,6）不满足4（因为需要至少4篇）
+- 所以r=3循环结束，返回3。
+
+
+
+
+复杂度分析
+
+时间复杂度：O(nlogn)，其中 n 为数组 citations 的长度。需要进行 logn 次二分搜索，每次二分搜索需要遍历数组 citations 一次。
+空间复杂度：O(1)，只需要常数个变量来进行二分搜索。
+
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/12.O(1) \346\227\266\351\227\264\346\217\222\345\205\245\343\200\201\345\210\240\351\231\244\345\222\214\350\216\267\345\217\226\351\232\217\346\234\272\345\205\203\347\264\240.md" "b/Algorithm/12.O(1) \346\227\266\351\227\264\346\217\222\345\205\245\343\200\201\345\210\240\351\231\244\345\222\214\350\216\267\345\217\226\351\232\217\346\234\272\345\205\203\347\264\240.md"
new file mode 100644
index 00000000..469f6e99
--- /dev/null
+++ "b/Algorithm/12.O(1) \346\227\266\351\227\264\346\217\222\345\205\245\343\200\201\345\210\240\351\231\244\345\222\214\350\216\267\345\217\226\351\232\217\346\234\272\345\205\203\347\264\240.md"	
@@ -0,0 +1,105 @@
+12.O(1) 时间插入、删除和获取随机元素
+===
+
+
+### 题目
+
+实现RandomizedSet 类：
+
+RandomizedSet() 初始化 RandomizedSet 对象
+bool insert(int val) 当元素 val 不存在时，向集合中插入该项，并返回 true ；否则，返回 false 。
+bool remove(int val) 当元素 val 存在时，从集合中移除该项，并返回 true ；否则，返回 false 。
+int getRandom() 随机返回现有集合中的一项（测试用例保证调用此方法时集合中至少存在一个元素）。每个元素应该有 相同的概率 被返回。
+你必须实现类的所有函数，并满足每个函数的 平均 时间复杂度为 O(1) 。
+
+ 
+
+示例：
+
+输入
+["RandomizedSet", "insert", "remove", "insert", "getRandom", "remove", "insert", "getRandom"]
+[[], [1], [2], [2], [], [1], [2], []]
+输出
+[null, true, false, true, 2, true, false, 2]
+
+解释
+RandomizedSet randomizedSet = new RandomizedSet();
+randomizedSet.insert(1); // 向集合中插入 1 。返回 true 表示 1 被成功地插入。
+randomizedSet.remove(2); // 返回 false ，表示集合中不存在 2 。
+randomizedSet.insert(2); // 向集合中插入 2 。返回 true 。集合现在包含 [1,2] 。
+randomizedSet.getRandom(); // getRandom 应随机返回 1 或 2 。
+randomizedSet.remove(1); // 从集合中移除 1 ，返回 true 。集合现在包含 [2] 。
+randomizedSet.insert(2); // 2 已在集合中，所以返回 false 。
+randomizedSet.getRandom(); // 由于 2 是集合中唯一的数字，getRandom 总是返回 2 。
+ 
+
+提示:       
+
+- -231 <= val <= 231 - 1
+- 最多调用 insert、remove 和 getRandom 函数 2 * 105 次
+- 在调用 getRandom 方法时，数据结构中 至少存在一个 元素。
+
+### 思路
+
+
+题目要求插入、删除、随机的时间复杂度为 O(1) 。
+
+- 变长数组可以在 O(1) 的时间内完成获取随机元素操作，但是由于无法在 O(1) 的时间内判断元素是否存在，因此不能在 O(1) 的时间内完成插入和删除操作。       
+- 哈希表可以在 O(1) 的时间内完成插入和删除操作，但是由于无法根据下标定位到特定元素，因此不能在 O(1) 的时间内完成获取随机元素操作。      
+- 为了满足插入、删除和获取随机元素操作的时间复杂度都是 O(1)，需要将变长数组和哈希表结合，变长数组中存储元素，哈希表中存储每个元素在变长数组中的下标。
+
+```java
+class RandomizedSet {
+    List<Integer> nums;
+    Map<Integer, Integer> indices;
+    Random random;
+
+    public RandomizedSet() {
+        nums = new ArrayList<Integer>();
+        indices = new HashMap<Integer, Integer>();
+        random = new Random();
+    }
+
+    public boolean insert(int val) {
+        if (indices.containsKey(val)) {
+            return false;
+        }
+        int index = nums.size();
+        nums.add(val);
+        indices.put(val, index);
+        return true;
+    }
+
+    public boolean remove(int val) {
+        if (!indices.containsKey(val)) {
+            return false;
+        }
+        int index = indices.get(val);
+        int last = nums.get(nums.size() - 1);
+        nums.set(index, last);
+        indices.put(last, index);
+        nums.remove(nums.size() - 1);
+        indices.remove(val);
+        return true;
+    }
+
+    public int getRandom() {
+        int randomIndex = random.nextInt(nums.size());
+        return nums.get(randomIndex);
+    }
+}
+```
+
+
+复杂度分析:    
+
+- 时间复杂度：初始化和各项操作的时间复杂度都是 O(1)。
+
+- 空间复杂度：O(n)，其中 n 是集合中的元素个数。存储元素的数组和哈希表需要 O(n) 的空间。
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/13.\351\231\244\350\207\252\350\272\253\344\273\245\345\244\226\346\225\260\347\273\204\347\232\204\344\271\230\347\247\257.md" "b/Algorithm/13.\351\231\244\350\207\252\350\272\253\344\273\245\345\244\226\346\225\260\347\273\204\347\232\204\344\271\230\347\247\257.md"
new file mode 100644
index 00000000..6b555aeb
--- /dev/null
+++ "b/Algorithm/13.\351\231\244\350\207\252\350\272\253\344\273\245\345\244\226\346\225\260\347\273\204\347\232\204\344\271\230\347\247\257.md"
@@ -0,0 +1,127 @@
+13.除自身以外数组的乘积
+===
+
+
+### 题目
+
+给你一个整数数组 nums，返回 数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积 。
+
+题目数据 保证 数组 nums之中任意元素的全部前缀元素和后缀的乘积都在  32 位 整数范围内。
+
+请 不要使用除法，且在 O(n) 时间复杂度内完成此题。
+
+ 
+
+示例 1:
+
+输入: nums = [1,2,3,4]
+输出: [24,12,8,6]
+示例 2:
+
+输入: nums = [-1,1,0,-3,3]
+输出: [0,0,9,0,0]
+ 
+
+提示:    
+
+- 2 <= nums.length <= 105
+- -30 <= nums[i] <= 30
+- 输入 保证 数组 answer[i] 在  32 位 整数范围内
+
+### 思路
+
+
+先计算数组中所有元素的乘积，然后将总的乘积除以数组的中每个元素x就是除自身值以外数组的乘积。     
+
+但是这样有个问题，如果数组中有一个元素是0，那这个方法就失效了，而且题目中说了不能使用除法运算。 
+
+我们可以分解为两部分： 
+
+- 得到索引左侧所有数字的乘积L
+- 得到索引右侧所有数字的乘积R
+- 两部分相乘
+
+
+```java
+
+class Solution {
+    public int[] productExceptSelf(int[] nums) {
+        int length = nums.length;
+
+        // L 和 R 分别表示左右两侧的乘积列表
+        int[] L = new int[length];
+        int[] R = new int[length];
+
+        int[] answer = new int[length];
+
+        // L[i] 为索引 i 左侧所有元素的乘积
+        // 对于索引为 '0' 的元素，因为左侧没有元素，所以 L[0] = 1
+        L[0] = 1;
+        for (int i = 1; i < length; i++) {
+            L[i] = nums[i - 1] * L[i - 1];
+        }
+
+        // R[i] 为索引 i 右侧所有元素的乘积
+        // 对于索引为 'length-1' 的元素，因为右侧没有元素，所以 R[length-1] = 1
+        R[length - 1] = 1;
+        for (int i = length - 2; i >= 0; i--) {
+            R[i] = nums[i + 1] * R[i + 1];
+        }
+
+        // 对于索引 i，除 nums[i] 之外其余各元素的乘积就是左侧所有元素的乘积乘以右侧所有元素的乘积
+        for (int i = 0; i < length; i++) {
+            answer[i] = L[i] * R[i];
+        }
+
+        return answer;
+    }
+}
+```
+
+复杂度分析:   
+
+- 时间复杂度：O(N)，其中 N 指的是数组 nums 的大小。预处理 L 和 R 数组以及最后的遍历计算都是 O(N) 的时间复杂度。
+- 空间复杂度：O(N)，其中 N 指的是数组 nums 的大小。使用了 L 和 R 数组去构造答案，L 和 R 数组的长度为数组 nums 的大小。
+
+
+尽管上面的方法已经能够很好的解决这个问题，但是空间复杂度并不为常数。
+
+- 由于输出数组不算在空间复杂度内，那么我们可以将 L 或 R 数组用输出数组来计算。也就是不再新申请L和R数组，而只是用一个变量记录索引右侧元素的乘积之和。
+- 第一遍遍历的时候将answer数组的值都填充为索引左侧元素的值(也就是上面方法中L的值)
+- 再一次后续遍历的时候取answer中的值和数组索引右侧元素乘积的和值相乘并赋值到answer中。这个时候answer中的值就已经是乘积的和值了。
+
+
+```java
+class Solution {
+   public int[] productExceptSelf(int[] nums) {
+       int n = nums.length;
+       int[] ans = new int[n];
+       //初始化ans都为1
+       for (int i = 0; i < n; i++) {
+           ans[i] = 1;
+       }
+       //左侧
+       int L = 1;
+       for(int i = 0; i < n; i++){
+           ans[i] *= L;
+           L *= nums[i];
+       }
+       //右侧
+       int R = 1;
+       for(int i = n - 1; i >= 0; i--){
+           ans[i] *= R;
+           R *= nums[i];
+       }
+       return ans;
+   } 
+}
+```
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/14.\345\212\240\346\262\271\347\253\231.md" "b/Algorithm/14.\345\212\240\346\262\271\347\253\231.md"
new file mode 100644
index 00000000..b39a9edd
--- /dev/null
+++ "b/Algorithm/14.\345\212\240\346\262\271\347\253\231.md"
@@ -0,0 +1,140 @@
+14.加油站
+===
+
+
+### 题目
+
+在一条环路上有 n 个加油站，其中第 i 个加油站有汽油 gas[i] 升。
+
+你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发，开始时油箱为空。
+
+给定两个整数数组 gas 和 cost ，如果你可以按顺序绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1 。如果存在解，则 保证 它是 唯一 的。
+
+ 
+
+示例 1:
+
+输入: gas = [1,2,3,4,5], cost = [3,4,5,1,2]
+输出: 3
+解释:
+从 3 号加油站(索引为 3 处)出发，可获得 4 升汽油。此时油箱有 = 0 + 4 = 4 升汽油
+开往 4 号加油站，此时油箱有 4 - 1 + 5 = 8 升汽油
+开往 0 号加油站，此时油箱有 8 - 2 + 1 = 7 升汽油
+开往 1 号加油站，此时油箱有 7 - 3 + 2 = 6 升汽油
+开往 2 号加油站，此时油箱有 6 - 4 + 3 = 5 升汽油
+开往 3 号加油站，你需要消耗 5 升汽油，正好足够你返回到 3 号加油站。
+因此，3 可为起始索引。
+示例 2:
+
+输入: gas = [2,3,4], cost = [3,4,3]
+输出: -1
+解释:
+你不能从 0 号或 1 号加油站出发，因为没有足够的汽油可以让你行驶到下一个加油站。
+我们从 2 号加油站出发，可以获得 4 升汽油。 此时油箱有 = 0 + 4 = 4 升汽油
+开往 0 号加油站，此时油箱有 4 - 3 + 2 = 3 升汽油
+开往 1 号加油站，此时油箱有 3 - 3 + 3 = 3 升汽油
+你无法返回 2 号加油站，因为返程需要消耗 4 升汽油，但是你的油箱只有 3 升汽油。
+因此，无论怎样，你都不可能绕环路行驶一周。
+ 
+
+提示:
+
+n == gas.length == cost.length
+1 <= n <= 105
+0 <= gas[i], cost[i] <= 104
+输入保证答案唯一。
+
+### 思路
+
+- 题目有一点很重要： 如果存在解，则 保证 它是 唯一 的。
+- 能跑一圈的前提有两个:     
+    - 每一站的油量都能达到下一站
+    - 一圈下来剩下的油量是大于等于0的
+
+- 我们首先检查第 0 个加油站，并试图判断能否环绕一周；如果不能，就从第一个无法到达的加油站开始继续检查。
+
+
+```python
+class Solution:
+    def canCompleteCircuit(self, gas: List[int], cost: List[int]) -> int:
+        n = len(gas)
+        start = 0
+        while start < n:
+            cur = 0
+            step = 0
+            while step < n:
+                nex = (start + step) % n
+                cur += gas[nex] - cost[nex]
+                # 走到这一步的时候当前的油量< 0了。需要更新起始的站，重新从下一站开始来计算了
+                if cur < 0:
+                    break
+                # 走下一步    
+                step += 1
+            # 走了n步，也就是一圈了
+            if step == n:
+                return start
+            else:
+                # 没走了，一圈，从当前已经走的步数继续遍历找
+                start = start + step + 1
+        return -1
+```
+
+
+##### 注意: 为什么使用 start += step + 1 而不是 start += 1？
+
+​如果从起点 start 出发，在走了 step 步后失败（无法到达第 step+1 个加油站），那么从 start 到 start+step 之间的任意一个加油站作为新起点都一定会失败。
+对于任意k在[start + 1, start + step]: 
+
+- 如果从 k 出发，我们失去了 start → k 这段路的油量积累（由问题性质决定）。
+- 由于 start → k 这段的油量积累 ​必然是非负的​（因为如果这段是负的，那在 k 之前就已经失败了）。
+- 因此，当从 k 开始时，油量比从 start 开始更少，不可能完成接下来的路程。
+
+使用 start += step + 1 是基于数学性质的优化，避免了无效的重复检查。
+改为 start += 1 虽然逻辑正确，但会退化为 O(n²) 的暴力解法，在大型数据集上效率极低。
+
+
+
+复杂度分析:      
+
+- 时间复杂度：O(N)，其中 N 为数组的长度。我们对数组进行了单次遍历。
+
+- 空间复杂度：O(1)。
+
+
+##### 方法二
+
+
+
+允许油量为负，但是总剩余油量应该大于等于0，否则不存在解的。
+
+存在解的情况下，利用贪心法的思想，找到最低点，它的下一个点出发的话，可以保证前期得到剩余油量最大，所以可以跑完全程。
+
+```java
+public int canCompleteCircuit2(int[] gas, int[] cost) {
+    // 一圈下来的总剩余油量
+    int totalNum = 0;
+    // 从某一站开始时每一站剩余的油量
+    int curNum = 0;
+    int idx = 0;
+
+    for (int i = 0; i < gas.length; i++) {
+        curNum += gas[i] - cost[i];
+        totalNum += gas[i] - cost[i];
+        if (curNum < 0) {
+            idx = (i+1) % gas.length;
+            curNum = 0;
+        }
+
+    }
+
+    if(totalNum < 0) return -1;
+    return idx;
+}
+```
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/15.\345\210\206\345\217\221\347\263\226\346\236\234.md" "b/Algorithm/15.\345\210\206\345\217\221\347\263\226\346\236\234.md"
new file mode 100644
index 00000000..66db9e01
--- /dev/null
+++ "b/Algorithm/15.\345\210\206\345\217\221\347\263\226\346\236\234.md"
@@ -0,0 +1,174 @@
+15.分发糖果
+===
+
+
+### 题目
+
+n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。
+
+你需要按照以下要求，给这些孩子分发糖果：
+
+每个孩子至少分配到 1 个糖果。
+相邻两个孩子评分更高的孩子会获得更多的糖果。
+请你给每个孩子分发糖果，计算并返回需要准备的 最少糖果数目 。
+
+ 
+
+示例 1:  
+
+- 输入：ratings = [1,0,2]
+- 输出：5
+- 解释：你可以分别给第一个、第二个、第三个孩子分发 2、1、2 颗糖果。
+
+示例 2:   
+
+- 输入：ratings = [1,2,2]
+- 输出：4
+- 解释：你可以分别给第一个、第二个、第三个孩子分发 1、2、1 颗糖果。
+     第三个孩子只得到 1 颗糖果，这满足题面中的两个条件。
+ 
+
+提示：
+
+- n == ratings.length
+- 1 <= n <= 2 * 104
+- 0 <= ratings[i] <= 2 * 104
+
+### 思路
+
+注意题目要求的是最少的糖果数目，且每个孩子至少分配1个糖果。      
+
+我们默认把所有小孩的糖果都是1。    
+
+那么本题我采用了两次贪心的策略:     
+
+
+- 第一次从左到右遍历，如果当前孩子评分高于左边孩子，那么当前孩子比左边多一个糖果；否则不处理，只保留一个糖果。
+    - 左规则：当`ratings[i−1]<ratings[i]`时，i号学生的糖果数量将比i−1号孩子的糖果数量多。我们让left[i]=left[i−1]+1
+- 第二次从右到左遍历，如果当前孩子评分高于右边孩子，那么取 “当前值” 与 “右侧糖果 +1” 中的最大值；否则不予处理。
+    - 右规则：当`ratings[i]>ratings[i+1]`时，i号学生的糖果数量将比i+1号孩子的糖果数量多。
+
+
+我们遍历该数组两次，处理出每一个学生分别满足左规则或右规则时，最少需要被分得的糖果数量。每个人最终分得的糖果数量即为这两个数量的最大值。
+
+在实际代码中，我们先计算出左规则left数组，在计算右规则的时候只需要用单个变量记录当前位置的右规则，同时计算答案即可。
+
+```java
+class Solution {
+    public int candy(int[] ratings) {
+        int n = ratings.length;
+        int[] left = new int[n];
+        for (int i = 0; i < n; i++) {
+            if (i > 0 && ratings[i] > ratings[i - 1]) {
+                left[i] = left[i - 1] + 1;
+            } else {
+                left[i] = 1;
+            }
+        }
+        int right = 0, ret = 0;
+        for (int i = n - 1; i >= 0; i--) {
+            if (i < n - 1 && ratings[i] > ratings[i + 1]) {
+                right++;
+            } else {
+                right = 1;
+            }
+            ret += Math.max(left[i], right);
+        }
+        return ret;
+    }
+}
+```
+
+```python
+class Solution:
+    def candy(self, ratings: List[int]) -> int:
+        n = len(ratings)
+        candies = [1] * n  # 每个孩子至少一个糖果
+
+        # 从左到右：右边评分高，则右边糖果 = 左边糖果 + 1
+        for i in range(1, n):
+            if ratings[i] > ratings[i - 1]:
+                candies[i] = candies[i - 1] + 1
+
+        # 从右到左：左边评分高，则左边糖果 = max(当前左边糖果, 右边糖果 + 1)
+        for i in range(n - 2, -1, -1):
+            if ratings[i] > ratings[i + 1]:
+                candies[i] = max(candies[i], candies[i + 1] + 1)
+
+        return sum(candies)  # 返回总糖果数
+```        
+
+
+复杂度分析:     
+
+- 时间复杂度：O(n)，其中 n 是孩子的数量。我们需要遍历两次数组以分别计算满足左规则或右规则的最少糖果数量。
+
+- 空间复杂度：O(n)，其中 n 是孩子的数量。我们需要保存所有的左规则对应的糖果数量。
+
+##### 方法二： 一次遍历
+
+
+
+在上面的方法中，我们只考虑了递增段的处理，没有考虑如何处理递减段，所以才必须使用两次遍历，那该如何将递减段的处理一同加入呢？
+
+分析一下，如果当前孩子的ratings[i]比左侧孩子的ratings[i-1]更小，到底该分配多大的值？这取决于这个递减段的长度。
+
+- 显然，如果i是最右侧的孩子，他可以只分配1颗糖果；
+- 如果i是倒数第二个孩子，右侧还有一个递减，那么他最少分配2颗糖果。
+
+核心思路：遍历数组时，跟踪当前是上升趋势、下降趋势，还是平；对于连续下降段，不立即分糖果，而是等下降结束后一次性累加。
+观察下降的规律，因为不处理的话就是默认分配1。如果下降长度为k，则需要补上1+2+....+k，即k * (k + 1) / 2颗糖果。 
+
+举个例子，假设ratings=[1,3,4,1]，从左往右处理时，得到cadies=[1,2,3]。我们发现，下降段是[4,1]，长度为1，所以补上1颗糖果，将数组变为
+candies=[1,2,3,1]。
+
+特别的，如果下降长度 >= 上升长度，需要为“山峰”孩子多加一个糖果。    
+
+举个例子，假设ratings=[1,2,4,3,2,1]，从左往右处理时，得到cadies=[1,2,3]。    
+我们发现，下降段的长度为3，比上升段还长。   
+
+如果仅按照之前的处理，得到candies=[1,2,3,3,2,1]。实际上，第一个3应该变为4，也即山峰更高才对，正确的结果是candies=[1,2,4,3,2,1]。
+
+代码如下:   
+
+
+```java
+class Solution {
+    public int candy(int[] ratings) {
+        int n = ratings.length;
+        int total = 1;      // 第一个孩子至少一个糖果
+        int up = 0;         // 上升序列长度
+        int down = 0;       // 下降序列长度
+        int peak = 0;       // 当前上升段的长度峰值
+
+        for (int i = 1; i < n; i++) {
+            if (ratings[i] > ratings[i - 1]) {  // 上升
+                up++;
+                peak = up;
+                down = 0;
+                total += 1 + up;  // 当前孩子比前一个多一颗糖果
+            } else if (ratings[i] == ratings[i - 1]) {  // 平
+                up = down = peak = 0;
+                total += 1;  // 持平，默认为1
+            } else {  // 下降
+                up = 0;
+                down++;
+                // 如果下降长度超过了之前的上升峰值，需要额外补偿
+                total += 1 + down - (peak >= down ? 1 : 0);
+            }
+        }
+
+        return total;
+    }
+}
+```
+
+- 时间复杂度： O(n)，其中 n为孩子总数
+- 空间复杂度： O(1)，仅使用常数个额外变量
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/16.\346\216\245\351\233\250\346\260\264.md" "b/Algorithm/16.\346\216\245\351\233\250\346\260\264.md"
new file mode 100644
index 00000000..853cadbd
--- /dev/null
+++ "b/Algorithm/16.\346\216\245\351\233\250\346\260\264.md"
@@ -0,0 +1,148 @@
+16.接雨水
+===
+
+
+### 题目
+
+给定n个非负整数表示每个宽度为1的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。
+
+示例 1：
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/rainwatertrap_1.png?raw=true)
+
+输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
+输出：6
+解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。 
+示例 2：
+
+输入：height = [4,2,0,3,2,5]
+输出：9
+
+
+### 思路
+
+##### 方法一：动态规划
+
+- 对于下标i，下雨后水能到达的***最大高度***等于下标i两边的最大高度的最小值，
+- 下标i处能接的雨水量等于下标i处的水能到达的***最大高度***减去height[i]。
+- 朴素的做法是对于数组height中的每个元素，分别向左和向右扫描并记录左边和右边的最大高度，然后计算每个下标位置能接的雨水量。
+
+
+上述做法的时间复杂度较高是因为需要对每个下标位置都向两边扫描。如果已经知道每个位置两边的最大高度，则可以在 O(n) 的时间内得到能接的雨水总量。使用动态规划的方法，可以在 O(n) 的时间内预处理得到每个位置两边的最大高度。
+
+- 创建两个长度为n的数组leftMax(存储每个位置左侧的最高柱子高度)和rightMax(存储每个位置右侧的最高柱子高度)。
+- 对于leftMax[i]表示下标i及其左边的位置中，柱子的最大高度
+- rightMax[i]表示下标i及其右边的位置中，柱子的最大高度。
+- 显然，leftMax[0]=height[0]，rightMax[n−1]=height[n−1]。
+- 两个数组的其余元素的计算如下:    
+    - 从左到右遍历，保障每次leftMax[i-1]是截止当前左边最大的。当1≤i≤n−1时，leftMax[i]=max(leftMax[i−1],height[i])；
+    - 从右到左遍历，保障每次rightMax[i+1]是截止当前右边最大的。当0≤i≤n−2时，rightMax[i]=max(rightMax[i+1],height[i])。
+
+- 在得到数组leftMax和rightMax的每个元素值之后，对于下标i处能接的雨水量等于`min(leftMax[i],rightMax[i])−height[i]`。遍历累加每个下标位置即可得到能接的雨水总量。
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/rainbow_2.png?raw=true)
+
+
+```java
+class Solution {
+    public int trap(int[] height) {
+        int n = height.length;
+        if (n == 0) {
+            return 0;
+        }
+
+        int[] leftMax = new int[n];
+        leftMax[0] = height[0];
+        for (int i = 1; i < n; i++) {
+            leftMax[i] = Math.max(leftMax[i - 1], height[i]);
+        }
+
+        int[] rightMax = new int[n];
+        rightMax[n - 1] = height[n - 1];
+        for (int i = n - 2; i >= 0; i--) {
+            rightMax[i] = Math.max(rightMax[i + 1], height[i]);
+        }
+
+        int ans = 0;
+        for (int i = 0; i < n; i++) {
+            // 左右最小边界决定能存水的高度
+            int minBound = Math.min(leftMax[i], rightMax[i]);
+            // 当前柱子能存的水高度 = 最小边界 - 当前高度
+            ans += minBound - height[i];
+        }
+        return ans;
+    }
+}
+```
+
+复杂度分析:    
+
+- 时间复杂度：O(n)，其中n是数组height的长度。计算数组leftMax和rightMax的元素值各需要遍历数组height一次，计算能接的雨水总量还需要遍历一次。
+- 空间复杂度：O(n)，其中n是数组height的长度。需要创建两个长度为n的数组leftMax和rightMax。
+
+
+
+##### 方法二
+
+动态规划的做法中，需要维护两个数组leftMax和rightMax，因此空间复杂度是O(n)。是否可以将空间复杂度降到O(1)？
+
+注意到下标i处能接的雨水量由leftMax[i]和rightMax[i]中的最小值决定。      
+
+- 由于数组leftMax是从左往右计算，数组rightMax是从右往左计算，因此可以使用双指针和两个变量代替两个数组。
+
+- 维护两个指针left和right，以及两个变量leftMax(左侧已扫描的最大高度)和rightMax(右侧已扫描的最大高度)，初始时left=0,right=n−1,leftMax=0,rightMax=0。
+- 指针left只会向右移动，指针right只会向左移动，在移动指针的过程中维护两个变量leftMax和rightMax的值。    
+
+当两个指针没有相遇时，进行如下操作：
+
+- 使用height[left]和height[right]的值更新leftMax和rightMax的值
+
+- 如果`height[left]<height[right]`，则必有`leftMax<rightMax`，下标`left`处能接的雨水量等于`leftMax−height[left]`，将下标`left`处能接的雨水量加到能接的雨水总量，然后将`left`加1（即向右移动一位）
+
+- 如果`height[left]≥height[right]`，则必有`leftMax≥rightMax`，下标`right`处能接的雨水量等于`rightMax−height[right]`，将下标right处能接的雨水量加到能接的雨水总量，然后将right减1（即向左移动一位）
+
+- 当两个指针相遇时，即可得到能接的雨水总量。
+
+
+```java
+class Solution {
+    public int trap(int[] height) {
+        int ans = 0;
+        int left = 0, right = height.length - 1;
+        int leftMax = 0, rightMax = 0;
+        while (left < right) {
+            leftMax = Math.max(leftMax, height[left]);
+            rightMax = Math.max(rightMax, height[right]);
+            // 选择较小的边界进行计算
+            // 如果height[left] < height[right]，说明右边存在一个较高的边界（至少是right指向的高度）能够保证左边有一个有效的边界（即leftMax）可以储水。
+            // 因为此时，左边的最大值leftMax是影响当前位置储水的关键，右边已经有一个不小于height[left]的边界（right指针指向的高度更高）。
+            if (height[left] < height[right]) {
+                // 左侧是短板，计算左侧储水量
+                ans += leftMax - height[left];
+                left++;
+            } else {
+                // 右侧是短板，计算右侧储水量
+                ans += rightMax - height[right];
+                right--;
+            }
+        }
+        return ans;
+    }
+}
+```
+
+复杂度分析:     
+
+- 时间复杂度:O(n)，其中n是数组height的长度。两个指针的移动总次数不超过n。
+
+- 空间复杂度：O(1)。只需要使用常数的额外空间。
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/2.\347\247\273\351\231\244\345\205\203\347\264\240.md" "b/Algorithm/2.\347\247\273\351\231\244\345\205\203\347\264\240.md"
new file mode 100644
index 00000000..422431ad
--- /dev/null
+++ "b/Algorithm/2.\347\247\273\351\231\244\345\205\203\347\264\240.md"
@@ -0,0 +1,118 @@
+2.移除元素
+===
+
+
+### 题目
+
+给你一个数组`nums`和一个值`val`，你需要`原地`移除所有数值等于`val`的元素。元素的顺序可能发生改变。然后返回`nums`中与`val`不同的元素的数量。
+
+假设`nums`中不等于`val`的元素数量为`k`，要通过此题，您需要执行以下操作:    
+
+更改`nums`数组，使`nums`的前`k`个元素包含不等于`val`的元素。`nums`的其余元素和`nums`的大小并不重要。
+返回`k`。
+
+
+示例 1：
+
+输入：nums = [3,2,2,3], val = 3
+输出：2, nums = [2,2,_,_]
+解释：你的函数函数应该返回 k = 2, 并且 nums 中的前两个元素均为 2。
+你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。
+示例 2：
+
+输入：nums = [0,1,2,2,3,0,4,2], val = 2
+输出：5, nums = [0,1,4,0,3,_,_,_]
+解释：你的函数应该返回 k = 5，并且 nums 中的前五个元素为 0,0,1,3,4。
+注意这五个元素可以任意顺序返回。
+你在返回的 k 个元素之外留下了什么并不重要（因此它们并不计入评测）。
+
+
+### 思路
+
+##### 双指针： 
+
+- 用一个变量k记录不等于val的元素数量，从0开始
+- 从头开始遍历nums中的元素，与val进行比较，如果不等于val，那就将nums[k]的值设置为nums中当前的元素，同时后移k
+
+```python
+class Solution:
+    def removeElement(self, nums: List[int], val: int) -> int:
+        k = 0
+        for num in nums:
+            if num != val:
+                nums[k] = num
+                k += 1
+        return k
+```
+
+
+```kotlin
+class Solution {
+    fun removeElement(nums: IntArray, `val`: Int): Int {
+        var k = 0
+        for (num in nums) {
+            if (num != `val`) {
+                nums[k] = num
+                k++
+            }
+        }
+        return k
+    }
+}
+```
+
+##### 双指针优化
+
+上面的方案存在一个问题，就是例如数组为[1, 2, 3, 4, 5]，而val为1时。我们需要把每一个元素都左移一位。   
+
+注意到题目上说：元素的顺序可以改变。    
+
+实际上我们只需要将最后一个元素5移动到序列开头，取代元素1，得到序列[5, 2, 3, 4]就可以。 
+
+
+思路： 
+- 还是用双指针，一个从前往后left，一个从后往前right
+- 从前往后的指针left的判断方式还是如同上面的思路
+- 如果left上的值等于val，那就把left位置的值换成right位置的值，同时移动right继续循环
+- 直到left > right相等，那就都遍历完了
+
+```python
+class Solution:
+    def removeElement(self, nums: List[int], val: int) -> int:
+        left = 0
+        right = len(nums) - 1
+        while left <= right:
+            if (nums[left] == val):
+                nums[left] = nums[right]
+                right -= 1
+            else:
+                left += 1
+        return left   
+```
+
+```Kotlin
+class Solution {
+    fun removeElement(nums: IntArray, `val`: Int): Int {
+        var left = 0
+        var right = nums.size - 1
+        while (left <= right) {
+            if (nums[left] == `val`) {
+                nums[left] = nums[right]
+                right --
+            } else {
+                left ++
+            }
+        }
+
+        return left
+    }
+}
+```
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/3.\345\210\240\351\231\244\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271.md" "b/Algorithm/3.\345\210\240\351\231\244\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271.md"
new file mode 100644
index 00000000..8465bf39
--- /dev/null
+++ "b/Algorithm/3.\345\210\240\351\231\244\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271.md"
@@ -0,0 +1,78 @@
+3.删除有序数组中的重复项
+===
+
+
+### 题目
+
+给你一个 非严格递增排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回 nums 中唯一元素的个数。
+
+考虑 nums 的唯一元素的数量为 k ，你需要做以下事情确保你的题解可以被通过：
+
+更改数组 nums ，使 nums 的前 k 个元素包含唯一元素，并按照它们最初在 nums 中出现的顺序排列。nums 的其余元素与 nums 的大小不重要。
+返回 k 。
+
+
+
+示例 1：
+
+输入：nums = [1,1,2]
+输出：2, nums = [1,2,_]
+解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。
+示例 2：
+
+输入：nums = [0,0,1,1,1,2,2,3,3,4]
+输出：5, nums = [0,1,2,3,4]
+解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。
+
+
+
+### 思路
+
+双指针      
+- 既然非严格递增队列，那么重复的元素一定会相邻，那我们可以从0开始遍历，将没有重复的数值替换放到数组的开头
+
+
+```python
+class Solution:
+    def removeDuplicates(self, nums: List[int]) -> int:
+    	# 第一个位置的不用判断
+        k = 1
+        for i in range(len(nums)):
+        	# 当前的数值与已放置的数值不同就重新放置
+            if nums[i] != nums[k - 1]:
+                nums[k] = nums[i]
+                k += 1
+        return k
+```
+
+
+```kotlin
+class Solution {
+    fun removeDuplicates(nums: IntArray): Int {
+        var k = 1
+        for(i in nums){
+            if (i != nums[k - 1]) {
+                nums[k] = i
+                k ++
+            }
+        }
+        return k
+    }
+}
+```
+
+优化： 
+
+假如数组是[0, 1, 2, 3, 4, 5]
+此时数组中没有重复元素，按照上面的方法，每次比较时nums[i]都不等于nums[k - 1]，因此就会将k指向的元素原地复制一遍，这个操作其实是不必要的。
+
+因此我们可以添加一个小判断，当 i  - k > 1 时，才进行复制。
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/4.\345\210\240\351\231\244\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271II.md" "b/Algorithm/4.\345\210\240\351\231\244\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271II.md"
new file mode 100644
index 00000000..549b9a20
--- /dev/null
+++ "b/Algorithm/4.\345\210\240\351\231\244\346\234\211\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271II.md"
@@ -0,0 +1,80 @@
+4.删除有序数组中的重复项II
+===
+
+
+### 题目
+
+给你一个有序数组 nums ，请你 原地 删除重复出现的元素，使得出现次数超过两次的元素只出现两次 ，返回删除后数组的新长度。
+
+不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
+
+
+
+示例 1：
+
+输入：nums = [1,1,1,2,2,3]
+输出：5, nums = [1,1,2,2,3]
+解释：函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3。 不需要考虑数组中超出新长度后面的元素。
+示例 2：
+
+输入：nums = [0,0,1,1,1,1,2,3,3]
+输出：7, nums = [0,0,1,1,2,3,3]
+解释：函数应返回新长度 length = 7, 并且原数组的前七个元素被修改为 0, 0, 1, 1, 2, 3, 3。不需要考虑数组中超出新长度后面的元素。
+ 
+
+
+### 思路
+
+双指针
+
+- 因为给定数组是有序的，所以相同元素必然连续。     
+- 我们可以使用双指针解决本题，遍历数组检查每一个元素是否应该被保留，如果应该被保留，就将其移动到指定位置。具体地，我们定义两个指针 slow 和 fast 分别为慢指针和快指针，其中慢指针表示处理出的数组的长度，快指针表示已经检查过的数组的长度，即 nums[fast] 表示待检查的第一个元素，nums[slow−1] 为上一个应该被保留的元素所移动到的指定位置。
+
+- 因为本题要求相同元素最多出现两次而非一次，所以我们需要检查上上个应该被保留的元素 nums[slow−2] 是否和当前待检查元素 nums[fast] 相同。
+
+- 当且仅当 nums[slow−2]=nums[fast] 时，当前待检查元素 nums[fast] 不应该被保留（因为此时必然有 nums[slow−2]=nums[slow−1]=nums[fast]）。最后，slow 即为处理好的数组的长度。
+
+特别地，数组的前两个数必然可以被保留，因此对于长度不超过 2 的数组，我们无需进行任何处理，对于长度超过 2 的数组，我们直接将双指针的初始值设为 2 即可。
+
+
+```python
+
+class Solution:
+    def removeDuplicates(self, nums: List[int]) -> int:
+        if len(nums) < 2:
+            return len(nums)
+        k = 2
+        for i in range(2, len(nums)):
+            if nums[i] == nums[k - 2] :
+                continue
+            else:            
+                nums[k] = nums[i]
+                k += 1
+        return k
+```
+
+
+```kotlin
+class Solution {
+    fun removeDuplicates(nums: IntArray): Int {
+        if (nums.size < 2) {
+            return nums.size
+        }
+        var k = 2
+        for (i in 2..nums.size - 1) {
+            if (nums[i] != nums[k - 2]) {
+                nums[k] = nums[i]
+                k ++
+            }
+        }
+        return k
+    }
+}
+```
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/5.\345\244\232\346\225\260\345\205\203\347\264\240.md" "b/Algorithm/5.\345\244\232\346\225\260\345\205\203\347\264\240.md"
new file mode 100644
index 00000000..71e6953d
--- /dev/null
+++ "b/Algorithm/5.\345\244\232\346\225\260\345\205\203\347\264\240.md"
@@ -0,0 +1,86 @@
+5.多数元素
+===
+
+
+### 题目
+
+给定一个大小为 n 的数组 nums ，返回其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
+
+你可以假设数组是非空的，并且给定的数组总是存在多数元素。
+
+
+数组中出现次数超过一半的数字被称为众数。
+
+示例 1：
+
+输入：nums = [3,2,3]
+输出：3
+示例 2：
+
+输入：nums = [2,2,1,1,1,2,2]
+输出：2
+
+
+
+### 思路
+
+##### 哈希表
+
+遍历数组nums，用HashMap统计各数字的数量，即可找出众数。
+此方法时间和空间复杂度均为O(N)。
+
+
+##### 排序法
+
+将数组nums排序，数组中心点的元素，一定是众数
+
+##### 摩尔投票法
+
+核心理念是票数正负抵消。此方法的时间和空间复杂度分别为O(N)和O(1)。     
+为本题最佳解法。 
+
+若记 众数 的票数为 +1 ，非众数 的票数为 −1 ，则一定有所有数字的 票数和 >0 。
+
+```python
+
+class Solution:
+    def majorityElement(self, nums: List[int]) -> int:
+        votes = 0
+        for num in nums:
+            if votes == 0:
+                x = num
+            if num == x:
+                votes += 1
+            else:
+                votes -= 1
+        return x
+```
+
+
+```kotlin
+class Solution {
+    fun majorityElement(nums: IntArray): Int {
+        var vote = 0
+        var k = 0
+        for (num in nums) {
+            if (vote == 0) {
+                k = num
+            }
+            if (num == k) {
+                vote ++
+            } else {
+                vote --
+            }
+        }
+        return k
+    }
+}
+```
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/6.\350\275\256\350\275\254\346\225\260\347\273\204.md" "b/Algorithm/6.\350\275\256\350\275\254\346\225\260\347\273\204.md"
new file mode 100644
index 00000000..eb2940c2
--- /dev/null
+++ "b/Algorithm/6.\350\275\256\350\275\254\346\225\260\347\273\204.md"
@@ -0,0 +1,87 @@
+6.轮转数组
+===
+
+
+### 题目
+
+给定一个整数数组 nums，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。
+
+
+示例 1:
+
+输入: nums = [1,2,3,4,5,6,7], k = 3
+输出: [5,6,7,1,2,3,4]
+解释:
+向右轮转 1 步: [7,1,2,3,4,5,6]
+向右轮转 2 步: [6,7,1,2,3,4,5]
+向右轮转 3 步: [5,6,7,1,2,3,4]
+示例 2:
+
+输入：nums = [-1,-100,3,99], k = 2
+输出：[3,99,-1,-100]
+解释: 
+向右轮转 1 步: [99,-1,-100,3]
+向右轮转 2 步: [3,99,-1,-100]
+
+
+
+### 思路
+
+
+##### 双层循环
+
+外层循环k此，不断把最后一位移到第一位，然后内层循环每个元素后移一位
+
+```kotlin
+class Solution {
+    fun rotate(nums: IntArray, k: Int): Unit {
+        for (i in 0..<k) {
+            val temp = nums[nums.size - 1]
+            for (j in nums.size - 1 downTo   1) {
+                nums[j] = nums[j - 1]
+            }
+            nums[0] = temp
+        }
+    }
+}
+```
+##### 反转法
+
+
+- k=3
+[1, 2, 3, 4, 5, 6, 7]
+- 反转整个数组
+[7, 6, 5, 4, 3, 2, 1]
+- 反转前k个元素
+[5, 6, 7, 4, 3, 2, 1]
+- 反转后n - k个
+[5, 6, 7, 1, 2, 3, 4]
+
+
+注意：这里k可能超过数组的长度，所以要用 k %= n保证超过一轮的问题
+```python
+# 注：请勿使用切片，会产生额外空间
+class Solution:
+    def rotate(self, nums: List[int], k: int) -> None:
+        def reverse(i: int, j: int) -> None:
+            while i < j:
+                nums[i], nums[j] = nums[j], nums[i]
+                i += 1
+                j -= 1
+
+        n = len(nums)
+        k %= n  # 轮转 k 次等于轮转 k % n 次
+        reverse(0, n - 1)
+        reverse(0, k - 1)
+        reverse(k, n - 1)
+```
+
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/7.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.md" "b/Algorithm/7.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.md"
new file mode 100644
index 00000000..5e4f9722
--- /dev/null
+++ "b/Algorithm/7.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.md"
@@ -0,0 +1,76 @@
+7.买卖股票的最佳时机
+===
+
+
+### 题目
+
+给定一个数组prices，它的第i个元素prices[i]表示一支给定股票第i天的价格。      
+
+你只能选择`某一天`买入这只股票，并选择在`未来的某一个不同的日子`卖出该股票。设计一个算法来计算你所能获取的最大利润。     
+
+返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回0。   
+
+ 
+
+示例 1:   
+
+- 输入：[7,1,5,3,6,4]
+- 输出：5
+- 解释：在第2天（股票价格 = 1）的时候买入，在第5天（股票价格=6）的时候卖出，最大利润= `6-1 = 5` 。
+     注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
+示例 2：
+
+输入：prices = [7,6,4,3,1]
+输出：0
+解释：在这种情况下, 没有交易完成, 所以最大利润为 0。
+
+
+### 思路
+
+
+##### 暴力遍历
+
+先考虑最简单的「暴力遍历」，即枚举出所有情况，并从中选择最大利润。设数组 prices 的长度为 n ，由于只能先买入后卖出，因此第 1 天买可在未来 n−1 天卖出，第 2 天买可在未来 n−2 天卖出……以此类推，要思考更优解法。
+
+然而，暴力法会产生许多冗余计算。例如，若第 1 天价格低于第 2 天价格，即第 1 天成本更低，那么我们一定不会选择在第 2 天买入。进一步的，若在前 i 天选择买入，若想达到最高利润，则一定选择价格最低的交易日买入。
+
+##### 贪心思想
+
+考虑根据此贪心思想，遍历价格列表 prices 并执行两步：
+
+
+- 更新前 i 天的最低价格，即最低买入成本 cost；
+- 更新前 i 天的最高利润 profit ，即选择「前 i−1 天最高利润 profit 」和「第 i 天卖出的最高利润 price - cost 」中的最大值 ；
+
+
+```python
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        minPrice = prices[0]
+        cost = 0
+        for i in prices:
+            if i < minPrice:
+                minPrice = i
+            elif i - minPrice > cost:
+                 cost = i - minPrice
+        return cost
+```        
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/8.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272II.md" "b/Algorithm/8.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272II.md"
new file mode 100644
index 00000000..05b07c7d
--- /dev/null
+++ "b/Algorithm/8.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272II.md"
@@ -0,0 +1,105 @@
+8.买卖股票的最佳时机II
+===
+
+
+### 题目
+
+给你一个整数数组prices，其中prices[i]表示某支股票第i天的价格。
+
+在每一天，你可以决定是否购买和/或出售股票。你在任何时候最多只能持有一股股票。你也可以先购买，然后在同一天出售。
+
+返回 你能获得的 最大 利润 。
+
+ 
+
+示例 1：
+
+输入：prices = [7,1,5,3,6,4]
+输出：7
+解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。
+随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3。
+最大总利润为 4 + 3 = 7 。
+示例 2：
+
+输入：prices = [1,2,3,4,5]
+输出：4
+解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。
+最大总利润为 4 。
+示例 3：
+
+输入：prices = [7,6,4,3,1]
+输出：0
+解释：在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0。
+
+
+### 思路
+
+这个的改动点时可以交易多次，怎么能保证利益最大？
+下面两种方式其实一样
+
+##### 方式一
+
+只要第二天价格比第一天价格高就卖
+
+```kotlin
+class Solution {
+    fun maxProfit(prices: IntArray): Int {
+        var buyPirce = prices[0]
+        var totalIncome = 0
+        for (i in prices) {
+            if (i > buyPirce) {
+                totalIncome += (i - buyPirce)
+                buyPirce = i
+            } else if ( < buyPrice) {
+                buyPirce = i
+            }
+        }
+        return totalIncome
+    }
+}
+```
+##### 方式二
+
+- 记录当前可卖的最大收入及买入的价格
+- 如果最新的价格低于买入的价格或者当前已经有收入了且当前的价格小于最大收入时的卖价(i - buyPrice < income)，这个时候需要卖了再买
+
+
+```python3
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        buyPrice = prices[0]
+        income = 0
+        totalIncome = 0
+        for i in prices:
+
+            if i < buyPrice or i - buyPrice < income: # 有更低的价格，或者说现在的价格比目前收益最大时可卖出的价格更低
+                # 有更低的购买价格了，这个时候要判断当前有没有利润，有就卖，没有就使用该价格买
+                if (income > 0):
+                    totalIncome += income
+                    income = 0
+                buyPrice = i
+            elif (i - buyPrice > income):
+                income = i - buyPrice
+
+        totalIncome += income
+        return totalIncome
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/9.\350\267\263\350\267\203\346\270\270\346\210\217.md" "b/Algorithm/9.\350\267\263\350\267\203\346\270\270\346\210\217.md"
new file mode 100644
index 00000000..705396c1
--- /dev/null
+++ "b/Algorithm/9.\350\267\263\350\267\203\346\270\270\346\210\217.md"
@@ -0,0 +1,90 @@
+9.跳跃游戏
+===
+
+
+### 题目
+
+给你一个非负整数数组nums，你最初位于数组的第一个下标。数组中的每个元素代表你在该位置可以跳跃的最大长度。
+
+判断你是否能够到达最后一个下标，如果可以，返回true；否则，返回false。
+
+ 
+
+示例 1：
+
+输入：nums = [2,3,1,1,4]
+输出：true
+解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。
+示例 2：
+
+输入：nums = [3,2,1,0,4]
+输出：false
+解释：无论怎样，总会到达下标为 3 的位置。但该下标的最大跳跃长度是 0 ， 所以永远不可能到达最后一个下标。
+
+
+
+### 思路
+
+##### 方式一
+
+题目中说：数组中的每个元素代表你在该位置可以跳跃的最大长度。
+所以我们只要保证能够跳跃的最大长度超过了数组的长度就可以。
+
+
+- 每走一步就记录最远可以到哪里
+- 最远可达位置够不够你继续往前走
+
+
+```python
+class Solution:
+    def canJump(self, nums: List[int]) -> bool:
+        rightmost = 0
+        for i in range(len(nums)):
+        	# 在可走的最大步数范围内走
+            if i <= rightmost:
+            	# 每走一步更新一下可继续走的最大步
+                rightmost = max(rightmost, i + nums[i])
+                if rightmost >= len(nums) - 1:
+                    return True
+        return False
+```
+
+
+
+
+##### 方式二
+
+
+- 假设在一个格子上，每个格子有对应的能量值。
+- 每前进一步需要消耗一个能量；
+- 而到达一个格子后， 如果当前格子储存的能量值较大，则更新为较大的能量值；
+- 如果当前格子能量值小于现有的能量值，则无需更新；
+- 如果出现能量值正好消耗完，那就没能量继续走了，最远的步数就是这里了
+- 判断最远的步数与数组的长度一样不一样
+
+```python
+class Solution:
+    def canJump(self, nums: List[int]) -> bool:
+        cur = nums[0]
+        if len(nums) == 1:
+            return True
+
+        for i in range(len(nums)):
+            cur -= 1
+            if cur < nums[i]:
+                cur = nums[i]
+            if cur <= 0:
+                    break
+        return i == (len(nums) - 1)
+```
+
+
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/JavaKnowledge/python3\345\205\245\351\227\250.md" "b/JavaKnowledge/python3\345\205\245\351\227\250.md"
index 293961fb..1f65e19f 100644
--- "a/JavaKnowledge/python3\345\205\245\351\227\250.md"
+++ "b/JavaKnowledge/python3\345\205\245\351\227\250.md"
@@ -461,14 +461,6 @@ make_pizza('mushrooms','green peppers','extra cheese')
 看起来，Python的参数传递方式是整齐划一的，但具体情况还得具体分析。在Python中，对象大致分为两类，即可变对象和不可变对象。可变对象包括字典、列表及集合等。不可变对象包括数值、字符串、不变集合等。如果参数传递的是可变对象，传递的就是地址，形参的地址就是实参的地址，如同“两套班子，一套人马”一样，修改了函数中的形参，就等同于修改了实参。如果参数传递的是不可变对象，为了维护它的“不可变”属性，函数内部不得不“重构”一个实参的副本。此时，实参的副本（即形参）和主调用函数提供的实参在内存中分处于不同的位置，因此对函数形参的修改，并不会对实参造成任何影响，在结果上看起来和传值一样。
 
 
-看起来，Python的参数传递方式是整齐划一的，但具体情况还得具体分析。在Python中，对象大致分为两类，即可变对象和不可变对象。可变对象包括字典、列表及集合等。不可变对象包括数值、字符串、不变集合等。如果参数传递的是可变对象，传递的就是地址，形参的地址就是实参的地址，如同“两套班子，一套人马”一样，修改了函数中的形参，就等同于修改了实参。如果参数传递的是不可变对象，为了维护它的“不可变”属性，函数内部不得不“重构”一个实参的副本。此时，实参的副本（即形参）和主调用函数提供的实参在内存中分处于不同的位置，因此对函数形参的修改，并不会对实参造成任何影响，在结果上看起来和传值一样。
-
-
-看起来，Python的参数传递方式是整齐划一的，但具体情况还得具体分析。在Python中，对象大致分为两类，即可变对象和不可变对象。可变对象包括字典、列表及集合等。不可变对象包括数值、字符串、不变集合等。如果参数传递的是可变对象，传递的就是地址，形参的地址就是实参的地址，如同“两套班子，一套人马”一样，修改了函数中的形参，就等同于修改了实参。如果参数传递的是不可变对象，为了维护它的“不可变”属性，函数内部不得不“重构”一个实参的副本。此时，实参的副本（即形参）和主调用函数提供的实参在内存中分处于不同的位置，因此对函数形参的修改，并不会对实参造成任何影响，在结果上看起来和传值一样。
-
-
-看起来，Python的参数传递方式是整齐划一的，但具体情况还得具体分析。在Python中，对象大致分为两类，即可变对象和不可变对象。可变对象包括字典、列表及集合等。不可变对象包括数值、字符串、不变集合等。如果参数传递的是可变对象，传递的就是地址，形参的地址就是实参的地址，如同“两套班子，一套人马”一样，修改了函数中的形参，就等同于修改了实参。如果参数传递的是不可变对象，为了维护它的“不可变”属性，函数内部不得不“重构”一个实参的副本。此时，实参的副本（即形参）和主调用函数提供的实参在内存中分处于不同的位置，因此对函数形参的修改，并不会对实参造成任何影响，在结果上看起来和传值一样。
-
 
 ### 将函数存储在模块中
 
@@ -642,7 +634,7 @@ with open('test.txt') as file_object:
 filename = 'test.txt'
 with open(filename) as file_object:
     for line in file_object:
-    print(line)
+        print(line)
 ```    
 这里使用了关键字with，让Python负责妥善地打开和关闭文件。       
 使用关键字with时，open()返回的文件对象只在with代码块内可用。
diff --git "a/SourceAnalysis/RecyclerView\345\244\215\347\224\250\345\216\237\347\220\206.md" "b/SourceAnalysis/RecyclerView\345\244\215\347\224\250\345\216\237\347\220\206.md"
new file mode 100644
index 00000000..bf99eba6
--- /dev/null
+++ "b/SourceAnalysis/RecyclerView\345\244\215\347\224\250\345\216\237\347\220\206.md"
@@ -0,0 +1,15 @@
+RecyclerView复用原理
+===
+
+但是很多时候我们的使用方式并不是最完美的，将Adapter和数据进行了强绑定。尽管在很多实际项目中，将数据存储在 Adapter 内部，甚至将数据作为了Adapter的成员变量是一种常见的做法:
+
+这种实现方式就是把数据给Adapter，然后Adapter进过处理，完成数据的展示，不过，从严格的单一职责原则角度出发， Adapter 只应该负责“映射”而不是“管理”数据。也就是说，数据的维护（如数据的获取、更新和业务逻辑）可以交给 Activity、Fragment 或 ViewModel，而 Adapter 仅仅负责根据外部传入的数据来创建和绑定视图
+
+
+
+
+
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
diff --git "a/VideoDevelopment/OpenGL/14.\345\256\236\344\276\213\345\214\226.md" "b/VideoDevelopment/OpenGL/14.\345\256\236\344\276\213\345\214\226.md"
index f0a70991..e04ca224 100644
--- "a/VideoDevelopment/OpenGL/14.\345\256\236\344\276\213\345\214\226.md"
+++ "b/VideoDevelopment/OpenGL/14.\345\256\236\344\276\213\345\214\226.md"
@@ -1,9 +1,25 @@
 ## 13.实例化
 
+
+OpenGL ES实例化(Instancing)是一种只调用一次渲染函数就能绘制出很多物体的技术，可以实现将数据一次性发送给GPU，告诉OpenGL ES使用一个绘制函数，将这些数据绘制成多个物体。   
+
+
+实例化(Instancing)避免了CPU多次向GPU下达渲染命令(避免多次调用glDrawArrays或glDrawElements等绘制函数)，节省了绘制多个物体时CPU和GPU之间的通信时间，提升了渲染性能。   
+
+
+
+
+
 实例化(instancing)提供了一种机制，可以只用一个C++/OpenGL调用就告诉显卡渲染一个对象的多个副本。这可以带来显著的性能优势，特别是在绘制有数千甚至数百万个对象时，例如渲染在场地中的许多花朵。
 
+### 粒子  
+
 实例化最常见的应用就是做一些粒子效果，例如一些烟花的效果。。
 
+实例化的目标并不是实现同一个物体绘制多次，而是能基于某一物体绘制出位置、大小、形状或颜色不同的多个物体。   
+
+OpenGL ES着色器中有一个与实例化绘制相关的内建变量gl_InstanceID，表示当前正在绘制实例的ID，每个实例对应一个唯一的ID，通过这个ID可以轻易实现基于一个物体而绘制出位置、大小、形状或颜色不同的多个物体(实例)。     
+
 
 在渲染多个对象时，OpenGL使用Z-buffer算法来进行隐藏面消除。通常情况下，通过选择最接近相机的相应片段的颜色作为像素的颜色，这种方法可决定哪些物体的曲面可见并呈现到屏幕，而位于其他物体后面的曲面不应该被渲染。
 然而，有时候场景中的两个物体表面重叠并位于重合的平面中，这使得深度缓冲区算法难以确定应该渲染两个表面中的哪一个（因为两者都不“最接近”相机）。发生这种情况时，浮点舍入误差可能会导致渲染表面的某些部分使用其中一个对象的颜色，而其他部分则使用另一个对象的颜色。这种不自然的伪影称为Z冲突(Z-fighting)或深度冲突(depth-fighting)，是渲染的片段在深度缓冲区中相互对应的像素条目上“斗争”的结果。
diff --git "a/VideoDevelopment/OpenGL/18.\345\205\266\344\273\226.md" "b/VideoDevelopment/OpenGL/18.\345\205\266\344\273\226.md"
index 72202177..723b4dae 100644
--- "a/VideoDevelopment/OpenGL/18.\345\205\266\344\273\226.md"
+++ "b/VideoDevelopment/OpenGL/18.\345\205\266\344\273\226.md"
@@ -64,5 +64,11 @@ GPU进行渲染时，会把数据先存储在帧缓冲区里，然后视频控
 
 
 
+### 混合
+
+OpenGL ES混合本质上是将2个片元颜色进行调和产生一个新的颜色。    
+
+OpenGL ES混合发生在片元通过各项测试之后，准备进入帧缓冲区的片元和原有的片元按照特定比例加权计算出最终片元的颜色值
+
 
  
diff --git "a/VideoDevelopment/OpenGL/19.\347\233\270\346\234\272\351\242\204\350\247\210.md" "b/VideoDevelopment/OpenGL/19.\347\233\270\346\234\272\351\242\204\350\247\210.md"
new file mode 100644
index 00000000..fec81043
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/19.\347\233\270\346\234\272\351\242\204\350\247\210.md"
@@ -0,0 +1,43 @@
+# 19.相机预览
+
+相机预览可以使用OpenGL方便的实现相机美颜、滤镜、塑性以及一些特效。   
+
+
+相机的预览实现一般有2种方式:    
+
+- 一种是基于Android原生SurfaceTexture的纯GPU实现方式    
+- 一种是通过相机的预览回调接口获取帧的YUV数据，利用CPU算法处理完成之后，传入显存，再利用GPU实现YUV转RGBA进行渲染，即CPU + GPU的实现方式   
+
+基于Android原生SurfaceTexture的纯GPU实现方式，相机可以使用SurfaceTexture作为预览载体。     
+SurfaceTexture可以来自于GLSurfaceView、TextureView或SurfaceView这些独立拥有Surface的封装类，也可以自定义实现。    
+
+
+作为预览载体的SurfaceTexture绑定的纹理需要是OES纹理。    
+
+使用OES纹理后，我们不需要在片段着色器中自己做YUV to RGBA的转换，因为OES纹理可以直接接收YUV数据或者直接输出YUV数据。  
+
+
+### YUV
+
+YUV和RGBA是两种不同的颜色编码格式，主要区别于在数据组织和应用场景。
+
+- YUV主要用于视频压缩、传输(例如H264/HEVC)，优势为亮度和色度分离适合压缩(人眼对亮度更敏感，色度可降采样)。
+YUV为视频压缩设计，牺牲直接显示兼容性换取高压缩率。   
+
+- RGBA主要用于图像显示、图形渲染(如屏幕绘制)，每个像素的RGBA值连续存储，可直接兼容显示设备。    
+RGBA为显示优化，直接支持像素渲染和透明通道。   
+
+
+### OES与YUV的关系
+
+OES纹理(GL_TEXTURE_EXTERNAL_OES)是OpenGL ES的一种扩展纹理类型，主要用于直接操作外部设备(如摄像头、视频解码器)的纹理数据。它与YUV的关系如下:   
+
+- 视频解码后的YUV数据: 移动端视频解码器(如Android的MediaCodec)输出的YUV帧数据，通常通过OES纹理直接传递给GPU，避免CPU到GPU的数据拷贝。     
+
+
+
+使用OES纹理需要修改片段着色器，在着色器脚本的头部增加扩展纹理的声明:   
+
+`#extension GL_OES_EGL_image_external : require`
+
+并且纹理采样器不再使用sample2D，需要换成samplerExternalOES作为纹理采样器。    
diff --git "a/VideoDevelopment/OpenGL/20.\351\200\232\350\277\207OpenGL\351\242\204\350\247\210\345\271\266\345\275\225\345\210\266\350\247\206\351\242\221.md" "b/VideoDevelopment/OpenGL/20.\351\200\232\350\277\207OpenGL\351\242\204\350\247\210\345\271\266\345\275\225\345\210\266\350\247\206\351\242\221.md"
new file mode 100644
index 00000000..64e06971
--- /dev/null
+++ "b/VideoDevelopment/OpenGL/20.\351\200\232\350\277\207OpenGL\351\242\204\350\247\210\345\271\266\345\275\225\345\210\266\350\247\206\351\242\221.md"
@@ -0,0 +1,50 @@
+## 通过OpenGL预览并录制视频
+
+
+Camera将预览的画面通过SurfaceTexture输出给屏幕的GLSurfaceView以及视频编码的MediaCodec的Surface上。   
+
+
+将渲染的结果输出到不同的目标，我们需要使用一种称为离屏渲染的技术。    
+
+离屏渲染：就是让OpenGL不将渲染的结果直接输出到屏幕上，而是输出到一个中间缓冲区(一块GPU空间)，然后再将中间缓冲区的内容输出到屏幕或编码器等目标上，这就称为离屏渲染。    
+
+
+在Android系统下可以使用三种方法实现同时将OpenGL ES的内容输出给多个目标(屏幕和编码器):     
+
+- 二次渲染法
+收到数据后调用Shader程序进行渲染；将渲染结果输出到SurfaceView中显示到屏幕；然后我们需要切换当前渲染的EGLSurface，通过调用EGL的eglMakeCurrent方法，将默认SurfaceView的EGLSurface切换到MediaCodec的EGLSurface上，然后再次调用Shader程序进行渲染，并将渲染结果输出给MediaCodec的Surface进行编码。     
+
+因为调用了两次Shader程序进行渲染，每次渲染后的结果输送给不同的Surface，因此称为二次渲染法。    
+- FBO
+二次渲染会调用两次滤镜程序的draw方法，将同一个纹理绘制到不同的Surface上，但是如果要对图像进行一些美颜、高斯模糊等变换操作，那么我们就要对同一个纹理进行两次计算，这无疑是对GPU的浪费，且效率低下。    
+
+那如何只计算一次，把结果输出给不同的Surface呢？    
+OpenGL提供了一种高效的方法，即FBO(FrameBufferObject)。 
+
+FBO法中我们操作步骤如下：
+
+- 将渲染结果绘制到FBO中
+- 将FBO数据输送到屏幕中
+- 将FBO数据输送到编码器
+
+FBO法中，我们不直接将OpenGL ES的渲染结果输送给不同的Surface，而是将结果输出到FBO中，FBO可以理解为一块显存区域，用于存放OpenGL ES的渲染结果。
+我们知道CameraFilter着色器程序是将SurfaceTexture纹理渲染到EGLSurface中的，如何将纹理渲染到FBO帧缓冲区中呢，我们需要一个渲染到FBO中的着色器程序。
+渲染结果输出到FBO后，我们可以将FBO结果分别输出给不同的目标，FBO->屏幕，FBO->MediaCodec。而FBO输出到不同的目标也需要一个新的着色器去绘制。
+
+FBO高效的原理在于，纹理渲染到FBO中的前置操作。如果需要对纹理进行美颜、高斯模糊等复杂的计算，FBO确实能提高效率。如果没有复杂的计算，那么FBO和二次渲染法效率差不多。
+
+
+- glBlitFramebuffer: copy a block of pixels from the read framebuffer to the draw framebuffer
+
+
+该方式不再使用FBO做缓存，而是像二次渲染法一样，先将渲染的内容输出到当前Surface中，但并不展示到屏幕上。我们来看下这种方式的流程：
+
+- 先将渲染结果输送给SurfaceView的Surface
+- 切换Surface为MediaCodec的Surface，此时当前Surface为MediaCodec的
+- 利用OpenGL3.0提供的API glBlitFramebuffer从原来的Surface拷贝数据到当前Surface中，再调用EGL的eglSwapBuffers将Surface中的内容送编码器编码
+- 最后将当前Surface切回原来的Surface，也就是SurfaceView的Surface，同样调用EGL的eglSwapBuffers方法，将其内容显示到屏幕上
+
+该方式的效率是最高的，一次渲染输出给多个目标，但是只有OpenGL3.0才有该方法
+
+
+
diff --git "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md" "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"
index ab251b38..be6c7acb 100644
--- "a/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
+++ "b/VideoDevelopment/OpenGL/5.OpenGL ES\347\273\230\345\210\266\344\270\211\350\247\222\345\275\242.md"	
@@ -19,7 +19,24 @@ float vertices[] = {
      0.0f,  0.5f, 0.0f
 };
 ```
-定义这样的顶点数据以后，我们会把它作为输入发送给图形渲染管线的第一个处理阶段：顶点着色器。    
+定义这样的顶点数据以后，我们会把它作为输入发送给图形渲染管线的第一个处理阶段：顶点着色器。   
+
+
+
+在OpenGL ES2.0编程中，用于绘制的顶点数组数据首先保存在CPU内存，在调用glDrawArrays或glDrawElements等进行绘制时，需要将顶点数组数据从CPU内存拷贝到显存。     
+
+但是很多时候我们没必要每次绘制的时候都去进行内存拷贝，如果可以在显存中缓存这些数据，就可以在很大程度上降低内存拷贝带来的开销。   
+
+OpenGL ES3.0编程中，VBO和EBO的出现就是为了解决这个问题。    
+
+VBO和EBO的作用是在显存中提前开辟好一块内存，用于缓存顶点数据或者图元索引数据，从而避免每次绘制时的CPU和GPU之间的内存拷贝，可以改进渲染性能，降低内存带宽和功耗。  
+OpenGL ES3.0支持两类缓冲区对象: 顶点数组缓冲区对象、图元索引缓冲区对象。  
+
+GL_ARRAY_BUFFER标志指定的缓冲区对象用于保存顶点数组。   
+
+GL_EMELEMNT_ARRAY_BUFFER标志指定的缓存区对象用于保存图元索引。   
+
+ 
 **这里会在GPU上创建内存用于储存我们的顶点数据，还要配置OpenGL如何解释这些内存，并且指定其如何发送给显卡。**      
 
 顶点着色器接着会处理我们在内存中指定数量的顶点。
@@ -197,6 +214,7 @@ someOpenGLFunctionThatDrawsOurTriangle();
 绑定正确的缓冲对象，为每个物体配置所有顶点属性很快就变成一件麻烦事。有没有一些方法可以使我们把所有这些状态配置储存在一个对象中，并且可以通过绑定这个对象来恢复状态呢？
 
 顶点数组对象(Vertex Array Object, VAO)可以像顶点缓冲对象那样被绑定，任何随后的顶点属性调用都会储存在这个VAO中。    
+
 这样的好处就是，当配置顶点属性指针时，你只需要将那些调用执行一次，之后再绘制物体的时候只需要绑定相应的VAO就行了。    
 这使在不同顶点数据和属性配置之间切换变得非常简单，只需要绑定不同的VAO就行了。刚刚设置的所有状态都将存储在VAO中。
 
diff --git "a/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md" "b/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
index 0df4bcff..4bc0353a 100644
--- "a/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
+++ "b/VideoDevelopment/OpenGL/8.GLES\347\261\273\345\217\212Matrix\347\261\273.md"
@@ -244,7 +244,13 @@ OpenGL ES中使用的是列向量。列向量和矩阵相乘实现变换时，
 
 所谓齐次坐标形式也就是在x、y、z 3个坐标值后面增加第四个量w，未变换时w值一般为1。
 
-所谓齐次坐标表示就是用N+1维坐标表示N维坐标。采用齐次坐标是由于很多在N维空间中难以解决的问题在N+1维空间中会变得比较简单。
+所谓齐次坐标表示就是用N+1维坐标表示N维坐标。     
+
+齐次坐标是为了兼容点的平移操作，使得我们可以用同一个公式对点和方向做运算。  y
+采用齐次坐标是由于很多在N维空间中难以解决的问题在N+1维空间中会变得比较简单。
+
+
+
 
 
 ##### 旋转变换
diff --git "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md" "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"
index d8258366..e6a24893 100644
--- "a/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
+++ "b/VideoDevelopment/OpenGL/9.OpenGL ES\347\272\271\347\220\206.md"	
@@ -19,6 +19,9 @@
 
 
 
+使用纹理坐标来获取纹理颜色就称为采样(sampling)。
+
+
 ### 基本原理
 
 启用纹理映射功能后，如果想把一副纹理应用到相应的几何图元，就必须告知渲染系统如何进行纹理的映射。     
@@ -380,6 +383,33 @@ GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, textureId);
 GLES20.glUniform1i(aTextureLocation, 0);
 ```
 
+
+
+#### 为什么要激活纹理单元0？(glActiveTexture(GL_TEXTURE_0))
+
+
+- 纹理单元系统: OpenGL通过纹理单元(Texture Unit)管理多个纹理。    
+
+每个纹理单元都是一个独立的“插槽”，可以绑定不同类型的纹理(GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP等)
+
+- 多纹理支持: 现代GPU支持同时使用多个纹理(例如同时使用漫反射贴纸+法线贴图+高光贴图)。通过激活不同纹理单元(GL_TEXTURE0、GL_TEXTURE1...)来实现这一点。     
+
+- 状态机特性: OpenGL是状态机，glActiveTexture选择当前操作的纹理单元，后续的glBindTexture和glTexParameter等操作都作用于这个单元。    
+
+#### 为什么要绑定纹理? (glBindTexture(GL_TEXTURE_2D, m_TextureId))  
+
+- 关联操作目标: 将具体的纹理对象(textureId)与当前激活的纹理单元(GL_TEXTURE0)关联。    
+
+- 多类型支持: 同一个纹理单元可以绑定不同类型的纹理(例如GL_TEXTURE_2D和GL_TEXTURE_CUBE_MAP互不影响)。
+
+- 渲染时使用: 绘制时，着色器通过纹理单元索引(这里是0)访问绑定的纹理数据。     
+
+#### 为什么要设置采样器为0? glUniform1i(m_SamplerLoc, 0) 
+
+- 着色器(uniform sampler2D texture1)与纹理单元的桥梁: 在着色器中sampler2D类型的uniform变量需要知道从哪个纹理单元读取数据。 0表示使用纹理单元GL_TEXTURE0(1对应GL_TEXTURE1,以此类推)。也就是告诉OpenGL每个着色器采样器从哪个纹理单元采样数据。     
+
+那这里为什么参数是0，而不是GL_TEXTURE0? 这是因为glUniform1i传递的是索引值，而不是OpenGL枚举常量。   
+
 这里有没有很奇怪，sampler2D的变量是uniform的，但是我们并不是用glUniform()方法给他赋值，而是使用glUniform1i()。         
 这是因为可以给纹理采样器分配一个位置值，这样我们就能够在一个片段着色器中设置多个纹理单元。一个纹理的话，纹理单元是默认为0，它是默认激活的，纹理单元的主要目的就是给着色器多一个使用的纹理。         
 通过纹理单元赋值给采样器，我们可以一次绑定多个纹理，只要我们在使用的时候激活纹理。
@@ -389,6 +419,17 @@ OpenGL至少保证有16个纹理单元供你使用，也就是说你可以激活
 它们都是按顺序定义的，所以我们也可以通过GL_TEXUTURE0 + 8的方式获得GL_TEXTURE8，这在需要循环一些纹理单元的时候会很有用。    
 
 
+#### 完整的流程
+
+1. 激活单元: 选择操作目标(GL_TEXTURE0)。 类比: 选择电视机第0号HDMI输入口。   
+2. 绑定纹理: 将具体纹理放入该单元。 类比: 给第0号HDMI口连接一个播放器。    
+3. 设置采样器: 告诉着色器从哪个“HDMI口”读取数据。 类比: 告诉观众观看第0 HDMI口的画面。     
+
+
+
+
+
+
 ```java
   public class TextureRender extends BaseGLSurfaceViewRenderer {
       private final FloatBuffer vertextBuffer;

From 84b244c71851c2a69c5487e32a67a46bbe2a454c Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 16 Jun 2025 20:35:27 +0800
Subject: [PATCH 205/213] update

---
 ...\350\267\203\346\270\270\346\210\217II.md" | 23 ++++----
 "Algorithm/11.H\346\214\207\346\225\260.md"   | 33 +++++------
 ...17\346\234\272\345\205\203\347\264\240.md" | 26 ++++-----
 ...04\347\232\204\344\271\230\347\247\257.md" | 19 ++++---
 ...4.\345\212\240\346\262\271\347\253\231.md" | 55 ++++++++++---------
 ...06\345\217\221\347\263\226\346\236\234.md" | 16 +++---
 ...6.\346\216\245\351\233\250\346\260\264.md" | 15 ++---
 ...32\346\225\260\345\205\203\347\264\240.md" | 13 +++--
 ...56\350\275\254\346\225\260\347\273\204.md" | 33 +++++------
 ...00\344\275\263\346\227\266\346\234\272.md" |  8 +--
 ...\344\275\263\346\227\266\346\234\272II.md" | 34 ++++++------
 ...63\350\267\203\346\270\270\346\210\217.md" | 19 ++++---
 12 files changed, 153 insertions(+), 141 deletions(-)

diff --git "a/Algorithm/10.\350\267\263\350\267\203\346\270\270\346\210\217II.md" "b/Algorithm/10.\350\267\263\350\267\203\346\270\270\346\210\217II.md"
index cd9ecad4..0e95d5fa 100644
--- "a/Algorithm/10.\350\267\263\350\267\203\346\270\270\346\210\217II.md"
+++ "b/Algorithm/10.\350\267\263\350\267\203\346\270\270\346\210\217II.md"
@@ -6,30 +6,31 @@
 
 给定一个长度为 n 的 0 索引整数数组 nums。初始位置为 nums[0]。
 
-每个元素 nums[i] 表示从索引 i 向后跳转的最大长度。换句话说，如果你在 nums[i] 处，你可以跳转到任意 nums[i + j] 处:
+每个元素 nums[i] 表示从索引 i 向后跳转的最大长度。换句话说，如果你在 nums[i] 处，你可以跳转到任意 nums[i + j] 处:       
 
-0 <= j <= nums[i] 
-i + j < n
+- 0 <= j <= nums[i] 
+- i + j < n
 返回到达 nums[n - 1] 的最小跳跃次数。生成的测试用例可以到达 nums[n - 1]。
 
  
 
 示例 1:
 
-输入: nums = [2,3,1,1,4]
-输出: 2
-解释: 跳到最后一个位置的最小跳跃数是 2。
-     从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。
-示例 2:
+- 输入: nums = [2,3,1,1,4]
+- 输出: 2
+- 解释: 跳到最后一个位置的最小跳跃数是 2。
+    - 从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。
 
-输入: nums = [2,3,0,1,4]
-输出: 2
+示例 2:     
+
+- 输入: nums = [2,3,0,1,4]
+- 输出: 2
 
 
 ### 思路
 
 
-贪心的思路，局部最优：当前可移动距离尽可能多走，如果还没到终点，步数再加一。整体最优：一步尽可能多走，从而达到最少步数。
+贪心的思路，局部最优：当前可移动距离尽可能多走，如果还没到终点，步数再加一。整体最优：一步尽可能多走，从而达到最少步数。     
 
 所以真正解题的时候，要从覆盖范围出发，不管怎么跳，覆盖范围内一定是可以跳到的，以最小的步数增加覆盖范围，覆盖范围一旦覆盖了终点，得到的就是最少步数！
 
diff --git "a/Algorithm/11.H\346\214\207\346\225\260.md" "b/Algorithm/11.H\346\214\207\346\225\260.md"
index 5be403e0..20afa38a 100644
--- "a/Algorithm/11.H\346\214\207\346\225\260.md"
+++ "b/Algorithm/11.H\346\214\207\346\225\260.md"
@@ -10,16 +10,17 @@
 
  
 
-示例 1：
+示例 1:     
 
-输入：citations = [3,0,6,1,5]
-输出：3 
-解释：给定数组表示研究者总共有 5 篇论文，每篇论文相应的被引用了 3, 0, 6, 1, 5 次。
-     由于研究者有 3 篇论文每篇 至少 被引用了 3 次，其余两篇论文每篇被引用 不多于 3 次，所以她的 h 指数是 3。
-示例 2：
+- 输入：citations = [3,0,6,1,5]
+- 输出：3 
+- 解释：给定数组表示研究者总共有 5 篇论文，每篇论文相应的被引用了 3, 0, 6, 1, 5 次。
+    - 由于研究者有 3 篇论文每篇 至少 被引用了 3 次，其余两篇论文每篇被引用 不多于 3 次，所以她的 h 指数是 3。
 
-输入：citations = [1,3,1]
-输出：1
+示例 2:     
+
+- 输入：citations = [1,3,1]
+- 输出：1
 
 ### 思路
 
@@ -67,7 +68,7 @@ public int hIndex(int[] citations) {
 
 最终的时间复杂度与排序算法的时间复杂度有关
 
-复杂度分析
+复杂度分析:     
 
 - 时间复杂度：O(nlogn)，其中 n 为数组 citations 的长度。即为排序的时间复杂度。
 
@@ -123,18 +124,18 @@ public class Solution {
 }
 ```
 
-复杂度分析
+复杂度分析:    
 
-时间复杂度：O(n)，其中 n 为数组 citations 的长度。需要遍历数组 citations 一次，以及遍历长度为 n+1 的数组 counter 一次。
+- 时间复杂度：O(n)，其中 n 为数组 citations 的长度。需要遍历数组 citations 一次，以及遍历长度为 n+1 的数组 counter 一次。
 
-空间复杂度：O(n)，其中 n 为数组 citations 的长度。需要创建长度为 n+1 的数组 counter。
+- 空间复杂度：O(n)，其中 n 为数组 citations 的长度。需要创建长度为 n+1 的数组 counter。
 
 
 ##### 方法三：二分法
 
 所谓的 h 指数是指一个具体的数值，该数值为“最大”的满足「至少发表了 x 篇论文，且每篇论文至少被引用 x 次」定义的合法数，重点是“最大”。
 
-给定所有论文的引用次数情况为[3,0,6,1,5]，可统计满足定义的数值有哪些：
+给定所有论文的引用次数情况为[3,0,6,1,5]，可统计满足定义的数值有哪些:     
 
 ```
 h=0，含义为「至少发表了 0 篇，且这 0 篇论文至少被引用 0 次」，空集即满足，恒成立；
@@ -215,10 +216,10 @@ class Solution {
 
 
 
-复杂度分析
+复杂度分析:     
 
-时间复杂度：O(nlogn)，其中 n 为数组 citations 的长度。需要进行 logn 次二分搜索，每次二分搜索需要遍历数组 citations 一次。
-空间复杂度：O(1)，只需要常数个变量来进行二分搜索。
+- 时间复杂度：O(nlogn)，其中 n 为数组 citations 的长度。需要进行 logn 次二分搜索，每次二分搜索需要遍历数组 citations 一次。
+- 空间复杂度：O(1)，只需要常数个变量来进行二分搜索。
 
 
 
diff --git "a/Algorithm/12.O(1) \346\227\266\351\227\264\346\217\222\345\205\245\343\200\201\345\210\240\351\231\244\345\222\214\350\216\267\345\217\226\351\232\217\346\234\272\345\205\203\347\264\240.md" "b/Algorithm/12.O(1) \346\227\266\351\227\264\346\217\222\345\205\245\343\200\201\345\210\240\351\231\244\345\222\214\350\216\267\345\217\226\351\232\217\346\234\272\345\205\203\347\264\240.md"
index 469f6e99..68b25643 100644
--- "a/Algorithm/12.O(1) \346\227\266\351\227\264\346\217\222\345\205\245\343\200\201\345\210\240\351\231\244\345\222\214\350\216\267\345\217\226\351\232\217\346\234\272\345\205\203\347\264\240.md"	
+++ "b/Algorithm/12.O(1) \346\227\266\351\227\264\346\217\222\345\205\245\343\200\201\345\210\240\351\231\244\345\222\214\350\216\267\345\217\226\351\232\217\346\234\272\345\205\203\347\264\240.md"	
@@ -4,25 +4,25 @@
 
 ### 题目
 
-实现RandomizedSet 类：
+实现RandomizedSet类:      
+
+- RandomizedSet() 初始化 RandomizedSet 对象      
+- bool insert(int val) 当元素 val 不存在时，向集合中插入该项，并返回 true ；否则，返回 false 。
+- bool remove(int val) 当元素 val 存在时，从集合中移除该项，并返回 true ；否则，返回 false 。
+- int getRandom() 随机返回现有集合中的一项（测试用例保证调用此方法时集合中至少存在一个元素）。每个元素应该有 相同的概率 被返回。
 
-RandomizedSet() 初始化 RandomizedSet 对象
-bool insert(int val) 当元素 val 不存在时，向集合中插入该项，并返回 true ；否则，返回 false 。
-bool remove(int val) 当元素 val 存在时，从集合中移除该项，并返回 true ；否则，返回 false 。
-int getRandom() 随机返回现有集合中的一项（测试用例保证调用此方法时集合中至少存在一个元素）。每个元素应该有 相同的概率 被返回。
 你必须实现类的所有函数，并满足每个函数的 平均 时间复杂度为 O(1) 。
 
  
 
-示例：
+示例:      
 
-输入
-["RandomizedSet", "insert", "remove", "insert", "getRandom", "remove", "insert", "getRandom"]
-[[], [1], [2], [2], [], [1], [2], []]
-输出
-[null, true, false, true, 2, true, false, 2]
+- 输入["RandomizedSet", "insert", "remove", "insert", "getRandom", "remove", "insert", "getRandom"]
+- [[], [1], [2], [2], [], [1], [2], []]
+- 输出[null, true, false, true, 2, true, false, 2]
 
-解释
+解释:    
+```
 RandomizedSet randomizedSet = new RandomizedSet();
 randomizedSet.insert(1); // 向集合中插入 1 。返回 true 表示 1 被成功地插入。
 randomizedSet.remove(2); // 返回 false ，表示集合中不存在 2 。
@@ -31,7 +31,7 @@ randomizedSet.getRandom(); // getRandom 应随机返回 1 或 2 。
 randomizedSet.remove(1); // 从集合中移除 1 ，返回 true 。集合现在包含 [2] 。
 randomizedSet.insert(2); // 2 已在集合中，所以返回 false 。
 randomizedSet.getRandom(); // 由于 2 是集合中唯一的数字，getRandom 总是返回 2 。
- 
+``` 
 
 提示:       
 
diff --git "a/Algorithm/13.\351\231\244\350\207\252\350\272\253\344\273\245\345\244\226\346\225\260\347\273\204\347\232\204\344\271\230\347\247\257.md" "b/Algorithm/13.\351\231\244\350\207\252\350\272\253\344\273\245\345\244\226\346\225\260\347\273\204\347\232\204\344\271\230\347\247\257.md"
index 6b555aeb..abff28d0 100644
--- "a/Algorithm/13.\351\231\244\350\207\252\350\272\253\344\273\245\345\244\226\346\225\260\347\273\204\347\232\204\344\271\230\347\247\257.md"
+++ "b/Algorithm/13.\351\231\244\350\207\252\350\272\253\344\273\245\345\244\226\346\225\260\347\273\204\347\232\204\344\271\230\347\247\257.md"
@@ -4,22 +4,23 @@
 
 ### 题目
 
-给你一个整数数组 nums，返回 数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积 。
+给你一个整数数组nums，返回数组answer，其中answer[i]等于nums中除nums[i]之外其余各元素的乘积。     
 
-题目数据 保证 数组 nums之中任意元素的全部前缀元素和后缀的乘积都在  32 位 整数范围内。
+题目数据保证数组nums之中任意元素的全部前缀元素和后缀的乘积都在32位整数范围内。    
 
-请 不要使用除法，且在 O(n) 时间复杂度内完成此题。
+请***不要使用除法***，且在O(n)时间复杂度内完成此题。
 
  
 
-示例 1:
+示例 1:     
 
-输入: nums = [1,2,3,4]
-输出: [24,12,8,6]
-示例 2:
+- 输入: nums = [1,2,3,4]
+- 输出: [24,12,8,6]
 
-输入: nums = [-1,1,0,-3,3]
-输出: [0,0,9,0,0]
+示例 2:    
+
+- 输入: nums = [-1,1,0,-3,3]
+- 输出: [0,0,9,0,0]
  
 
 提示:    
diff --git "a/Algorithm/14.\345\212\240\346\262\271\347\253\231.md" "b/Algorithm/14.\345\212\240\346\262\271\347\253\231.md"
index b39a9edd..8debb624 100644
--- "a/Algorithm/14.\345\212\240\346\262\271\347\253\231.md"
+++ "b/Algorithm/14.\345\212\240\346\262\271\347\253\231.md"
@@ -12,37 +12,40 @@
 
  
 
-示例 1:
-
-输入: gas = [1,2,3,4,5], cost = [3,4,5,1,2]
-输出: 3
-解释:
-从 3 号加油站(索引为 3 处)出发，可获得 4 升汽油。此时油箱有 = 0 + 4 = 4 升汽油
-开往 4 号加油站，此时油箱有 4 - 1 + 5 = 8 升汽油
-开往 0 号加油站，此时油箱有 8 - 2 + 1 = 7 升汽油
-开往 1 号加油站，此时油箱有 7 - 3 + 2 = 6 升汽油
-开往 2 号加油站，此时油箱有 6 - 4 + 3 = 5 升汽油
-开往 3 号加油站，你需要消耗 5 升汽油，正好足够你返回到 3 号加油站。
+示例 1:    
+
+- 输入: gas = [1,2,3,4,5], cost = [3,4,5,1,2]
+- 输出: 3
+- 解释:
+    - 从 3 号加油站(索引为 3 处)出发，可获得 4 升汽油。此时油箱有 = 0 + 4 = 4 升汽油
+    - 开往 4 号加油站，此时油箱有 4 - 1 + 5 = 8 升汽油
+    - 开往 0 号加油站，此时油箱有 8 - 2 + 1 = 7 升汽油
+    - 开往 1 号加油站，此时油箱有 7 - 3 + 2 = 6 升汽油
+    - 开往 2 号加油站，此时油箱有 6 - 4 + 3 = 5 升汽油
+    - 开往 3 号加油站，你需要消耗 5 升汽油，正好足够你返回到 3 号加油站。
+
 因此，3 可为起始索引。
-示例 2:
-
-输入: gas = [2,3,4], cost = [3,4,3]
-输出: -1
-解释:
-你不能从 0 号或 1 号加油站出发，因为没有足够的汽油可以让你行驶到下一个加油站。
-我们从 2 号加油站出发，可以获得 4 升汽油。 此时油箱有 = 0 + 4 = 4 升汽油
-开往 0 号加油站，此时油箱有 4 - 3 + 2 = 3 升汽油
-开往 1 号加油站，此时油箱有 3 - 3 + 3 = 3 升汽油
-你无法返回 2 号加油站，因为返程需要消耗 4 升汽油，但是你的油箱只有 3 升汽油。
+
+示例 2:      
+
+- 输入: gas = [2,3,4], cost = [3,4,3]
+- 输出: -1
+- 解释:       
+    - 你不能从 0 号或 1 号加油站出发，因为没有足够的汽油可以让你行驶到下一个加油站。
+    - 我们从 2 号加油站出发，可以获得 4 升汽油。 此时油箱有 = 0 + 4 = 4 升汽油
+    - 开往 0 号加油站，此时油箱有 4 - 3 + 2 = 3 升汽油
+    - 开往 1 号加油站，此时油箱有 3 - 3 + 3 = 3 升汽油
+    - 你无法返回 2 号加油站，因为返程需要消耗 4 升汽油，但是你的油箱只有 3 升汽油。
+
 因此，无论怎样，你都不可能绕环路行驶一周。
  
 
-提示:
+提示:     
 
-n == gas.length == cost.length
-1 <= n <= 105
-0 <= gas[i], cost[i] <= 104
-输入保证答案唯一。
+- n == gas.length == cost.length
+- 1 <= n <= 105
+- 0 <= gas[i], cost[i] <= 104
+- 输入保证答案唯一。
 
 ### 思路
 
diff --git "a/Algorithm/15.\345\210\206\345\217\221\347\263\226\346\236\234.md" "b/Algorithm/15.\345\210\206\345\217\221\347\263\226\346\236\234.md"
index 66db9e01..b74a91ed 100644
--- "a/Algorithm/15.\345\210\206\345\217\221\347\263\226\346\236\234.md"
+++ "b/Algorithm/15.\345\210\206\345\217\221\347\263\226\346\236\234.md"
@@ -4,17 +4,17 @@
 
 ### 题目
 
-n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。
-
-你需要按照以下要求，给这些孩子分发糖果：
+n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。      
+ 
+你需要按照以下要求，给这些孩子分发糖果:    
 
-每个孩子至少分配到 1 个糖果。
-相邻两个孩子评分更高的孩子会获得更多的糖果。
-请你给每个孩子分发糖果，计算并返回需要准备的 最少糖果数目 。
+- 每个孩子至少分配到 1 个糖果。
+- 相邻两个孩子评分更高的孩子会获得更多的糖果。
+- 请你给每个孩子分发糖果，计算并返回需要准备的 最少糖果数目 。
 
  
 
-示例 1:  
+示例 1:    
 
 - 输入：ratings = [1,0,2]
 - 输出：5
@@ -28,7 +28,7 @@ n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的
      第三个孩子只得到 1 颗糖果，这满足题面中的两个条件。
  
 
-提示：
+提示:     
 
 - n == ratings.length
 - 1 <= n <= 2 * 104
diff --git "a/Algorithm/16.\346\216\245\351\233\250\346\260\264.md" "b/Algorithm/16.\346\216\245\351\233\250\346\260\264.md"
index 853cadbd..0a86815c 100644
--- "a/Algorithm/16.\346\216\245\351\233\250\346\260\264.md"
+++ "b/Algorithm/16.\346\216\245\351\233\250\346\260\264.md"
@@ -6,17 +6,18 @@
 
 给定n个非负整数表示每个宽度为1的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。
 
-示例 1：
+示例 1:    
 
 ![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/rainwatertrap_1.png?raw=true)
 
-输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
-输出：6
-解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。 
-示例 2：
+- 输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
+- 输出：6
+- 解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。 
 
-输入：height = [4,2,0,3,2,5]
-输出：9
+示例 2:     
+
+- 输入：height = [4,2,0,3,2,5]
+- 输出：9
 
 
 ### 思路
diff --git "a/Algorithm/5.\345\244\232\346\225\260\345\205\203\347\264\240.md" "b/Algorithm/5.\345\244\232\346\225\260\345\205\203\347\264\240.md"
index 71e6953d..f99c600a 100644
--- "a/Algorithm/5.\345\244\232\346\225\260\345\205\203\347\264\240.md"
+++ "b/Algorithm/5.\345\244\232\346\225\260\345\205\203\347\264\240.md"
@@ -11,14 +11,15 @@
 
 数组中出现次数超过一半的数字被称为众数。
 
-示例 1：
+示例 1:    
 
-输入：nums = [3,2,3]
-输出：3
-示例 2：
+- 输入：nums = [3,2,3]
+- 输出：3
 
-输入：nums = [2,2,1,1,1,2,2]
-输出：2
+示例 2:    
+
+- 输入：nums = [2,2,1,1,1,2,2]
+- 输出：2
 
 
 
diff --git "a/Algorithm/6.\350\275\256\350\275\254\346\225\260\347\273\204.md" "b/Algorithm/6.\350\275\256\350\275\254\346\225\260\347\273\204.md"
index eb2940c2..4f9e6d02 100644
--- "a/Algorithm/6.\350\275\256\350\275\254\346\225\260\347\273\204.md"
+++ "b/Algorithm/6.\350\275\256\350\275\254\346\225\260\347\273\204.md"
@@ -7,21 +7,25 @@
 给定一个整数数组 nums，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。
 
 
-示例 1:
+示例 1:     
 
-输入: nums = [1,2,3,4,5,6,7], k = 3
-输出: [5,6,7,1,2,3,4]
-解释:
-向右轮转 1 步: [7,1,2,3,4,5,6]
-向右轮转 2 步: [6,7,1,2,3,4,5]
-向右轮转 3 步: [5,6,7,1,2,3,4]
-示例 2:
+- 输入: nums = [1,2,3,4,5,6,7], k = 3
+- 输出: [5,6,7,1,2,3,4]
 
-输入：nums = [-1,-100,3,99], k = 2
-输出：[3,99,-1,-100]
-解释: 
-向右轮转 1 步: [99,-1,-100,3]
-向右轮转 2 步: [3,99,-1,-100]
+解释:      
+- 向右轮转 1 步: [7,1,2,3,4,5,6]
+- 向右轮转 2 步: [6,7,1,2,3,4,5]
+- 向右轮转 3 步: [5,6,7,1,2,3,4]
+
+示例 2:     
+
+- 输入：nums = [-1,-100,3,99], k = 2
+- 输出：[3,99,-1,-100]
+
+解释:     
+
+- 向右轮转 1 步: [99,-1,-100,3]
+- 向右轮转 2 步: [3,99,-1,-100]
 
 
 
@@ -77,9 +81,6 @@ class Solution:
 ```
 
 
-
-
-
 ---
 - 邮箱 ：charon.chui@gmail.com  
 - Good Luck! 
diff --git "a/Algorithm/7.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.md" "b/Algorithm/7.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.md"
index 5e4f9722..18fa2d74 100644
--- "a/Algorithm/7.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.md"
+++ "b/Algorithm/7.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.md"
@@ -18,11 +18,11 @@
 - 输出：5
 - 解释：在第2天（股票价格 = 1）的时候买入，在第5天（股票价格=6）的时候卖出，最大利润= `6-1 = 5` 。
      注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
-示例 2：
+示例 2:   
 
-输入：prices = [7,6,4,3,1]
-输出：0
-解释：在这种情况下, 没有交易完成, 所以最大利润为 0。
+- 输入：prices = [7,6,4,3,1]
+- 输出：0
+- 解释：在这种情况下, 没有交易完成, 所以最大利润为 0。
 
 
 ### 思路
diff --git "a/Algorithm/8.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272II.md" "b/Algorithm/8.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272II.md"
index 05b07c7d..00e0fa54 100644
--- "a/Algorithm/8.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272II.md"
+++ "b/Algorithm/8.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272II.md"
@@ -12,24 +12,26 @@
 
  
 
-示例 1：
+示例 1:     
 
-输入：prices = [7,1,5,3,6,4]
-输出：7
-解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。
-随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3。
-最大总利润为 4 + 3 = 7 。
-示例 2：
+- 输入：prices = [7,1,5,3,6,4]
+- 输出：7
+- 解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。
+- 随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3。
+- 最大总利润为 4 + 3 = 7 。
 
-输入：prices = [1,2,3,4,5]
-输出：4
-解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。
-最大总利润为 4 。
-示例 3：
+示例 2:    
 
-输入：prices = [7,6,4,3,1]
-输出：0
-解释：在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0。
+- 输入：prices = [1,2,3,4,5]
+- 输出：4
+- 解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。
+- 最大总利润为 4。
+
+示例 3:      
+
+- 输入：prices = [7,6,4,3,1]
+- 输出：0
+- 解释：在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0。
 
 
 ### 思路
@@ -50,7 +52,7 @@ class Solution {
             if (i > buyPirce) {
                 totalIncome += (i - buyPirce)
                 buyPirce = i
-            } else if ( < buyPrice) {
+            } else if (i < buyPrice) {
                 buyPirce = i
             }
         }
diff --git "a/Algorithm/9.\350\267\263\350\267\203\346\270\270\346\210\217.md" "b/Algorithm/9.\350\267\263\350\267\203\346\270\270\346\210\217.md"
index 705396c1..3bb87d3a 100644
--- "a/Algorithm/9.\350\267\263\350\267\203\346\270\270\346\210\217.md"
+++ "b/Algorithm/9.\350\267\263\350\267\203\346\270\270\346\210\217.md"
@@ -10,16 +10,17 @@
 
  
 
-示例 1：
+示例 1:    
 
-输入：nums = [2,3,1,1,4]
-输出：true
-解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。
-示例 2：
+- 输入：nums = [2,3,1,1,4]
+- 输出：true
+- 解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。
 
-输入：nums = [3,2,1,0,4]
-输出：false
-解释：无论怎样，总会到达下标为 3 的位置。但该下标的最大跳跃长度是 0 ， 所以永远不可能到达最后一个下标。
+示例 2:   
+
+- 输入：nums = [3,2,1,0,4]
+- 输出：false
+- 解释：无论怎样，总会到达下标为 3 的位置。但该下标的最大跳跃长度是 0 ， 所以永远不可能到达最后一个下标。
 
 
 
@@ -74,7 +75,7 @@ class Solution:
             if cur < nums[i]:
                 cur = nums[i]
             if cur <= 0:
-                    break
+                break
         return i == (len(nums) - 1)
 ```
 

From c19a90be805f24af29b1bf52c8065ee444400d03 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Tue, 17 Jun 2025 18:57:13 +0800
Subject: [PATCH 206/213] add notes

---
 ...27\350\275\254\346\225\264\346\225\260.md" | 116 +++++++
 ...27\351\251\254\346\225\260\345\255\227.md" | 114 ++++++
 ...15\347\232\204\351\225\277\345\272\246.md" |  78 +++++
 ...54\345\205\261\345\211\215\347\274\200.md" |  68 ++++
 ...55\347\232\204\345\215\225\350\257\215.md" |  84 +++++
 ...27\345\275\242\350\275\254\346\215\242.md" | 106 ++++++
 ...71\347\232\204\344\270\213\346\240\207.md" | 324 ++++++++++++++++++
 ...46\345\217\263\345\257\271\351\275\220.md" |  80 +++++
 ...01\345\233\236\346\226\207\344\270\262.md" |  48 +++
 Algorithm/26..md                              |  17 +
 Algorithm/27..md                              |  17 +
 11 files changed, 1052 insertions(+)
 create mode 100644 "Algorithm/17.\347\275\227\351\251\254\346\225\260\345\255\227\350\275\254\346\225\264\346\225\260.md"
 create mode 100644 "Algorithm/18.\346\225\264\346\225\260\350\275\254\347\275\227\351\251\254\346\225\260\345\255\227.md"
 create mode 100644 "Algorithm/19.\346\234\200\345\220\216\344\270\200\344\270\252\345\215\225\350\257\215\347\232\204\351\225\277\345\272\246.md"
 create mode 100644 "Algorithm/20.\346\234\200\351\225\277\345\205\254\345\205\261\345\211\215\347\274\200.md"
 create mode 100644 "Algorithm/21.\345\217\215\350\275\254\345\255\227\347\254\246\344\270\262\344\270\255\347\232\204\345\215\225\350\257\215.md"
 create mode 100644 "Algorithm/22.Z\345\255\227\345\275\242\350\275\254\346\215\242.md"
 create mode 100644 "Algorithm/23.\346\211\276\345\207\272\345\255\227\347\254\246\344\270\262\344\270\255\347\254\254\344\270\200\344\270\252\345\214\271\351\205\215\351\241\271\347\232\204\344\270\213\346\240\207.md"
 create mode 100644 "Algorithm/24.\346\226\207\346\234\254\345\267\246\345\217\263\345\257\271\351\275\220.md"
 create mode 100644 "Algorithm/25.\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262.md"
 create mode 100644 Algorithm/26..md
 create mode 100644 Algorithm/27..md

diff --git "a/Algorithm/17.\347\275\227\351\251\254\346\225\260\345\255\227\350\275\254\346\225\264\346\225\260.md" "b/Algorithm/17.\347\275\227\351\251\254\346\225\260\345\255\227\350\275\254\346\225\264\346\225\260.md"
new file mode 100644
index 00000000..f6765dd5
--- /dev/null
+++ "b/Algorithm/17.\347\275\227\351\251\254\346\225\260\345\255\227\350\275\254\346\225\264\346\225\260.md"
@@ -0,0 +1,116 @@
+17.罗马数字转整数
+===
+
+
+### 题目
+
+罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。
+
+```
+字符          数值
+I             1
+V             5
+X             10
+L             50
+C             100
+D             500
+M             1000
+```
+例如， 罗马数字 2 写做 II ，即为两个并列的 1 。12 写做 XII ，即为 X + II 。 27 写做  XXVII, 即为 XX + V + II 。
+
+通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
+
+- I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
+- X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。 
+- C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
+- 给定一个罗马数字，将其转换成整数。
+
+ 
+
+示例 1:     
+
+- 输入: s = "III"
+- 输出: 3
+
+示例 2:      
+
+- 输入: s = "IV"
+- 输出: 4
+
+示例 3:     
+
+- 输入: s = "IX"
+- 输出: 9
+
+示例 4:      
+
+- 输入: s = "LVIII"
+- 输出: 58
+- 解释: L = 50, V= 5, III = 3.
+
+示例 5:     
+
+- 输入: s = "MCMXCIV"
+- 输出: 1994
+- 解释: M = 1000, CM = 900, XC = 90, IV = 4.
+ 
+
+提示:     
+
+- 1 <= s.length <= 15
+- s 仅含字符 ('I', 'V', 'X', 'L', 'C', 'D', 'M')
+- 题目数据保证 s 是一个有效的罗马数字，且表示整数在范围 [1, 3999] 内
+- 题目所给测试用例皆符合罗马数字书写规则，不会出现跨位等情况。
+- IL 和 IM 这样的例子并不符合题目要求，49 应该写作 XLIX，999 应该写作 CMXCIX 。
+
+### 思路
+
+通常情况下，罗马数字中小的数字在大的数字的右边。若输入的字符串满足该情况，那么可以将每个字符视作一个单独的值，累加每个字符对应的数值即可。
+
+例如 XXVII 可视作 X+X+V+I+I=10+10+5+1+1=27。
+
+若存在小的数字在大的数字的左边的情况，根据规则需要减去小的数字。对于这种情况，我们也可以将每个字符视作一个单独的值，若一个数字右侧的数字比它大，则将该数字的符号取反。
+
+例如 XIV 可视作 X−I+V=10−1+5=14。
+
+所以我们可以从左遍历，如果一个字符右边的比当前的大，那这个就要减去该值，否则就加。
+
+```java
+class Solution {
+    Map<Character, Integer> symbolValues = new HashMap<Character, Integer>() {{
+        put('I', 1);
+        put('V', 5);
+        put('X', 10);
+        put('L', 50);
+        put('C', 100);
+        put('D', 500);
+        put('M', 1000);
+    }};
+
+    public int romanToInt(String s) {
+        int ans = 0;
+        int n = s.length();
+        for (int i = 0; i < n; ++i) {
+            int value = symbolValues.get(s.charAt(i));
+            if (i < n - 1 && value < symbolValues.get(s.charAt(i + 1))) {
+                ans -= value;
+            } else {
+                ans += value;
+            }
+        }
+        return ans;
+    }
+}
+```
+
+复杂度分析:   
+
+- 时间复杂度：O(n)，其中 n 是字符串 s 的长度。
+
+- 空间复杂度：O(1)。
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/18.\346\225\264\346\225\260\350\275\254\347\275\227\351\251\254\346\225\260\345\255\227.md" "b/Algorithm/18.\346\225\264\346\225\260\350\275\254\347\275\227\351\251\254\346\225\260\345\255\227.md"
new file mode 100644
index 00000000..cce5ae83
--- /dev/null
+++ "b/Algorithm/18.\346\225\264\346\225\260\350\275\254\347\275\227\351\251\254\346\225\260\345\255\227.md"
@@ -0,0 +1,114 @@
+18.整数转罗马数字
+===
+
+
+### 题目
+
+七个不同的符号代表罗马数字，其值如下：
+```
+符号	值
+I	1
+V	5
+X	10
+L	50
+C	100
+D	500
+M	1000
+```
+罗马数字是通过添加从最高到最低的小数位值的转换而形成的。将小数位值转换为罗马数字有以下规则：
+
+- 如果该值不是以 4 或 9 开头，请选择可以从输入中减去的最大值的符号，将该符号附加到结果，减去其值，然后将其余部分转换为罗马数字。
+- 如果该值以 4 或 9 开头，使用 减法形式，表示从以下符号中减去一个符号，例如 4 是 5 (V) 减 1 (I): IV ，9 是 10 (X) 减 1 (I)：IX。仅使用以下减法形式：4 (IV)，9 (IX)，40 (XL)，90 (XC)，400 (CD) 和 900 (CM)。
+- 只有 10 的次方（I, X, C, M）最多可以连续附加 3 次以代表 10 的倍数。你不能多次附加 5 (V)，50 (L) 或 500 (D)。如果需要将符号附加4次，请使用 减法形式。
+- 给定一个整数，将其转换为罗马数字。
+
+ 
+
+示例 1:   
+
+- 输入：num = 3749
+
+- 输出： "MMMDCCXLIX"
+
+- 解释:   
+
+    - 3000 = MMM 由于 1000 (M) + 1000 (M) + 1000 (M)
+    - 700 = DCC 由于 500 (D) + 100 (C) + 100 (C)
+    - 40 = XL 由于 50 (L) 减 10 (X)
+    - 9 = IX 由于 10 (X) 减 1 (I)
+注意：49 不是 50 (L) 减 1 (I) 因为转换是基于小数位
+
+示例 2:    
+
+- 输入：num = 58
+
+- 输出："LVIII"
+
+解释:   
+
+    - 50 = L
+    - 8 = VIII
+
+示例 3:    
+
+- 输入：num = 1994
+
+- 输出："MCMXCIV"
+
+- 解释:      
+
+    - 1000 = M
+    - 900 = CM
+    - 90 = XC
+    - 4 = IV
+ 
+
+提示:     
+
+- 1 <= num <= 3999
+
+### 思路
+
+题目中说了num <= 3999
+
+所以:    
+
+- 千位数只能由M表示，分别为 M，MM，MMM
+- 百位数只能由C、CC、CCC、CD、D、DC、DCC、DCCC、CM表示
+- 十位数只能由X、XX、XXX、XL、L、LX、LXX、LXXX、XC表示
+- 个位数只能由I、II、III、IV、V、VI、VII、VIII、IV表示
+
+
+所以可以利用模运算和除法运算，得到num每个位上的数字，然后去取对应的罗马数字就可以了。 
+
+```java
+
+class Solution {
+    String[] thousands = {"", "M", "MM", "MMM"};
+    String[] hundreds  = {"", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM"};
+    String[] tens      = {"", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC"};
+    String[] ones      = {"", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"};
+
+    public String intToRoman(int num) {
+        StringBuffer roman = new StringBuffer();
+        roman.append(thousands[num / 1000]);
+        roman.append(hundreds[num % 1000 / 100]);
+        roman.append(tens[num % 100 / 10]);
+        roman.append(ones[num % 10]);
+        return roman.toString();
+    }
+}
+```
+
+复杂度分析:     
+
+- 时间复杂度：O(1)。计算量与输入数字的大小无关。
+
+- 空间复杂度：O(1)。
+
+
+---
+-  邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/19.\346\234\200\345\220\216\344\270\200\344\270\252\345\215\225\350\257\215\347\232\204\351\225\277\345\272\246.md" "b/Algorithm/19.\346\234\200\345\220\216\344\270\200\344\270\252\345\215\225\350\257\215\347\232\204\351\225\277\345\272\246.md"
new file mode 100644
index 00000000..95e2c32f
--- /dev/null
+++ "b/Algorithm/19.\346\234\200\345\220\216\344\270\200\344\270\252\345\215\225\350\257\215\347\232\204\351\225\277\345\272\246.md"
@@ -0,0 +1,78 @@
+19.最后一个单词的长度
+===
+
+
+### 题目
+
+给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中 最后一个 单词的长度。
+
+单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。
+
+ 
+
+示例 1:    
+
+- 输入：s = "Hello World"
+- 输出：5
+- 解释：最后一个单词是“World”，长度为 5。
+
+示例 2:    
+
+- 输入：s = "   fly me   to   the moon  "
+- 输出：4
+- 解释：最后一个单词是“moon”，长度为 4。
+
+示例 3:     
+
+- 输入：s = "luffy is still joyboy"
+- 输出：6
+- 解释：最后一个单词是长度为 6 的“joyboy”。
+ 
+
+提示:    
+
+- 1 <= s.length <= 104
+- s 仅有英文字母和空格 ' ' 组成
+- s 中至少存在一个单词
+
+### 思路
+
+从最后一个字母开始往前遍历，并开始计数，找到第一个空格的时候停止。要注意没有空格的情况，例如"ab"，应该返回2。
+
+```java
+class Solution {
+    public int lengthOfLastWord(String s) {
+        int end = s.length() - 1;
+        while(end >= 0 && s.charAt(end) == ' ') end--;
+        if(end < 0) return 0;
+        int start = end;
+        while(start >= 0 && s.charAt(start) != ' ') start--;
+        return end - start;
+    }
+}
+```
+
+
+```python
+class Solution:
+    def lengthOfLastWord(self, s: str) -> int:
+        length = 0
+        for i in reversed(range(len(s.rstrip()))):
+            if s.rstrip()[i] == " ":
+                return length
+            else:
+                length += 1
+        return length    
+```
+
+复杂度分析:    
+
+- 时间复杂度：O(n)，其中 n 是字符串的长度。最多需要反向遍历字符串一次。
+
+- 空间复杂度：O(1)。
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/20.\346\234\200\351\225\277\345\205\254\345\205\261\345\211\215\347\274\200.md" "b/Algorithm/20.\346\234\200\351\225\277\345\205\254\345\205\261\345\211\215\347\274\200.md"
new file mode 100644
index 00000000..ce72e6a5
--- /dev/null
+++ "b/Algorithm/20.\346\234\200\351\225\277\345\205\254\345\205\261\345\211\215\347\274\200.md"
@@ -0,0 +1,68 @@
+20.最长公共前缀
+===
+
+
+### 题目
+
+编写一个函数来查找字符串数组中的最长公共前缀。
+
+如果不存在公共前缀，返回空字符串 ""。
+
+ 
+
+示例 1:    
+
+- 输入：strs = ["flower","flow","flight"]
+- 输出："fl"
+
+示例 2:     
+
+- 输入：strs = ["dog","racecar","car"]
+- 输出：""
+- 解释：输入不存在公共前缀。
+ 
+
+提示:    
+
+- 1 <= strs.length <= 200
+- 0 <= strs[i].length <= 200
+- strs[i] 如果非空，则仅由小写英文字母组成
+
+### 思路
+
+
+###### 遍历每次找重合的前缀部分
+
+横向扫描，依次遍历每个字符串，更新最长公共前缀
+
+```python
+class Solution:
+    def longestCommonPrefix(self, strs: List[str]) -> str:
+        ans = strs[0]
+        def compare(s1, s2) -> str:
+            result = ""
+            for i in range(min(len(s1), len(s2))):
+                if s1[i] == s2[i]:
+                    result += s1[i]
+                else:
+                    break
+            return result
+
+        for i in range(1, len(strs)):
+            ans = compare(ans, strs[i])
+        return ans
+```
+
+
+复杂度分析:     
+
+- 时间复杂度：O(mn)，其中 m 是字符串数组中的字符串的平均长度，n 是字符串的数量。最坏情况下，字符串数组中的每个字符串的每个字符都会被比较一次。
+
+- 空间复杂度：O(1)。使用的额外空间复杂度为常数。
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/21.\345\217\215\350\275\254\345\255\227\347\254\246\344\270\262\344\270\255\347\232\204\345\215\225\350\257\215.md" "b/Algorithm/21.\345\217\215\350\275\254\345\255\227\347\254\246\344\270\262\344\270\255\347\232\204\345\215\225\350\257\215.md"
new file mode 100644
index 00000000..1a5754c5
--- /dev/null
+++ "b/Algorithm/21.\345\217\215\350\275\254\345\255\227\347\254\246\344\270\262\344\270\255\347\232\204\345\215\225\350\257\215.md"
@@ -0,0 +1,84 @@
+21.反转字符串中的单词
+===
+
+
+### 题目
+
+
+给你一个字符串 s ，请你反转字符串中 单词 的顺序。
+
+单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。
+
+返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。
+
+注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。
+
+ 
+
+示例 1:    
+
+- 输入：s = "the sky is blue"
+- 输出："blue is sky the"
+
+示例 2:    
+
+- 输入：s = "  hello world  "
+- 输出："world hello"
+- 解释：反转后的字符串中不能存在前导空格和尾随空格。
+
+示例 3:     
+
+- 输入：s = "a good   example"
+- 输出："example good a"
+- 解释：如果两个单词间有多余的空格，反转后的字符串需要将单词间的空格减少到仅有一个。
+ 
+
+提示:    
+
+- 1 <= s.length <= 104
+- s 包含英文大小写字母、数字和空格 ' '
+- s 中 至少存在一个 单词
+
+
+### 思路
+
+- 倒序遍历，记录每个单词的起始和结束长度
+- 结果中累加每个单词，注意在加下一个单词的时候需要提前加上空格
+- 遍历到最后一个空格或者第一个元素截止
+- 注意如果是第一个元素截止的时候需要考虑第一个元素是不是空格" "，例如: " asdasd df f"
+    - 如果是空格，需要从i + 1开始
+    - 如果不是空格，需要从0开始
+
+```python
+class Solution:
+    def reverseWords(self, s: str) -> str:
+        length = len(s)
+        result = ""
+        last = -1
+
+        for i in reversed(range(length)):
+            if last == -1 and s[i] != " ":
+                last = i
+            if last > -1 and (s[i] == " " or i == 0):
+                if result != "":
+                    result += " "
+                if i == 0 and s[i] != " ":
+                    result += s[0: last + 1]
+                else:
+                    result += s[i + 1: last + 1]
+                last = -1
+
+        return result
+```        
+
+
+复杂度分析:     
+
+- 时间复杂度 O(N) ： 其中 N 为字符串 s 的长度，线性遍历字符串。
+- 空间复杂度 O(N) ： 新建的 list(Python) 或 StringBuilder(Java) 中的字符串总长度 ≤N ，占用 O(N) 大小的额外空间。
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/22.Z\345\255\227\345\275\242\350\275\254\346\215\242.md" "b/Algorithm/22.Z\345\255\227\345\275\242\350\275\254\346\215\242.md"
new file mode 100644
index 00000000..d4f3e661
--- /dev/null
+++ "b/Algorithm/22.Z\345\255\227\345\275\242\350\275\254\346\215\242.md"
@@ -0,0 +1,106 @@
+22.Z字形转换
+===
+
+
+### 题目
+
+将一个给定字符串 s 根据给定的行数 numRows ，以从上往下、从左到右进行 Z 字形排列。
+
+比如输入字符串为 "PAYPALISHIRING" 行数为 3 时，排列如下:     
+```
+P   A   H   N
+A P L S I I G
+Y   I   R
+```
+之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如："PAHNAPLSIIGYIR"。
+
+请你实现这个将字符串进行指定行数变换的函数：
+
+string convert(string s, int numRows);
+ 
+
+示例 1:     
+
+- 输入：s = "PAYPALISHIRING", numRows = 3
+- 输出："PAHNAPLSIIGYIR"
+
+示例 2:    
+- 输入：s = "PAYPALISHIRING", numRows = 4
+- 输出："PINALSIGYAHRPI"
+- 解释：
+```
+P     I    N
+A   L S  I G
+Y A   H R
+P     I
+```
+示例 3:    
+
+- 输入：s = "A", numRows = 1
+- 输出："A"
+ 
+
+提示:    
+
+- 1 <= s.length <= 1000
+- s 由英文字母（小写和大写）、',' 和 '.' 组成
+- 1 <= numRows <= 1000
+
+### 思路
+
+找规律，假设s = "PAYPALISHIRING", numRows = 3
+
+- 从前往后遍历s
+- s[0] : 第一行
+- s[1] : 第二行
+- s[2] : 第三行， 大于等于numRows了，行要开始递减了
+- s[3] : 第二行，
+- s[4] : 第一行， 到最小行了，行要开始递加了
+- s[5] : 第二行
+- ...
+
+
+```python
+
+class Solution:
+    def convert(self, s: str, numRows: int) -> str:
+        if len(s) < 3 or numRows < 2:
+            return s
+        row = 1
+        add = True
+        # 用一个数组记录每一行的字符内容
+        rowArray = [""] * numRows
+        for i in s:
+            rowArray[row - 1] += i
+
+            if add:
+                row += 1
+            else:
+                row -= 1
+            if row > numRows:
+                add = False
+                # 本来要减1因为上面刚加了1，所以这里要减2
+                row -= 2
+            elif row < 1:
+                add = True
+                row += 2
+
+        result = ""
+        for i in rowArray:
+            result += i
+        return result
+```
+
+
+
+
+复杂度分析:   
+
+- 时间复杂度 O(N) ：遍历一遍字符串 s；
+- 空间复杂度 O(N) ：各行字符串共占用 O(N) 额外空间。
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/23.\346\211\276\345\207\272\345\255\227\347\254\246\344\270\262\344\270\255\347\254\254\344\270\200\344\270\252\345\214\271\351\205\215\351\241\271\347\232\204\344\270\213\346\240\207.md" "b/Algorithm/23.\346\211\276\345\207\272\345\255\227\347\254\246\344\270\262\344\270\255\347\254\254\344\270\200\344\270\252\345\214\271\351\205\215\351\241\271\347\232\204\344\270\213\346\240\207.md"
new file mode 100644
index 00000000..b3f118f9
--- /dev/null
+++ "b/Algorithm/23.\346\211\276\345\207\272\345\255\227\347\254\246\344\270\262\344\270\255\347\254\254\344\270\200\344\270\252\345\214\271\351\205\215\351\241\271\347\232\204\344\270\213\346\240\207.md"
@@ -0,0 +1,324 @@
+23.找出字符串中第一个匹配项的下标
+===
+
+
+### 题目
+
+给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回  -1 。
+
+ 
+
+示例 1:    
+
+- 输入：haystack = "sadbutsad", needle = "sad"
+- 输出：0
+- 解释："sad" 在下标 0 和 6 处匹配。
+- 第一个匹配项的下标是 0 ，所以返回 0 。
+
+示例 2:   
+
+- 输入：haystack = "leetcode", needle = "leeto"
+- 输出：-1
+- 解释："leeto" 没有在 "leetcode" 中出现，所以返回 -1 。
+ 
+
+提示:    
+
+- 1 <= haystack.length, needle.length <= 104
+- haystack 和 needle 仅由小写英文字符组成
+
+### 思路
+
+##### 方法一： 普通对比
+
+```python
+
+class Solution:
+    def strStr(self, haystack: str, needle: str) -> int:
+        length = len(needle)
+        for i in range(len(haystack)):
+            if haystack[i] == needle[0]:
+                if haystack[i: i+length] == needle:
+                    return i
+        return -1    
+```
+
+
+复杂度分析
+
+- 时间复杂度：O(n×m)，其中 n 是字符串 haystack 的长度，m 是字符串 needle 的长度。最坏情况下我们需要将字符串 needle 与字符串 haystack 的所有长度为 m 的子串均匹配一次。
+
+- 空间复杂度：O(1)。我们只需要常数的空间保存若干变量。
+
+
+##### 方法二： KMP
+
+
+
+上述的朴素解法，不考虑剪枝的话复杂度是 O(m∗n) 的，而 KMP 算法的复杂度为 O(m+n)。
+
+KMP算法是一种字符串匹配算法，可以在 O(n+m) 的时间复杂度内实现两个字符串的匹配。
+
+KMP 之所以能够在 O(m+n) 复杂度内完成查找，是因为其能在「非完全匹配」的过程中提取到有效信息进行复用，以减少「重复匹配」的消耗。
+
+
+KMP算法的核心，是一个被称为部分匹配表(Partial Match Table)的数组。
+
+###### 算法原理
+
+从主字符串的第一个字符开始：KMP算法从主字符串的第一个字符开始，将其与子字符串的第一个字符进行比较。 相等与不等的情况：如果字符相等，则继续比较后续字符；如果不等，则根据部分匹配表（即next数组）的值，将子字符串向右移动若干个字符，然后再次进行比较。
+
+
+###### 算法效率
+
+- 时间复杂度：KMP算法的时间复杂度为O(m+n)，其中m和n分别是模式串和主串的长度。相较于O(n^2)的暴力匹配算法，KMP算法具有较高的效率。
+
+
+
+###### KMP算法的本质
+
+理解计算next数组是核心。
+
+
+next数组是匹配串的一个查找表，它的定义可以用下面一句话来解释。就是kmp算法的本质：
+
+***next数组的每个元素表示匹配串中从起始到以当前字符结尾的子串中以当前字符结尾的连续重复最长串长度。***
+
+字符串abcdabe,len是每个子串以最后一个字符结尾的连续重复最长串长度:     
+
+- next[0] = 0 // 子串'a'中没有包含以'a'结尾的连续重复子串，len = 0
+- next[1] = 0 // 子串'ab'中没有包含以'b'结尾的连续重复子串，len = 0
+- next[2] = 0 // 子串'abc'中没有包含以'c'结尾的连续重复子串，len = 0
+- next[3] = 0 // 子串'abcd'中没有包含以'd'结尾的连续重复子串，len = 0
+- next[4] = 1 // 子串'abcda'中包含以'a'结尾的连续重复子串是'a'，len = 1
+- next[5] = 2 // 子串'abcdab'中包含以'b'结尾的连续重复子串'ab'，len = 2
+- next[6] = 0 // 子串'abcdabe'中没有包含以'e'结尾的连续重复子串，len = 0 
+
+匹配过程与计算next的思路相似，如果当前字符不匹配，就往回跳，跳多少呢，就是前面已比较串的以最后一个字符结尾的连续最长重复长度，最长也就一半，不用跳到开头，即next[j-1]的长度，不用再重头比较，
+
+
+
+
+
+所谓字符串匹配，是这样一种问题： 字符串P是否为字符串S的子串？如果是，它出现在S的哪个位置。
+
+- S称为主串。    
+- P称为模式串。  
+
+
+最简单的方法就是上面的方法一，不断的去遍历查找。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/Brute-Force.png?raw=true)
+
+
+这就是Brute-Force 算法。现在，我们需要对它的时间复杂度做一点讨论，它的时间复杂度是O(n×m)。 
+
+我们很难降低字符串比较的复杂度（因为比较两个字符串，真的只能逐个比较字符）。        
+
+因此，我们考虑降低比较的趟数。如果比较的趟数能降到足够低，那么总的复杂度也将会下降很多。    
+
+
+要优化一个算法，首先要回答的问题是“我手上有什么信息？”　我们手上的信息是否足够、是否有效，决定了我们能把算法优化到何种程度。请记住：尽可能利用残余的信息，是KMP算法的思想所在。
+
+
+在Brute-Force中，如果从S[i]开始的那一趟比较失败了，算法会直接开始尝试从S[i+1]开始比较。
+
+这种行为，属于典型的“没有从之前的错误中学到东西”。     
+
+我们应当注意到，一次失败的匹配，会给我们提供宝贵的信息：    
+
+- 如果 S[i : i+len(P)] 与 P 的匹配是在第 r 个位置失败的，那么从 S[i] 开始的 (r-1) 个连续字符，一定与 P 的前 (r-1) 个字符一模一样！
+- 为什么呢？ 因为不然得话你在r之前就失败了。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/Brute-Force_2.png?raw=true)
+
+
+需要实现的任务是“字符串匹配”，而每一次失败都会给我们换来一些信息——能告诉我们，主串的某一个子串等于模式串的某一个前缀。但是这又有什么用呢？
+
+有些趟字符串比较是有可能会成功的；有些则毫无可能。      
+
+我们刚刚提到过，优化 Brute-Force的路线是“尽量减少比较的趟数”，而如果我们跳过那些绝不可能成功的字符串比较，则可以希望复杂度降低到能接受的范围。　　       
+
+那么，哪些字符串比较是不可能成功的？来看一个例子。已知信息如下：
+
+- 模式串 P = "abcabd".
+- 和主串从S[0]开始匹配时，在 P[5] 处失配。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/Brute-Force_3.png?raw=true)
+
+- 既然是在 P[5] 失配的，那么说明 S[0:5] 等于 P[0:5]，即"abcab".       
+
+- 现在我们来考虑：从 S[1]、S[2]、S[3] 开始的匹配尝试，有没有可能成功？　　    
+
+- 从 S[1] 开始肯定没办法成功，因为 S[1] = P[1] = 'b'，和 P[0] 并不相等。       
+
+- 从 S[2] 开始也是没戏的，因为 S[2] = P[2] = 'c'，并不等于P[0].       
+
+- 但是从 S[3] 开始是有可能成功的——至少按照已知的信息，我们推不出矛盾。
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/Brute-Force_4.png?raw=true)
+
+
+也就是说当主串的某个字符c发生不匹配时，如果主串回退，最终还是会重新匹配到字符c上。     
+那干脆不回退，岂不美哉！   
+也就是说主串一直遍历不回退。
+主串不回退，那模式串必须回退尽可能少，并且模式串回退位置的前面那段已经和主串匹配，这样主串才能不用回退。
+
+如何找到模式串回退的位置呢？
+
+在不匹配发生时，前面匹配的那一小段字符对于主串和模式串都是相同的(如果不相同，在这之前会就匹配失败了)。     
+那既然这一小段是主串和模式串相同的。那我就用这个串的头部去匹配这个串的尾部，最长的那段就是答案，也就是模式串改回退到的位置。   
+
+
+***带着“跳过不可能成功的尝试”的思想，我们来看next数组。***
+
+那就假设模式串在其所有位置上都发生了不匹配，模式串在和主串匹配前把其所有位置的最长匹配都算出来（算个长度就行），生成一张表，之后我俩发生不匹配时直接查这张表就行。这就是next数组。  
+
+###### next数组
+
+next数组是对于***模式串***而言的。
+
+P 的 next 数组定义为：next[i] 表示 P[0] ~ P[i] 这一个子串，使得***前k个字符恰等于后k个字符的最大的k***. 特别地，k不能取i+1（因为这个子串一共才 i+1 个字符，自己肯定与自己相等，就没有意义了）。
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/Brute-Force_5.png?raw=true)
+
+上图给出了一个例子。P="abcabd"时，next[4]=2，这是因为P[0] ~ P[4] 这个子串是"abcab"，前两个字符与后两个字符相等，因此next[4]取2. 
+
+而next[5]=0，是因为"abcabd"找不到前缀与后缀相同，因此只能取0.
+
+如果把模式串视为一把标尺，在主串上移动，那么 Brute-Force 就是每次失配之后只右移一位；改进算法则是每次失配之后，移很多位，跳过那些不可能匹配成功的位置。但是该如何确定要移多少位呢？
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/Brute-Force_6.png?raw=true)
+
+
+- 在 S[0] 尝试匹配，失配于 S[3] != P[3] 之后，我们直接把模式串往右移了两位，让 S[3] 对准 P[1].      
+
+- 接着继续匹配，失配于 S[8] != P[6], 接下来我们把 P 往右平移了三位，把 S[8] 对准 P[3].         
+
+- 此后继续匹配直到成功。　　
+
+
+我们应该如何移动这把标尺？很明显，如图中蓝色箭头所示，旧的后缀要与新的前缀一致（如果不一致，那就肯定没法匹配上了）！　　     
+
+
+---  
+回忆next数组的性质：P[0] 到 P[i] 这一段子串中，前next[i]个字符与后next[i]个字符一模一样。       
+
+既然如此，如果失配在`P[r]`, 那么`P[0]~P[r-1]`这一段里面，前`next[r-1]`个字符恰好和后`next[r-1]`个字符相等——也就是说，我们可以拿长度为`next[r-1]`的那一段前缀，来顶替当前后缀的位置，让匹配继续下去。          
+
+
+您可以验证一下上面的匹配例子：P[3]失配后，把P[next[3-1]]也就是P[1]对准了主串刚刚失配的那一位；P[6]失配后，把P[next[6-1]]也就是P[3]对准了主串刚刚失配的那一位。
+
+--- 
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/Brute-Force_7.png?raw=true)
+
+
+
+如上图所示，绿色部分是成功匹配，失配于红色部分。深绿色手绘线条标出了相等的前缀和后缀，其长度为next[右端]. 由于手绘线条部分的字符是一样的，所以直接把前面那条移到后面那条的位置。因此说，next数组为我们如何移动标尺提供了依据。接下来，我们实现这个优化的算法。
+
+了解了利用next数组加速字符串匹配的原理，我们接下来代码实现之。分为两个部分:     
+
+- 建立next数组
+
+- 利用next数组进行匹配。
+
+
+首先是建立next数组。我们暂且用最朴素的做法，以后再回来优化：
+
+```python
+
+def getNxt(x):
+	for i in range(x, 0, -1):
+		if p[0: 1] == p[x-i+1:x+1]:
+			return i
+	return 0
+
+nxt = [getNxt(x) for x in range(len(p))]			
+```
+
+如上图代码所示，直接根据next数组的定义来建立next数组。不难发现它的复杂度是  的。
+　　接下来，实现利用next数组加速字符串匹配。代码如下：
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/Brute-Force_8.png?raw=true)
+
+
+
+###### 快速求next数组
+
+
+终于来到了我们最后一个问题——如何快速构建next数组。　　   
+
+- 首先说一句：快速构建next数组，是KMP算法的精髓所在，核心思想是“P自己与自己做匹配”。　    
+
+为什么这样说呢？回顾next数组的完整定义:    
+
+- 定义 “k-前缀” 为一个字符串的前 k 个字符； “k-后缀” 为一个字符串的后 k 个字符。k 必须小于字符串长度。     
+
+- next[x]定义为:`P[0]~P[x]`这一段字符串，使得k-前缀恰等于k-后缀的最大的k.　　   
+
+这个定义中，不知不觉地就包含了一个匹配——前缀和后缀相等。      
+
+接下来，我们考虑采用递推的方式求出next数组。如果next[0], next[1], ... next[x-1]均已知，那么如何求出 next[x] 呢？　　     
+
+来分情况讨论。首先，已经知道了 next[x-1]（以下记为now），如果 P[x] 与 P[now] 一样，那最长相等前后缀的长度就可以扩展一位，很明显 next[x] = now + 1. 图示如下。
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/Brute-Force_9.png?raw=true)
+
+刚刚解决了 P[x] = P[now] 的情况。那如果 P[x] 与 P[now] 不一样，又该怎么办？
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/Brute-Force_10.png?raw=true)
+
+如图。
+
+长度为now的子串A和子串B是`P[0]~P[x-1]`中最长的公共前后缀。        
+
+可惜 A 右边的字符和 B 右边的那个字符不相等，next[x]不能改成now+1了。     
+
+因此，我们应该缩短这个now，把它改成小一点的值，再来试试 P[x] 是否等于 P[now].　　         
+
+now该缩小到多少呢？显然，我们不想让now缩小太多。因此我们决定，在保持`P[0]~P[x-1]`的now-前缀仍然等于now-后缀”的前提下，让这个新的now尽可能大一点。       
+
+
+`P[0]~P[x-1]`的公共前后缀，前缀一定落在串A里面、后缀一定落在串B里面。       
+
+换句话讲：接下来now应该改成：使得 A的k-前缀等于B的k-后缀 的最大的k.　　 
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/Brute-Force_14.png?raw=true)
+
+也就是说：假设这个时候最大的前缀和后缀是字符串X，那将这个前缀和后缀去掉一个字符（去掉c）后，得到的两个新的串也必然是相等的。   
+也就是只可能是现有最大串的子串。也就是a的前缀和b的后缀(而这个时候a和b是一样的，所以就变成找A中的前缀和后缀一样的子串)。   
+
+您应该已经注意到了一个非常强的性质——串A和串B是相同的！B的后缀等于A的后缀！因此，使得A的k-前缀等于B的k-后缀的最大的k，其实就是串A的最长公共前后缀的长度 —— next[now-1]！
+
+简单说就是： 次大匹配必定在最大匹配中
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/Brute-Force_11.png?raw=true)
+
+
+来看上面的例子。当P[now]与P[x]不相等的时候，我们需要缩小now——把now变成next[now-1]，直到P[now]=P[x]为止。P[now]=P[x]时，就可以直接向右扩展了。
+
+
+代码实现如下：
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/Brute-Force_12.png?raw=true)
+
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/Brute-Force_13.png?raw=true)
+
+
+
+https://www.zhihu.com/question/21923021/answer/281346746
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/24.\346\226\207\346\234\254\345\267\246\345\217\263\345\257\271\351\275\220.md" "b/Algorithm/24.\346\226\207\346\234\254\345\267\246\345\217\263\345\257\271\351\275\220.md"
new file mode 100644
index 00000000..322b9ff6
--- /dev/null
+++ "b/Algorithm/24.\346\226\207\346\234\254\345\267\246\345\217\263\345\257\271\351\275\220.md"
@@ -0,0 +1,80 @@
+24.文本左右对齐
+===
+
+
+### 题目
+
+给定一个单词数组 words 和一个长度 maxWidth ，重新排版单词，使其成为每行恰好有 maxWidth 个字符，且左右两端对齐的文本。
+
+你应该使用 “贪心算法” 来放置给定的单词；也就是说，尽可能多地往每行中放置单词。必要时可用空格 ' ' 填充，使得每行恰好有 maxWidth 个字符。
+
+要求尽可能均匀分配单词间的空格数量。如果某一行单词间的空格不能均匀分配，则左侧放置的空格数要多于右侧的空格数。
+
+文本的最后一行应为左对齐，且单词之间不插入额外的空格。
+
+注意:     
+
+- 单词是指由非空格字符组成的字符序列。
+- 每个单词的长度大于 0，小于等于 maxWidth。
+- 输入单词数组 words 至少包含一个单词。
+ 
+
+示例 1:   
+
+- 输入: words = ["This", "is", "an", "example", "of", "text", "justification."], maxWidth = 16
+- 输出:
+```
+[
+   "This    is    an",
+   "example  of text",
+   "justification.  "
+]
+```
+示例 2:    
+
+- 输入:words = ["What","must","be","acknowledgment","shall","be"], maxWidth = 16
+- 输出:   
+```
+[
+  "What   must   be",
+  "acknowledgment  ",
+  "shall be        "
+]
+```
+- 解释:     
+    - 注意最后一行的格式应为 "shall be    " 而不是 "shall     be",
+    - 因为最后一行应为左对齐，而不是左右两端对齐。       
+    - 第二行同样为左对齐，这是因为这行只包含一个单词。
+
+示例 3:     
+
+- 输入:words = ["Science","is","what","we","understand","well","enough","to","explain","to","a","computer.","Art","is","everything","else","we","do"]，maxWidth = 20
+- 输出:      
+```
+[
+  "Science  is  what we",
+  "understand      well",
+  "enough to explain to",
+  "a  computer.  Art is",
+  "everything  else  we",
+  "do                  "
+]
+```
+
+提示:      
+
+- 1 <= words.length <= 300
+- 1 <= words[i].length <= 20
+- words[i] 由小写英文字母和符号组成
+- 1 <= maxWidth <= 100
+- words[i].length <= maxWidth
+
+### 思路
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/25.\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262.md" "b/Algorithm/25.\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262.md"
new file mode 100644
index 00000000..29134c67
--- /dev/null
+++ "b/Algorithm/25.\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262.md"
@@ -0,0 +1,48 @@
+25.验证回文串
+===
+
+
+### 题目
+
+如果在将所有大写字符转换为小写字符、并移除所有非字母数字字符之后，短语正着读和反着读都一样。则可以认为该短语是一个 回文串 。
+
+字母和数字都属于字母数字字符。
+
+给你一个字符串 s，如果它是 回文串 ，返回 true ；否则，返回 false 。
+
+ 
+
+示例 1:    
+
+- 输入: s = "A man, a plan, a canal: Panama"
+- 输出：true
+- 解释："amanaplanacanalpanama" 是回文串。
+
+示例 2:   
+
+- 输入：s = "race a car"
+- 输出：false
+- 解释："raceacar" 不是回文串。
+示例 3:    
+
+- 输入：s = " "
+- 输出：true
+- 解释：在移除非字母数字字符之后，s 是一个空字符串 "" 。
+- 由于空字符串正着反着读都一样，所以是回文串。
+ 
+
+提示:   
+
+- 1 <= s.length <= 2 * 105
+- s 仅由可打印的 ASCII 字符组成
+
+
+### 思路
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git a/Algorithm/26..md b/Algorithm/26..md
new file mode 100644
index 00000000..0970b4ab
--- /dev/null
+++ b/Algorithm/26..md
@@ -0,0 +1,17 @@
+18.整数转罗马数字
+===
+
+
+### 题目
+
+
+
+### 思路
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git a/Algorithm/27..md b/Algorithm/27..md
new file mode 100644
index 00000000..0970b4ab
--- /dev/null
+++ b/Algorithm/27..md
@@ -0,0 +1,17 @@
+18.整数转罗马数字
+===
+
+
+### 题目
+
+
+
+### 思路
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	

From 540c62788838176d8acb2e9080b16f1a5dcf74a8 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 18 Jun 2025 15:20:59 +0800
Subject: [PATCH 207/213] add notes

---
 ...46\345\217\263\345\257\271\351\275\220.md" |  80 +++++++++++
 ...01\345\233\236\346\226\207\344\270\262.md" |  56 ++++++++
 ...55\345\255\220\345\272\217\345\210\227.md" | 129 ++++++++++++++++++
 ...11\345\272\217\346\225\260\347\273\204.md" |  97 +++++++++++++
 ...64\347\232\204\345\256\271\345\231\250.md" |  73 ++++++++++
 ...11\346\225\260\344\271\213\345\222\214.md" | 109 +++++++++++++++
 ...04\345\255\220\346\225\260\347\273\204.md" | 102 ++++++++++++++
 ...00\351\225\277\345\255\220\344\270\262.md" | 107 +++++++++++++++
 ...15\347\232\204\345\255\220\344\270\262.md" |  59 ++++++++
 Algorithm/{26..md => 33..md}                  |   0
 Algorithm/{27..md => 34..md}                  |   0
 Algorithm/35..md                              |  17 +++
 12 files changed, 829 insertions(+)
 create mode 100644 "Algorithm/26.\345\210\244\346\226\255\345\255\220\345\272\217\345\210\227.md"
 create mode 100644 "Algorithm/27.\344\270\244\346\225\260\344\271\213\345\222\214 II - \350\276\223\345\205\245\346\234\211\345\272\217\346\225\260\347\273\204.md"
 create mode 100644 "Algorithm/28.\347\233\233\346\234\200\345\244\232\346\260\264\347\232\204\345\256\271\345\231\250.md"
 create mode 100644 "Algorithm/29.\344\270\211\346\225\260\344\271\213\345\222\214.md"
 create mode 100644 "Algorithm/30.\351\225\277\345\272\246\346\234\200\345\260\217\347\232\204\345\255\220\346\225\260\347\273\204.md"
 create mode 100644 "Algorithm/31.\346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262.md"
 create mode 100644 "Algorithm/32.\344\270\262\350\201\224\346\211\200\346\234\211\345\215\225\350\257\215\347\232\204\345\255\220\344\270\262.md"
 rename Algorithm/{26..md => 33..md} (100%)
 rename Algorithm/{27..md => 34..md} (100%)
 create mode 100644 Algorithm/35..md

diff --git "a/Algorithm/24.\346\226\207\346\234\254\345\267\246\345\217\263\345\257\271\351\275\220.md" "b/Algorithm/24.\346\226\207\346\234\254\345\267\246\345\217\263\345\257\271\351\275\220.md"
index 322b9ff6..ffde6522 100644
--- "a/Algorithm/24.\346\226\207\346\234\254\345\267\246\345\217\263\345\257\271\351\275\220.md"
+++ "b/Algorithm/24.\346\226\207\346\234\254\345\267\246\345\217\263\345\257\271\351\275\220.md"
@@ -71,6 +71,86 @@
 
 ### 思路
 
+字符串大模拟，分情况讨论即可：
+
+- 如果当前行只有一个单词，特殊处理为左对齐；
+- 如果当前行为最后一行，特殊处理为左对齐；
+- 其余为一般情况，分别计算「当前行单词总长度」、「当前行空格总长度」和「往下取整后的单位空格长度」，然后依次进行拼接。当空格无法均分时，每次往靠左的间隙多添加一个空格，直到剩余的空格能够被后面的间隙所均分。
+
+```java
+
+class Solution {
+    public List<String> fullJustify(String[] words, int maxWidth) {
+        List<String> ans = new ArrayList<>();
+        int n = words.length;
+        List<String> list = new ArrayList<>();
+        for (int i = 0; i < n; ) {
+            // list 装载当前行的所有 word
+            list.clear();
+            list.add(words[i]);
+            int cur = words[i++].length();
+            while (i < n && cur + 1 + words[i].length() <= maxWidth) {
+                cur += 1 + words[i].length();
+                list.add(words[i++]);
+            }
+
+            // 当前行为最后一行，特殊处理为左对齐
+            if (i == n) {
+                StringBuilder sb = new StringBuilder(list.get(0));
+                for (int k = 1; k < list.size(); k++) {
+                    sb.append(" ").append(list.get(k));
+                }
+                while (sb.length() < maxWidth) sb.append(" ");
+                ans.add(sb.toString());
+                break;
+            }
+
+            // 如果当前行只有一个 word，特殊处理为左对齐
+            int cnt = list.size();
+            if (cnt == 1) {
+                String str = list.get(0);
+                while (str.length() != maxWidth) str += " ";
+                ans.add(str);
+                continue;
+            }
+
+            /**
+            * 其余为一般情况
+            * wordWidth : 当前行单词总长度;
+            * spaceWidth : 当前行空格总长度;
+            * spaceItem : 往下取整后的单位空格长度
+            */
+            int wordWidth = cur - (cnt - 1);
+            int spaceWidth = maxWidth - wordWidth;
+            int spaceItemWidth = spaceWidth / (cnt - 1);
+            String spaceItem = "";
+            for (int k = 0; k < spaceItemWidth; k++) spaceItem += " ";
+            StringBuilder sb = new StringBuilder();
+            for (int k = 0, sum = 0; k < cnt; k++) {
+                String item = list.get(k);
+                sb.append(item);
+                if (k == cnt - 1) break;
+                sb.append(spaceItem);
+                sum += spaceItemWidth;
+                // 剩余的间隙数量（可填入空格的次数）
+                int remain = cnt - k - 1 - 1;
+                // 剩余间隙数量 * 最小单位空格长度 + 当前空格长度 < 单词总长度，则在当前间隙多补充一个空格
+                if (remain * spaceItemWidth + sum < spaceWidth) {
+                    sb.append(" ");
+                    sum++;
+                }
+            }
+            ans.add(sb.toString());
+        }
+        return ans;
+    }
+}
+```
+
+复杂度分析:     
+
+- 时间复杂度：会对 words 做线性扫描，最坏情况下每个 words[i] 独占一行，此时所有字符串的长度为 n∗maxWidth。复杂度为 O(n∗maxWidth)
+- 空间复杂度：最坏情况下每个 words[i] 独占一行，复杂度为 O(n∗maxWidth)
 
 
 ---
diff --git "a/Algorithm/25.\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262.md" "b/Algorithm/25.\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262.md"
index 29134c67..b8720d78 100644
--- "a/Algorithm/25.\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262.md"
+++ "b/Algorithm/25.\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262.md"
@@ -39,7 +39,63 @@
 
 ### 思路
 
+##### 方法一
 
+最简单的方法是对字符串 s 进行一次遍历，并将其中的字母和数字字符进行保留，放在另一个字符串 sgood 中。这样我们只需要判断 sgood 是否是一个普通的回文串即可。
+
+判断的方法有两种:     
+
+- 第一种是使用语言中的字符串翻转 API 得到 sgood 的逆序字符串 sgood_rev，只要这两个字符串相同，那么 sgood 就是回文串。
+- 第二种是使用双指针。初始时，左右指针分别指向 sgood 的两侧，随后我们不断地将这两个指针相向移动，每次移动一步，并判断这两个指针指向的字符是否相同。当这两个指针相遇时，就说明 sgood 时回文串。
+
+```java
+class Solution {
+    public boolean isPalindrome(String s) {
+        StringBuffer sgood = new StringBuffer();
+        int length = s.length();
+        for (int i = 0; i < length; i++) {
+            char ch = s.charAt(i);
+            if (Character.isLetterOrDigit(ch)) {
+                sgood.append(Character.toLowerCase(ch));
+            }
+        }
+        int n = sgood.length();
+        int left = 0, right = n - 1;
+        while (left < right) {
+            if (Character.toLowerCase(sgood.charAt(left)) != Character.toLowerCase(sgood.charAt(right))) {
+                return false;
+            }
+            ++left;
+            --right;
+        }
+        return true;
+    }
+}
+```
+
+复杂度分析:     
+
+- 时间复杂度：O(n)，其中n是字符串s的长度。
+
+- 空间复杂度：O(n)。由于我们需要将所有的字母和数字字符存放在另一个字符串中，在最坏情况下，新的字符串sgood与原字符串s完全相同，因此需要使用 O(n) 的空间。
+
+
+##### 方法二：在原字符串上直接判断
+
+我们可以对方法一中第二种判断回文串的方法进行优化，就可以得到只使用 O(1) 空间的算法。
+
+我们直接在原字符串 s 上使用双指针。在移动任意一个指针时，需要不断地向另一指针的方向移动，直到遇到一个字母或数字字符，或者两指针重合为止。
+
+也就是说，我们每次将指针移到下一个字母字符或数字字符，再判断这两个指针指向的字符是否相同。
+
+
+
+
+复杂度分析：   
+
+- 时间复杂度：O(n)，其中n是字符串s的长度。
+
+- 空间复杂度：O(1)。
 
 ---
 - 邮箱 ：charon.chui@gmail.com  
diff --git "a/Algorithm/26.\345\210\244\346\226\255\345\255\220\345\272\217\345\210\227.md" "b/Algorithm/26.\345\210\244\346\226\255\345\255\220\345\272\217\345\210\227.md"
new file mode 100644
index 00000000..77ea7063
--- /dev/null
+++ "b/Algorithm/26.\345\210\244\346\226\255\345\255\220\345\272\217\345\210\227.md"
@@ -0,0 +1,129 @@
+26.判断子序列
+===
+
+
+### 题目
+
+给定字符串 s 和 t ，判断 s 是否为 t 的子序列。
+
+字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。
+
+进阶：
+
+如果有大量输入的 S，称作 S1, S2, ... , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？
+ 
+
+示例 1:   
+
+- 输入：s = "abc", t = "ahbgdc"
+- 输出：true
+
+示例 2:   
+
+- 输入：s = "axc", t = "ahbgdc"
+- 输出：false
+ 
+
+提示:    
+
+- 0 <= s.length <= 100
+- 0 <= t.length <= 10^4
+- 两个字符串都只由小写字符组成。
+
+### 思路
+
+
+首先，如果 s 是空串，直接返回 true，因为空串是任何字符串的子序列。  
+设置双指针 i , j 分别指向字符串 s , t 的首个字符，遍历字符串 t:    
+
+- 当 s[i] == t[j] 时，代表匹配成功，此时同时 i++ , j++ ；
+    - 进而，若 i 已走过 s 尾部，代表 s 是 t 的子序列，此时应提前返回 true ；
+- 当 s[i] != t[j] 时，代表匹配失败，此时仅 j++ ；
+
+若遍历完字符串 t 后，字符串 s 仍未遍历完，代表 s 不是 t 的子序列，此时返回 false 。
+
+```java
+
+class Solution {
+    public boolean isSubsequence(String s, String t) {
+        int i = 0, j = 0;
+        while (i < s.length() && j < t.length()) {
+            if (s.charAt(i) == t.charAt(j)) {
+                i++;
+            }
+            j++;
+        }
+        return i == s.length();
+    }
+}
+```
+
+复杂度分析:   
+
+- 时间复杂度 O(N) ： 其中 N 为字符串 t 的长度。最差情况下需完整遍历 t 。
+- 空间复杂度 O(1) ： i , j 变量使用常数大小空间。
+
+
+##### 进阶问题解法
+
+如果有大量输入的 S，称作 S1, S2, ... , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？
+
+
+这种类似对同一个长字符串做很多次匹配的 ，可以像 KMP 算法一样，先用一些时间将长字符串中的数据 提取出来，磨刀不误砍柴功。有了提取好的数据，就可以快速的进行匹配。
+
+因为S非常多，所以可以通过一次性对T进行简化处理，这样来减少后续每一次S匹配T的遍历时间:     
+
+- 这里需要的数据就是匹配到某一点时,待匹配的字符在长字符串中 下一次 出现的位置。
+
+- 所以我们前期多做一点工作，将长字符串研究透彻，假如长字符串的长度为 n，建立一个 n∗26 大小的矩阵，表示每个位置上26个字符下一次出现的位置。实现如下：
+
+- 对于要匹配的短字符串，遍历每一个字符，不断地寻找该字符在长字符串中的位置，然后将位置更新，寻找下一个字符，相当于在长字符串上“跳跃”。
+
+- 如果下一个位置为 -1，表示长字符串再没有该字符了，返回 false 即可。
+
+- 如果能正常遍历完毕，则表示可行，返回 true
+
+- 需要注意的一点
+
+    - 对于 "abc" 在 "ahbgdc" 上匹配的时候，由于长字符串第一个 a 的下一个出现 a 的位置为 -1（不出现），会导致一个 bug。
+
+    - 所以在生成数组时在长字符串前插入一个空字符即可。
+
+```java
+
+//进阶问题的解决 
+public boolean isSubsequence(String s, String t) {
+
+    //考虑到  对第一个字符的处理 ，在t 之前一个空字符
+    t=' '+t;
+
+    //对t长字符串 做预处理
+    int[][] dp = new int[t.length()][26];//存储每一个位置上  a--z的下一个字符出现的位置
+    for (char c = 'a'; c <= 'z'; c++) {//依次对每个字符作处理
+        int nextPos = -1;//表示接下来不会在出现该字符
+
+        for (int i = t.length() - 1; i >= 0; i--) {//从最后一位开始处理
+            dp[i][c - 'a'] = nextPos;//dp[i][c-'a']  加上外层循环  就是对每一个位置的a---z字符的处理了
+            if (t.charAt(i) == c) {//表示当前位置有该字符  那么指向下一个该字符出现的位置就要被更新  为i
+                nextPos = i;
+            }
+        }
+    }
+
+    //数据的利用 ，开始匹配
+    int index=0;
+    for (char c:s.toCharArray()){
+        index=dp[index][c-'a'];//因为加了' '，所以之后在处理第一个字符的时候  如果是在第一行，就会去第一行，不影响之后字符的判断
+        if(index==-1){
+            return false;
+        }
+    }
+    return true;
+}
+```
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/27.\344\270\244\346\225\260\344\271\213\345\222\214 II - \350\276\223\345\205\245\346\234\211\345\272\217\346\225\260\347\273\204.md" "b/Algorithm/27.\344\270\244\346\225\260\344\271\213\345\222\214 II - \350\276\223\345\205\245\346\234\211\345\272\217\346\225\260\347\273\204.md"
new file mode 100644
index 00000000..b879cd8b
--- /dev/null
+++ "b/Algorithm/27.\344\270\244\346\225\260\344\271\213\345\222\214 II - \350\276\223\345\205\245\346\234\211\345\272\217\346\225\260\347\273\204.md"	
@@ -0,0 +1,97 @@
+27.两数之和 II - 输入有序数组
+===
+
+
+### 题目
+
+给你一个下标从1开始的整数数组numbers，该数组已按非递减顺序排列，请你从数组中找出满足相加之和等于目标数target的两个数。     
+
+如果设这两个数分别是numbers[index1]和numbers[index2]，则`1 <= index1 < index2 <= numbers.length`。     
+
+以长度为`2`的整数数组`[index1, index2]`的形式返回这两个整数的下标`index1`和`index2`。      
+
+你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。     
+
+你所设计的解决方案必须只使用常量级的额外空间。     
+
+ 
+示例 1:    
+
+- 输入：numbers = [2,7,11,15], target = 9
+- 输出：[1,2]
+- 解释：2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 。
+
+示例 2:    
+
+- 输入：numbers = [2,3,4], target = 6
+- 输出：[1,3]
+- 解释：2 与 4 之和等于目标数 6 。因此 index1 = 1, index2 = 3 。返回 [1, 3] 。
+
+示例 3:   
+
+- 输入：numbers = [-1,0], target = -1
+- 输出：[1,2]
+- 解释：-1 与 0 之和等于目标数 -1 。因此 index1 = 1, index2 = 2 。返回 [1, 2] 。
+ 
+
+提示:    
+
+- 2 <= numbers.length <= 3 * 104
+- -1000 <= numbers[i] <= 1000
+- numbers 按 非递减顺序 排列
+- -1000 <= target <= 1000
+- 仅存在一个有效答案
+
+### 思路
+
+注意题目说仅存在一个有效答案
+
+
+初始时两个指针分别指向第一个元素位置和最后一个元素的位置。每次计算两个指针指向的两个元素之和，并和目标值比较。如果两个元素之和等于目标值，则发现了唯一解。如果两个元素之和小于目标值，则将左侧指针右移一位。如果两个元素之和大于目标值，则将右侧指针左移一位。移动指针之后，重复上述操作，直到找到答案。
+
+使用双指针的实质是缩小查找范围。那么会不会把可能的解过滤掉？答案是不会。
+
+假设`numbers[i]+numbers[j]=target`是唯一解，其中`0≤i<j≤numbers.length−1`。        
+
+初始时两个指针分别指向下标0和下标`numbers.length−1`，左指针指向的下标小于或等于i，右指针指向的下标大于或等于 j。        除非初始时左指针和右指针已经位于下标 i 和 j，否则一定是左指针先到达下标 i 的位置或者右指针先到达下标 j 的位置。
+
+- 如果左指针先到达下标 i 的位置，此时右指针还在下标 j 的右侧，`sum>target`，因此一定是右指针左移，左指针不可能移到 i 的右侧。
+
+- 如果右指针先到达下标 j 的位置，此时左指针还在下标 i 的左侧，`sum<target`，因此一定是左指针右移，右指针不可能移到 j 的左侧。
+
+由此可见，在整个移动过程中，左指针不可能移到 i 的右侧，右指针不可能移到 j 的左侧，因此不会把可能的解过滤掉。
+
+
+由于题目确保有唯一的答案，因此使用双指针一定可以找到答案。
+
+
+```python
+class Solution:
+    def twoSum(self, numbers: List[int], target: int) -> List[int]:
+        left = 0
+        right = len(numbers) - 1
+        result = [-1]*2
+        while left < right:
+            sum = numbers[left] + numbers[right]
+            if sum < target:
+                left += 1
+            elif sum > target:
+                right -= 1
+            else:
+                return [left+1, right+1]
+
+        return [-1, -1]
+```
+
+复杂度分析:    
+
+- 时间复杂度：O(n)，其中 n 是数组的长度。两个指针移动的总次数最多为 n 次。
+
+- 空间复杂度：O(1)。
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/28.\347\233\233\346\234\200\345\244\232\346\260\264\347\232\204\345\256\271\345\231\250.md" "b/Algorithm/28.\347\233\233\346\234\200\345\244\232\346\260\264\347\232\204\345\256\271\345\231\250.md"
new file mode 100644
index 00000000..d8f7ea6e
--- /dev/null
+++ "b/Algorithm/28.\347\233\233\346\234\200\345\244\232\346\260\264\347\232\204\345\256\271\345\231\250.md"
@@ -0,0 +1,73 @@
+28.盛最多水的容器
+===
+
+
+### 题目
+
+给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。
+
+找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
+
+返回容器可以储存的最大水量。
+
+说明：你不能倾斜容器。
+
+
+
+示例 1:     
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_28_1.png?raw=true)
+
+- 输入：[1,8,6,2,5,4,8,3,7]
+- 输出：49 
+- 解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。
+
+示例 2:    
+
+- 输入：height = [1,1]
+- 输出：1
+ 
+
+提示:    
+
+- n == height.length
+- 2 <= n <= 105
+- 0 <= height[i] <= 104
+
+### 思路
+
+- 求出两个index1和index2，其中index < index2，使得min(height[index1], height[index2]) * (index2 - index1)最大
+- 核心就是：优先移动短板指针，因为面积是由短板的高度决定。
+
+在每个状态下，无论长板或短板向中间收窄一格，都会导致水槽 底边宽度 −1​ 变短:    
+
+- 若向内 移动短板 ，水槽的短板 min(h[i],h[j]) 可能变大，因此下个水槽的面积 可能增大 。
+- 若向内 移动长板 ，水槽的短板 min(h[i],h[j])​ 不变或变小，因此下个水槽的面积 一定变小 。
+
+因此，初始化双指针分列水槽左右两端，循环每轮将短板向内移动一格，并更新面积最大值，直到两指针相遇时跳出；即可获得最大面积。
+
+
+```python
+class Solution:
+    def maxArea(self, height: List[int]) -> int:
+        i, j, res = 0, len(height) - 1, 0
+        while i < j:
+            if height[i] < height[j]:
+                res = max(res, height[i] * (j - i))
+                i += 1
+            else:
+                res = max(res, height[j] * (j - i))
+                j -= 1
+        return res
+```
+
+复杂度分析:    
+
+- 时间复杂度 O(N)​ ： 双指针遍历一次底边宽度 N​​ 。
+- 空间复杂度 O(1)​ ： 变量 i , j , res 使用常数额外空间。
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/29.\344\270\211\346\225\260\344\271\213\345\222\214.md" "b/Algorithm/29.\344\270\211\346\225\260\344\271\213\345\222\214.md"
new file mode 100644
index 00000000..fae1fd31
--- /dev/null
+++ "b/Algorithm/29.\344\270\211\346\225\260\344\271\213\345\222\214.md"
@@ -0,0 +1,109 @@
+29.三数之和
+===
+
+
+### 题目
+
+
+给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。
+
+注意：答案中不可以包含重复的三元组。
+
+ 
+
+ 
+
+示例 1:    
+
+- 输入：nums = [-1,0,1,2,-1,-4]
+- 输出：[[-1,-1,2],[-1,0,1]]
+- 解释:    
+    - nums[0] + nums[1] + nums[2] = (-1) + 0 + 1 = 0 。
+    - nums[1] + nums[2] + nums[4] = 0 + 1 + (-1) = 0 。
+    - nums[0] + nums[3] + nums[4] = (-1) + 2 + (-1) = 0 。
+- 不同的三元组是 [-1,0,1] 和 [-1,-1,2] 。
+注意，输出的顺序和三元组的顺序并不重要。
+
+示例 2:    
+
+- 输入：nums = [0,1,1]
+- 输出：[]
+- 解释：唯一可能的三元组和不为 0 。
+
+示例 3:   
+
+- 输入：nums = [0,0,0]
+- 输出：[[0,0,0]]
+- 解释：唯一可能的三元组和为 0 。
+ 
+
+提示:    
+
+- 3 <= nums.length <= 3000
+- -105 <= nums[i] <= 105
+
+
+### 思路
+
+
+- 特判，对于数组长度 n，如果数组为 null 或者数组长度小于 3，返回 []。
+- 对数组进行从小到大的排序。
+- 从0到nums.length - 2(因为一共三个数，后面还有有两个数)遍历排序后数组:   
+    - 若 nums[i]>0：因为已经排序好，所以后面不可能有三个数加和等于 0，直接返回结果。
+    - 对于重复元素：跳过，避免出现重复解
+    - 令左指针 L=i+1，右指针 R=n−1，当 L<R 时，执行循环:     
+        - 当 nums[i]+nums[L]+nums[R]==0，执行循环，判断左界和右界是否和下一位置重复，去除重复解。并同时将 L,R 移到下一位置，寻找新的解
+        - 若和大于 0，说明 nums[R] 太大，R 左移
+        - 若和小于 0，说明 nums[L] 太小，L 右移
+
+```python
+
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        res = []
+        if not nums or len(nums) < 3:
+            return res
+        nums = sorted(nums)
+        for i in range(len(nums) - 2):
+            if nums[i] > 0:
+                return res
+            if i > 0 and nums[i] == nums[i - 1]:
+                continue
+
+            left = i + 1
+            right = len(nums) - 1
+            while left < right:
+                result = nums[i] + nums[left] + nums[right]
+                if result > 0:
+                    # 需要right减小
+                    right -= 1
+                elif result < 0:
+                    left += 1
+                else:
+                    res.append([nums[i], nums[left], nums[right]])
+                    # 去重复，判断左边或右边的元素是否与当前的相同，相同就夸脱
+                    while left < right and nums[left] == nums[left + 1]:
+                        left += 1
+
+                    while left < right and nums[right] == nums[right - 1]:
+                        right -= 1
+                     # 移动指针
+                    left += 1
+                    right -= 1
+        return res
+
+```
+
+
+复杂度分析:    
+
+- 时间复杂度：O(n²)，数组排序 O(NlogN)，遍历数组 O(n)，双指针遍历 O(n)，总体 O(NlogN)+O(n)∗O(n)，O(n²)
+- 空间复杂度：O(1)
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/30.\351\225\277\345\272\246\346\234\200\345\260\217\347\232\204\345\255\220\346\225\260\347\273\204.md" "b/Algorithm/30.\351\225\277\345\272\246\346\234\200\345\260\217\347\232\204\345\255\220\346\225\260\347\273\204.md"
new file mode 100644
index 00000000..c04f8f5d
--- /dev/null
+++ "b/Algorithm/30.\351\225\277\345\272\246\346\234\200\345\260\217\347\232\204\345\255\220\346\225\260\347\273\204.md"
@@ -0,0 +1,102 @@
+30.长度最小的子数组
+===
+
+
+### 题目
+
+给定一个含有 n 个正整数的数组和一个正整数 target 。
+
+找出该数组中满足其总和大于等于 target 的长度最小的 子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。
+
+ 
+
+示例 1:    
+
+- 输入：target = 7, nums = [2,3,1,2,4,3]
+- 输出：2
+- 解释：子数组 [4,3] 是该条件下的长度最小的子数组。
+
+示例 2:    
+
+- 输入：target = 4, nums = [1,4,4]
+- 输出：1
+
+示例 3:    
+
+- 输入：target = 11, nums = [1,1,1,1,1,1,1,1]
+- 输出：0
+ 
+
+提示:    
+
+- 1 <= target <= 109
+- 1 <= nums.length <= 105
+- 1 <= nums[i] <= 104
+ 
+
+进阶:     
+
+如果你已经实现 O(n) 时间复杂度的解法, 请尝试设计一个 O(n log(n)) 时间复杂度的解法。
+
+
+
+### 思路
+
+注意:  
+子数组 是数组中连续的 非空 元素序列。
+
+所以下面排序的方法是错误的。 因为不连续
+```python
+class Solution:
+    def minSubArrayLen(self, target, nums) -> int:
+        nums = sorted(nums, reverse=True)
+        result = 0
+        total = 0
+        for i in nums:
+            print(i)
+            total += i
+            result += 1
+            print(total)
+            if total >= target:
+                print(result)
+                return result
+        return result
+```
+
+
+2.使用队列相加（实际上我们也可以把它称作是滑动窗口，这里的队列其实就相当于一个窗口）
+
+我们把数组中的元素不停的入队，直到总和大于等于 s 为止，接着记录下队列中元素的个数，然后再不停的出队，直到队列中元素的和小于 s 为止（如果不小于 s，也要记录下队列中元素的个数，这个个数其实就是不小于 s 的连续子数组长度，我们要记录最小的即可）。接着再把数组中的元素添加到队列中……重复上面的操作，直到数组中的元素全部使用完为止。
+
+```java
+class Solution {
+    public int minSubArrayLen(int s, int[] nums) {
+        int leftIndex = 0;
+        int rightIndex = 0;
+        int sum = 0;
+        int min = Integer.MAX_VALUE;
+        while (rightIndex < nums.length) {
+            sum += nums[rightIndex++];
+            while (sum >= s) {
+                min = Math.min(min, rightIndex - leftIndex);
+                sum -= nums[leftIndex++];
+            }
+        }
+        return min == Integer.MAX_VALUE ? 0 : min;
+    }
+}
+```
+
+
+复杂度分析:    
+
+- 时间复杂度：O(n)，其中 n 是数组的长度。指针 start 和 end 最多各移动 n 次。
+
+- 空间复杂度：O(1)。
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/31.\346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262.md" "b/Algorithm/31.\346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262.md"
new file mode 100644
index 00000000..32e4a899
--- /dev/null
+++ "b/Algorithm/31.\346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262.md"
@@ -0,0 +1,107 @@
+31.无重复字符的最长子串
+===
+
+
+### 题目
+
+给定一个字符串 s ，请你找出其中不含有重复字符的 最长 子串 的长度。
+
+ 
+
+示例 1:     
+
+- 输入: s = "abcabcbb"
+- 输出: 3 
+- 解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
+
+示例 2:     
+
+- 输入: s = "bbbbb"
+- 输出: 1
+- 解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
+
+示例 3:      
+
+- 输入: s = "pwwkew"
+- 输出: 3
+- 解释: 
+    - 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
+    - 请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
+ 
+
+提示:    
+
+- 0 <= s.length <= 5 * 104
+- s 由英文字母、数字、符号和空格组成
+
+
+### 思路
+
+这道题主要用到思路是：滑动窗口
+
+什么是滑动窗口？
+
+其实就是一个队列,比如例题中的 abcabcbb，进入这个队列（窗口）为 abc 满足题目要求，当再进入 a，队列变成了 abca，这时候不满足要求。所以，我们要移动这个队列！
+
+如何移动？
+
+我们只要把队列的左边的元素移出就行了，直到满足题目要求！
+
+一直维持这样的队列，找出队列出现最长的长度时候，求出解！
+
+
+
+```python
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        leftIndex = 0
+        rightIndex = 0
+
+        # pwwkew
+        # "abcabcbb"
+        result = 0
+        while rightIndex < len(s):
+            index = s[leftIndex: rightIndex].find(s[rightIndex])
+            if index >= 0:
+                leftIndex += index + 1
+            rightIndex += 1
+            result = max(result, rightIndex - leftIndex)
+        return result
+```
+
+这个实现的时间复杂度是O(n²)，显然不满足。    
+
+可以使用Set或者HashMap进行优化:   
+
+
+
+```python
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        leftIndex = 0
+        rightIndex = 0
+        result = 0
+        data = set()
+        while rightIndex < len(s):
+            while s[rightIndex] in data:
+                data.remove(s[leftIndex])
+                leftIndex += 1
+            data.add(s[rightIndex])
+            rightIndex += 1
+            result = max(result, rightIndex - leftIndex)
+        return result
+```
+
+
+
+- 时间复杂度：O(n)
+
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/32.\344\270\262\350\201\224\346\211\200\346\234\211\345\215\225\350\257\215\347\232\204\345\255\220\344\270\262.md" "b/Algorithm/32.\344\270\262\350\201\224\346\211\200\346\234\211\345\215\225\350\257\215\347\232\204\345\255\220\344\270\262.md"
new file mode 100644
index 00000000..89302165
--- /dev/null
+++ "b/Algorithm/32.\344\270\262\350\201\224\346\211\200\346\234\211\345\215\225\350\257\215\347\232\204\345\255\220\344\270\262.md"
@@ -0,0 +1,59 @@
+32.串联所有单词的子串
+===
+
+
+### 题目
+
+给定一个字符串 s 和一个字符串数组 words。 words 中所有字符串 长度相同。
+
+s 中的 串联子串 是指一个包含  words 中所有字符串以任意顺序排列连接起来的子串。
+
+例如，如果 words = ["ab","cd","ef"]， 那么 "abcdef"， "abefcd"，"cdabef"， "cdefab"，"efabcd"， 和 "efcdab" 都是串联子串。 "acdbef" 不是串联子串，因为他不是任何 words 排列的连接。  
+
+返回所有串联子串在 s 中的开始索引。你可以以 任意顺序 返回答案。
+
+ 
+
+示例 1:    
+
+- 输入：s = "barfoothefoobarman", words = ["foo","bar"]
+- 输出：[0,9]
+- 解释：因为 words.length == 2 同时 words[i].length == 3，连接的子字符串的长度必须为 6。
+- 子串 "barfoo" 开始位置是 0。它是 words 中以 ["bar","foo"] 顺序排列的连接。
+- 子串 "foobar" 开始位置是 9。它是 words 中以 ["foo","bar"] 顺序排列的连接。
+- 输出顺序无关紧要。返回 [9,0] 也是可以的。
+
+示例 2:    
+
+- 输入：s = "wordgoodgoodgoodbestword", words = ["word","good","best","word"]
+- 输出：[]
+- 解释：因为 words.length == 4 并且 words[i].length == 4，所以串联子串的长度必须为 16。
+- s 中没有子串长度为 16 并且等于 words 的任何顺序排列的连接。
+- 所以我们返回一个空数组。
+
+示例 3:    
+
+- 输入：s = "barfoofoobarthefoobarman", words = ["bar","foo","the"]
+- 输出：[6,9,12]
+- 解释：因为 words.length == 3 并且 words[i].length == 3，所以串联子串的长度必须为 9。
+- 子串 "foobarthe" 开始位置是 6。它是 words 中以 ["foo","bar","the"] 顺序排列的连接。
+- 子串 "barthefoo" 开始位置是 9。它是 words 中以 ["bar","the","foo"] 顺序排列的连接。
+- 子串 "thefoobar" 开始位置是 12。它是 words 中以 ["the","foo","bar"] 顺序排列的连接。
+ 
+
+提示:     
+
+- 1 <= s.length <= 104
+- 1 <= words.length <= 5000
+- 1 <= words[i].length <= 30
+- words[i] 和 s 由小写英文字母组成
+
+### 思路
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git a/Algorithm/26..md b/Algorithm/33..md
similarity index 100%
rename from Algorithm/26..md
rename to Algorithm/33..md
diff --git a/Algorithm/27..md b/Algorithm/34..md
similarity index 100%
rename from Algorithm/27..md
rename to Algorithm/34..md
diff --git a/Algorithm/35..md b/Algorithm/35..md
new file mode 100644
index 00000000..0970b4ab
--- /dev/null
+++ b/Algorithm/35..md
@@ -0,0 +1,17 @@
+18.整数转罗马数字
+===
+
+
+### 题目
+
+
+
+### 思路
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	

From 2a894a6f09bf7a6e7ccdf3ede750bc008772cb80 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Fri, 20 Jun 2025 16:26:44 +0800
Subject: [PATCH 208/213] add notes

---
 ...15\347\232\204\345\255\220\344\270\262.md" | 159 ++++++++++++++++++
 Algorithm/33..md                              |  17 --
 ...06\347\233\226\345\255\220\344\270\262.md" | 109 ++++++++++++
 3 files changed, 268 insertions(+), 17 deletions(-)
 delete mode 100644 Algorithm/33..md
 create mode 100644 "Algorithm/33.\346\234\200\345\260\217\350\246\206\347\233\226\345\255\220\344\270\262.md"

diff --git "a/Algorithm/32.\344\270\262\350\201\224\346\211\200\346\234\211\345\215\225\350\257\215\347\232\204\345\255\220\344\270\262.md" "b/Algorithm/32.\344\270\262\350\201\224\346\211\200\346\234\211\345\215\225\350\257\215\347\232\204\345\255\220\344\270\262.md"
index 89302165..73f0d47d 100644
--- "a/Algorithm/32.\344\270\262\350\201\224\346\211\200\346\234\211\345\215\225\350\257\215\347\232\204\345\255\220\344\270\262.md"
+++ "b/Algorithm/32.\344\270\262\350\201\224\346\211\200\346\234\211\345\215\225\350\257\215\347\232\204\345\255\220\344\270\262.md"
@@ -50,6 +50,165 @@ s 中的 串联子串 是指一个包含  words 中所有字符串以任意顺
 
 ### 思路
 
+##### 方法一，从头到尾遍历s
+
+- words中每个字符的长度是m、words整个数组的长度是n
+- 那我们每次可以从s中从头开始去遍历，每次是取 `m*n` 个字符(窗口)
+- 然后把这个`m*n`个字符按照words中每个字符的长度m进行分割，然后把分割后的单词与words中的单词进行比较
+- 如果和words中的都一样，那当前的索引就是。否则不是
+- 在与words中的单词进行比较的时候，这个时候是不用关心顺序的，所以我们可以用一个哈希表来表示单词以及频次
+    - 当窗口中出现一个单词时，我们就把该单词加到哈希表中，如果已经存在，那就在后面的值+1
+    - 然后用哈希表中的内容与words中的单词进行对比，如果words中出现一个单词且也在哈希表中，那就将哈希表中该单词的频次减1，如果是0了就一次该单词
+    - 等到最后都遍历完，如果哈希表的长度是0，那就说明完全与words重点额一样
+
+```python
+
+class Solution:
+
+    def findSubstring(self, s: str, words: List[str]) -> List[int]:
+        res = []
+        if len(s) == 0 or len(words) == 0 or len(words[0]) == 0:
+            return[]
+
+        wordsLength = len(words[0])
+        slideLength = wordsLength * len(words)
+        wordsCount = len(words)
+
+        wordsMap = dict()
+        for word in words:
+            wordsMap[word] = wordsMap.get(word, 0) + 1
+
+        tempMap = dict()
+        for index in range(len(s) - slideLength + 1):
+            currentString = s[index: index+slideLength]
+            print(currentString)
+            for currentStringIndex in range(wordsCount):
+                currentWord = currentString[currentStringIndex * wordsLength: (currentStringIndex + 1) * wordsLength]
+                tempMap[currentWord] = tempMap.get(currentWord, 0) + 1
+
+            print(tempMap)
+            print(wordsMap)
+            if tempMap == wordsMap:
+                res.append(index)
+            tempMap.clear()
+
+
+        return res
+```
+
+
+
+时间复杂度：O(n×m×k)，n为s的长度，m为每个words中单词的长度，也就是len(words[0])，k为words的长度，也就是len(words)
+
+
+空间复杂度：每次循环都新建一个字典tempMap，但循环结束就清除，所以空间为O(m)（m是words中不同单词的个数）？实际上每次循环都重新统计，所以空间上是O(m)，但要注意，我们每次循环都重新统计整个子串，所以没有利用滑动窗口的特性。
+
+
+而下面方法二的时间复杂度是： 
+- O(n×k): n为s的长度，k为words中单词的个数
+
+
+
+##### 方法二
+
+
+上面方法一种当仅使用一个从0开始的滑动窗口时，为了避免漏掉一些子串，在缩短窗口时，每次只能缩小一格，而且这还会导致窗口内所维护的单词计数无效。那么，希望有一个方法，可以保证:     
+- 不遗漏子串
+- 缩小窗口时，不会使窗口内的单词计数无效
+
+那么，在使用滑动窗口时，每次都移动 sz = len(words[0]) 个字符，那么我们就可以按照单词的纬度进行统计。
+但是，这样会导致某一些子串没有枚举到（即[1, sz-1]为起点的子串都被忽略了），所以为了保证不遗漏子串，可以枚举以[0, sz-1]为起点的所有滑动窗口，并且每一个滑窗都是互相独立的。
+
+--- 
+
+- 建立滑动窗口
+
+    - 如何建立：计算窗口长度为：words中所有串拼接后的长度len，第一个窗口为[0,len-1]。
+    - 如果窗口中的字符串和words中所有串拼接后相等，则说明满足要求。
+    - 如何判断:     
+        - 将words中的所有word放入hashmap。key为word，value为个数。
+        - 对窗口进行substr操作，每隔d，substr一次。d为words中word的长度。将substr的结果作为key放入另一个hashmap,个数为value。
+        - 当窗口中没有剩余字符时，对两个map进行判断，如果相等。说明满足要求。此时记录窗口的起点。
+
+- 建立多起点的滑动窗口。
+
+    - 何为多起点：
+        - 一般理解滑动窗口从0或者某个数值开始，向右滑动不断滑动一个步长。
+        - 此处需要建立多个滑动窗口，数量为d。起点分别为0,1,2...d；
+
+    - 为何需要多起点：
+        - 如果只建立一个滑动窗口，那么每次就只能滑动一格，因为需要找到所有的可能。但是这样的操作意味着之前建立的map需要重新构建
+        - 例如：foobarfoobar [foo][bar]。当foobar完成匹配后，向右滑动一格，oobarf。这时候需要重新构建map。插入oob ,arf。时间复杂度很高，而滑动窗口应该是线性时间复杂度，
+        - 理想状态是，滑动d格，删去左侧foo，加入右侧foo。这个时候不需要重新构建map，map中原本的foo的计数先-1再+1即可，然后判断即可。
+
+    那么如果按照上面的方法，每次都滑动d，又会漏检。例如afoobarfoobar [foo][bar]     
+    
+    因此，需要多起点，afoobar，foobar。。个数为d个。这样每个窗口每次都是滑动d格。map的效率最高
+
+    - 如何建立多起点
+
+    - 从0开始初始化d个滑动窗口。每个滑动窗口每次都是滑动d格。建立相应的map。
+
+    - 最后得到vector<map<string, int>>;
+
+- 滑动
+
+    - 由于已经建立了多起点的滑动窗口，所以不会存在漏检的情况。同时map的效率最高。
+
+
+
+
+
+
+```java
+
+class Solution {
+    public List<Integer> findSubstring(String s, String[] words) {
+    	// 记录所有满足的结果索引
+        List<Integer> res = new ArrayList<>();
+        if (s == null || s.length() == 0 || words == null || words.length == 0) {
+        	return res;
+        }
+        	
+        HashMap<String, Integer> map = new HashMap<>();
+        // 每个单词的长度是固定的
+        int one_word = words[0].length();
+        int word_num = words.length;
+        // 窗口长度
+        int all_len = one_word * word_num;
+        // 把words中的内容和次数都记录到HashMap中
+        for (String word : words) {
+            map.put(word, map.getOrDefault(word, 0) + 1);
+        }
+
+        for (int i = 0; i < one_word; i++) {
+            int left = i, right = i, count = 0;
+            HashMap<String, Integer> tmp_map = new HashMap<>();
+            while (right + one_word <= s.length()) {
+                String w = s.substring(right, right + one_word);
+                right += one_word;
+                if (!map.containsKey(w)) {
+                    count = 0;
+                    left = right;
+                    tmp_map.clear();
+                } else {
+                    tmp_map.put(w, tmp_map.getOrDefault(w, 0) + 1);
+                    count++;
+                    while (tmp_map.getOrDefault(w, 0) > map.getOrDefault(w, 0)) {
+                        String t_w = s.substring(left, left + one_word);
+                        count--;
+                        tmp_map.put(t_w, tmp_map.getOrDefault(t_w, 0) - 1);
+                        left += one_word;
+                    }
+                    if (count == word_num) res.add(left);
+                }
+            }
+        }
+        return res;
+    }
+}
+```
+
 
 
 ---
diff --git a/Algorithm/33..md b/Algorithm/33..md
deleted file mode 100644
index 0970b4ab..00000000
--- a/Algorithm/33..md
+++ /dev/null
@@ -1,17 +0,0 @@
-18.整数转罗马数字
-===
-
-
-### 题目
-
-
-
-### 思路
-
-
-
----
-- 邮箱 ：charon.chui@gmail.com  
-- Good Luck! 
-
-	
diff --git "a/Algorithm/33.\346\234\200\345\260\217\350\246\206\347\233\226\345\255\220\344\270\262.md" "b/Algorithm/33.\346\234\200\345\260\217\350\246\206\347\233\226\345\255\220\344\270\262.md"
new file mode 100644
index 00000000..c4f31bed
--- /dev/null
+++ "b/Algorithm/33.\346\234\200\345\260\217\350\246\206\347\233\226\345\255\220\344\270\262.md"
@@ -0,0 +1,109 @@
+33.最小覆盖子串
+===
+
+
+### 题目
+
+给你一个字符串s、一个字符串t。返回s中涵盖t所有字符的最小子串。如果s中不存在涵盖t所有字符的子串，则返回空字符串 "" 。
+
+ 
+
+注意:    
+
+- 对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。
+- 如果 s 中存在这样的子串，我们保证它是唯一的答案。
+ 
+
+示例 1:    
+
+- 输入：s = "ADOBECODEBANC", t = "ABC"
+- 输出："BANC"
+- 解释：最小覆盖子串 "BANC" 包含来自字符串 t 的 'A'、'B' 和 'C'。
+
+示例 2:    
+
+- 输入：s = "a", t = "a"
+- 输出："a"
+- 解释：整个字符串 s 是最小覆盖子串。
+
+示例 3:    
+
+- 输入: s = "a", t = "aa"
+- 输出: ""
+- 解释: t 中两个字符 'a' 均应包含在 s 的子串中，因此没有符合条件的子字符串，返回空字符串。
+ 
+
+提示:     
+
+- m == s.length
+- n == t.length
+- 1 <= m, n <= 105
+- s 和 t 由英文字母组成
+ 
+
+进阶：你能设计一个在 o(m+n) 时间内解决此问题的算法吗？
+
+### 思路
+
+题目中说如果 s 中存在这样的子串，我们保证它是唯一的答案。
+
+双指针
+
+- 初始化ansLeft=−1, ansRight=m，用来记录最短子串的左右端点，其中m是s的长度。
+- 用一个哈希表（或者数组）cntT 统计 t 中每个字母的出现次数。
+- 初始化 left=0，以及一个空哈希表（或者数组）cntS，用来统计 s 子串中每个字母的出现次数。
+- 遍历 s，设当前枚举的子串右端点为 right，把 s[right] 的出现次数加一。
+- 遍历 cntS 中的每个字母及其出现次数，如果出现次数都大于等于 cntT 中的字母出现次数：
+    - 如果`right−left<ansRight−ansLeft`，说明我们找到了更短的子串，更新 ansLeft=left, ansRight=right。
+    - 把 s[left] 的出现次数减一。
+    - 左端点右移，即 left 加一。
+    重复上述三步，直到 cntS 有字母的出现次数小于 cntT 中该字母的出现次数为止。
+
+最后，如果 ansLeft<0，说明没有找到符合要求的子串，返回空字符串，否则返回下标 ansLeft 到下标 ansRight 之间的子串。
+由于本题大写字母和小写字母都有，为了方便，代码实现时可以直接创建大小为 128 的数组，保证所有 ASCII 字符都可以统计。
+
+
+```java
+class Solution {
+    public String minWindow(String s, String t) {
+        Map<Character, Integer> cnt = new HashMap<>();
+        for (char c : t.toCharArray()) {
+            cnt.put(c, cnt.getOrDefault(c, 0) + 1);
+        }
+        int ans_l = -1;
+        int ans_r = s.length();
+        int l = 0;
+        int count = cnt.size();
+        for (int r = 0; r < s.length(); r++) {
+            char c = s.charAt(r);
+            if (cnt.containsKey(c)) {
+                cnt.put(c, cnt.get(c) - 1);
+                if (cnt.get(c) == 0) {
+                    count--;
+                }
+            }
+            while (count == 0) {
+                if (ans_r - ans_l > r - l) {
+                    ans_l = l;
+                    ans_r = r;
+                }
+                char ch = s.charAt(l);
+                if (cnt.containsKey(ch)) {
+                    if (cnt.get(ch) == 0) {
+                        count++;
+                    }
+                    cnt.put(ch, cnt.get(ch) + 1);
+                }
+                l++;
+            }
+        }
+        return ans_l == -1 ? "" : s.substring(ans_l, ans_r+1);
+    }
+}
+```
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	

From 14691c5bfaba919ed8f9082a695e5a9383b95b89 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 2 Jul 2025 10:31:25 +0800
Subject: [PATCH 209/213] add notes

---
 ...10\347\232\204\346\225\260\347\213\254.md" | 142 ++++++++++
 ...72\346\227\213\347\237\251\351\230\265.md" |  99 +++++++
 ...13\350\275\254\345\233\276\345\203\217.md" | 252 ++++++++++++++++++
 Algorithm/{34..md => 37..md}                  |   0
 Algorithm/{35..md => 38..md}                  |   0
 Algorithm/39..md                              |  17 ++
 Algorithm/40..md                              |  17 ++
 7 files changed, 527 insertions(+)
 create mode 100644 "Algorithm/34.\346\234\211\346\225\210\347\232\204\346\225\260\347\213\254.md"
 create mode 100644 "Algorithm/35.\350\236\272\346\227\213\347\237\251\351\230\265.md"
 create mode 100644 "Algorithm/36.\346\227\213\350\275\254\345\233\276\345\203\217.md"
 rename Algorithm/{34..md => 37..md} (100%)
 rename Algorithm/{35..md => 38..md} (100%)
 create mode 100644 Algorithm/39..md
 create mode 100644 Algorithm/40..md

diff --git "a/Algorithm/34.\346\234\211\346\225\210\347\232\204\346\225\260\347\213\254.md" "b/Algorithm/34.\346\234\211\346\225\210\347\232\204\346\225\260\347\213\254.md"
new file mode 100644
index 00000000..e1c6fefa
--- /dev/null
+++ "b/Algorithm/34.\346\234\211\346\225\210\347\232\204\346\225\260\347\213\254.md"
@@ -0,0 +1,142 @@
+34.有效的数独
+===
+
+
+### 题目
+
+请你判断一个 9 x 9 的数独是否有效。只需要 根据以下规则 ，验证已经填入的数字是否有效即可。
+
+数字 1-9 在每一行只能出现一次。
+数字 1-9 在每一列只能出现一次。
+数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）
+ 
+
+注意:     
+
+- 一个有效的数独（部分已被填充）不一定是可解的。
+- 只需要根据以上规则，验证已经填入的数字是否有效即可。
+- 空白格用 '.' 表示。
+
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/isValidSudoku.png?raw=true)
+
+
+```
+输入：board = 
+[["5","3",".",".","7",".",".",".","."]
+,["6",".",".","1","9","5",".",".","."]
+,[".","9","8",".",".",".",".","6","."]
+,["8",".",".",".","6",".",".",".","3"]
+,["4",".",".","8",".","3",".",".","1"]
+,["7",".",".",".","2",".",".",".","6"]
+,[".","6",".",".",".",".","2","8","."]
+,[".",".",".","4","1","9",".",".","5"]
+,[".",".",".",".","8",".",".","7","9"]]
+```
+输出：true
+
+```
+输入：board = 
+[["8","3",".",".","7",".",".",".","."]
+,["6",".",".","1","9","5",".",".","."]
+,[".","9","8",".",".",".",".","6","."]
+,["8",".",".",".","6",".",".",".","3"]
+,["4",".",".","8",".","3",".",".","1"]
+,["7",".",".",".","2",".",".",".","6"]
+,[".","6",".",".",".",".","2","8","."]
+,[".",".",".","4","1","9",".",".","5"]
+,[".",".",".",".","8",".",".","7","9"]]
+```
+输出：false
+解释：除了第一行的第一个数字从 5 改为 8 以外，空格内其他数字均与 示例1 相同。 但由于位于左上角的 3x3 宫内有两个 8 存在, 因此这个数独是无效的。
+
+
+提示:     
+
+- board.length == 9
+- board[i].length == 9
+- board[i][j] 是一位数字（1-9）或者 '.'
+
+
+### 思路
+
+有效的数独满足以下三个条件：    
+
+- 同一个数字在每一行只能出现一次；
+
+- 同一个数字在每一列只能出现一次；
+
+- 同一个数字在每一个小九宫格只能出现一次。
+
+--- 
+
+- i是行标      
+- j是列标
+- 数字从char直接转换成int，会变成对应的ASCII数字码，而不是原来的数值。解决方法就是当前char数字减'0'：用两个char数字的ASCII码相减，差值就是原来char数值直接对应的int数值。
+    - 为什么不是减'0'，而是减'1'？
+    - 若运行了大佬的代码你会发现，减'0'的话会出现`ArrayIndexOutOfBoundsException`的异常。因为后面的代码将这个`num`作为了数组的下标。本身数组设置的就是9个位置，下标范围是`[0~8]`，那么遇到数字9作为下标的时候，不就越位了吗，所以就要减1，char转换成int的同时还能解决后面越位的情况。
+- boolean数组的巧妙建立
+    - 第一个[]存放第？行/列/块
+    - 第二个[]存放 相应数字
+    - 结合起来解释就是：第？行/列/块 是否 出现过相应数字
+
+- 行标决定一组block的起始位置（因为block为3行，所以除3取整得到组号，又因为每组block为3个，所以需要乘3），列标再细分出是哪个block（因为block是3列，所以除3取整）
+
+```
+blockIndex = i / 3 * 3 + j / 3的原因:    
+[0, 0, 0, 1, 1, 1, 2, 2, 2]
+[0, 0, 0, 1, 1, 1, 2, 2, 2]
+[0, 0, 0, 1, 1, 1, 2, 2, 2]
+[3, 3, 3, 4, 4, 4, 5, 5, 5]
+[3, 3, 3, 4, 4, 4, 5, 5, 5]
+[3, 3, 3, 4, 4, 4, 5, 5, 5]
+[6, 6, 6, 7, 7, 7, 8, 8, 8]
+[6, 6, 6, 7, 7, 7, 8, 8, 8]
+[6, 6, 6, 7, 7, 7, 8, 8, 8]
+```
+
+- blockIndex的规律探寻
+    - 微观`9x9` -> 宏观`3x3`
+    - （1）`i/3`为行号，`j/3`为列号
+    - （2）二维数组思路：`行号*列数＋列号`，即位置
+
+
+
+
+```java
+
+class Solution {
+    public boolean isValidSudoku(char[][] board) {
+        // 记录某行，某位数字是否已经被摆放
+        boolean[][] row = new boolean[9][9];
+        // 记录某列，某位数字是否已经被摆放
+        boolean[][] col = new boolean[9][9];
+        // 记录某 3x3 宫格内，某位数字是否已经被摆放
+        boolean[][] block = new boolean[9][9];
+
+        for (int i = 0; i < 9; i++) {
+            for (int j = 0; j < 9; j++) {
+                if (board[i][j] != '.') { // 只处理数字格子
+                    int num = board[i][j] - '1';
+                    int blockIndex = i / 3 * 3 + j / 3;
+                    if (row[i][num] || col[j][num] || block[blockIndex][num]) {
+                        return false;
+                    } else {
+                        row[i][num] = true;
+                        col[j][num] = true;
+                        block[blockIndex][num] = true;
+                    }
+                }
+            }
+        }
+        return true;
+    }
+}
+```
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/35.\350\236\272\346\227\213\347\237\251\351\230\265.md" "b/Algorithm/35.\350\236\272\346\227\213\347\237\251\351\230\265.md"
new file mode 100644
index 00000000..cdde4f92
--- /dev/null
+++ "b/Algorithm/35.\350\236\272\346\227\213\347\237\251\351\230\265.md"
@@ -0,0 +1,99 @@
+35.螺旋矩阵
+===
+
+
+### 题目
+
+
+给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。
+ 
+
+示例 1:    
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/spiralOrder_1.png?raw=true)
+
+- 输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
+- 输出：[1,2,3,6,9,8,7,4,5]
+
+示例 2:    
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/spiralOrder_2.png?raw=true)
+
+- 输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
+- 输出：[1,2,3,4,8,12,11,10,9,5,6,7]
+ 
+
+提示:    
+
+- m == matrix.length
+- n == matrix[i].length
+- 1 <= m, n <= 10
+- -100 <= matrix[i][j] <= 100
+
+
+### 思路
+
+- 对于这种螺旋遍历的方法，重要的是要确定上下左右四条边的位置
+- 初始化的时候，上边up就是0，下边down就是m-1，左边left是0，右边right是n-1。
+- 然后我们进行while循环
+    - 先遍历上边第一行up ，将所有元素加入结果res，然后上边下移一位，如果此时上边大于下边，说明此时已经遍历完成了，直接break。
+
+
+```java
+class Solution {
+    public List<Integer> spiralOrder(int[][] matrix) {
+        List<Integer> res=new ArrayList<Integer>();
+
+        if(matrix.length==0 || matrix[0].length==0) {
+            return res;
+        }
+
+        int m = matrix.length;
+        int n =matrix[0].length;
+
+        int up = 0;
+        int down = m-1;
+        int left = 0;
+        int right = n-1;
+
+        while(true) {
+            for(int i=left; i<=right; i++) {
+            	res.add(matrix[up][i]);
+            }
+
+            if (++up > down) {
+            	break;
+            }
+
+            for (int i = up; i <= down; i++) {
+            	res.add(matrix[i][right]);
+            }
+
+            if (--right < left) {
+            	break;
+            }
+
+            for (int i = right; i >= left; i--) {
+            	res.add(matrix[down][i]);
+            }
+
+            if (--down < up) {
+            	break;
+            }
+
+            for (int i = down; i >= up; i--) {
+            	res.add(matrix[i][left]);
+            }
+
+            if (++left > right) {
+            	break;
+            }
+        }
+        return res;
+    }
+}
+```
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/36.\346\227\213\350\275\254\345\233\276\345\203\217.md" "b/Algorithm/36.\346\227\213\350\275\254\345\233\276\345\203\217.md"
new file mode 100644
index 00000000..ddda4601
--- /dev/null
+++ "b/Algorithm/36.\346\227\213\350\275\254\345\233\276\345\203\217.md"
@@ -0,0 +1,252 @@
+36.旋转图像
+===
+
+
+### 题目
+
+
+给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。
+
+你必须在 原地 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。
+
+示例1:   
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_rotate_1.png?raw=true)
+
+- 输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
+- 输出：[[7,4,1],[8,5,2],[9,6,3]]
+
+示例2:   
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_rotate_2.png?raw=true)
+
+- 输入：matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]
+- 输出：[[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]
+
+
+提示:    
+
+- n == matrix.length == matrix[i].length
+- 1 <= n <= 20
+- -1000 <= matrix[i][j] <= 1000
+
+
+
+
+### 思路
+
+##### 方法一： 辅助矩阵
+
+如下图所示，矩阵顺时针旋转 90º 后，可找到以下规律:     
+
+- 「第 i 行」元素旋转到「第 n−1−i 列」元素；
+- 「第 j 列」元素旋转到「第 j 行」元素；
+
+因此，对于矩阵任意第 i 行、第 j 列元素 matrix[i][j] ，矩阵旋转 90º 后「元素位置旋转公式」为:      
+
+```
+matrix[i][j] → matrix[j][n−1−i]
+原索引位置 →旋转后索引位置 
+​```
+  
+
+
+根据以上「元素旋转公式」，考虑遍历矩阵，将各元素依次写入到旋转后的索引位置。但仍存在问题：在写入一个元素 matrix[i][j]→matrix[j][n−1−i] 后，原矩阵元素 matrix[j][n−1−i] 就会被覆盖（即丢失），而此丢失的元素就无法被写入到旋转后的索引位置了。
+
+为解决此问题，考虑借助一个「辅助矩阵」暂存原矩阵，通过遍历辅助矩阵所有元素，将各元素填入「原矩阵」旋转后的新索引位置即可。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_rotate_3.png?raw=true)
+
+```python3
+class Solution:
+    def rotate(self, matrix: List[List[int]]) -> None:
+        n = len(matrix)
+        # 深拷贝 matrix -> tmp
+        tmp = copy.deepcopy(matrix)
+        # 根据元素旋转公式，遍历修改原矩阵 matrix 的各元素
+        for i in range(n):
+            for j in range(n):
+                matrix[j][n - 1 - i] = tmp[i][j]
+```
+
+复杂度分析:   
+​
+- 遍历矩阵所有元素的时间复杂度为O(N²)
+- 由于借助了一个辅助矩阵，空间复杂度为O(N²)。
+
+
+##### 方法二：原地修改
+
+
+考虑不借助辅助矩阵，通过在原矩阵中直接「原地修改」，实现空间复杂度 O(1) 的解法。
+
+以位于矩阵四个角点的元素为例，设矩阵左上角元素A、右上角元素B、右下角元素C、左下角元素D。      
+
+矩阵旋转90º后，相当于依次先后执行D→A,C→D,B→C,A→B修改元素，即如下「首尾相接」的元素旋转操作:     
+```
+A←D←C←B←A
+```
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_rotate_4.png?raw=true)
+
+
+如上图所示:    
+
+- 由于第1步D→A已经将A覆盖（导致A丢失），此丢失导致最后第4步A→B无法赋值。为解决此问题，考虑借助一个「辅助变量 tmp 」预先存储 A ，此时的旋转操作变为：
+
+```
+暂存 tmp=A
+A←D←C←B←tmp
+```
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_rotate_5.png?raw=true)
+
+
+
+如上图所示，一轮可以完成矩阵 4 个元素的旋转。因而，只要分别以矩阵左上角 1/4 的各元素为起始点执行以上旋转操作，即可完整实现矩阵旋转。
+
+- 当矩阵大小 n 为偶数时，取前½ * n行、前 ½ * n 列的元素为起始点；
+
+- 当矩阵大小 n 为奇数时，取前 ½ * n 行、前  ½ * (n + 1)列的元素为起始点。
+
+令 matrix[i][j]=A ，根据文章开头的元素旋转公式，可推导得适用于任意起始点的元素旋转操作：
+
+```
+暂存tmp=matrix[i][j]
+matrix[i][j]←matrix[n−1−j][i]←matrix[n−1−i][n−1−j]←matrix[j][n−1−i]←tmp
+```
+
+
+
+```python3
+class Solution:
+    def rotate(self, matrix: List[List[int]]) -> None:
+        n = len(matrix)
+        for i in range(n // 2):
+            for j in range((n + 1) // 2):
+                tmp = matrix[i][j]
+                matrix[i][j] = matrix[n - 1 - j][i]
+                matrix[n - 1 - j][i] = matrix[n - 1 - i][n - 1 - j]
+                matrix[n - 1 - i][n - 1 - j] = matrix[j][n - 1 - i]
+                matrix[j][n - 1 - i] = tmp
+```
+
+
+```java
+class Solution {
+    public void rotate(int[][] matrix) {
+        // 设矩阵行列数为 n
+        int n = matrix.length;
+        // 起始点范围为 0 <= i < n / 2 , 0 <= j < (n + 1) / 2
+        // 其中 '/' 为整数除法
+        for (int i = 0; i < n / 2; i++) {
+            for (int j = 0; j < (n + 1) / 2; j++) {
+                // 暂存 A 至 tmp
+                int tmp = matrix[i][j];
+                // 元素旋转操作 A <- D <- C <- B <- tmp
+                matrix[i][j] = matrix[n - 1 - j][i];
+                matrix[n - 1 - j][i] = matrix[n - 1 - i][n - 1 - j];
+                matrix[n - 1 - i][n - 1 - j] = matrix[j][n - 1 - i];
+                matrix[j][n - 1 - i] = tmp;
+            }
+        }
+    }
+}
+```
+
+复杂度分析:    
+
+- 时间复杂度 O(N²): 其中 N 为输入矩阵的行（列）数。需要将矩阵中每个元素旋转到新的位置，即对矩阵所有元素操作一次，使用O(N²)时间。
+- 空间复杂度 O(1): 临时变量 tmp 使用常数大小的额外空间。值得注意，当循环中进入下轮迭代，上轮迭代初始化的 tmp 占用的内存就会被自动释放，因此无累计使用空间。
+
+
+##### 方法三: 先转置再左右翻转
+
+```
+很明显可以发现，对二位矩阵顺时针旋转90度，等价于先对二位矩阵进行转置操作，再对转置后的数组进行左右翻转。
+如：
+原矩阵：
+1   2   3
+4   5   6
+7   8   9
+
+转置后：
+1   4   7
+2   5   8   
+3   6   9
+
+左右翻转：
+7   4   1   
+8   5   2   
+9   6   3
+
+原矩阵：
+1   2   3
+4   5   6
+7   8   9
+
+顺时针旋转90度：
+7   4   1
+8   5   2   
+9   6   3
+
+可以发现，顺时针旋转90度后的矩阵，于先转置再左右翻转的矩阵相同
+```
+
+1、矩阵转置:
+
+矩阵的转置是将矩阵的行和列互换，即将元素 matrix[i][j] 和 matrix[j][i] 交换。
+性质:    
+- 转置操作不会改变主对角线上的元素（即 i=j 时的元素）。
+- 转置完成后，矩阵变为关于主对角线对称。
+
+本质：将矩阵对角线两边的元素互换
+
+
+2、逐行翻转:
+
+- 对转置后的矩阵，每一行进行翻转，即从左到右交换元素，得到最终旋转后的结果。
+
+性质：
+转置只是调整了行列的关系，但要实现顺时针旋转 90 度，还需要将转置后的行元素顺序反转。
+
+
+全部代码:    
+
+```python3
+class Solution:
+    def transpose(self, matrix:List[List[int]]) -> None:
+        length = len(matrix)
+        for i in range(0, length):
+            for j in range(0, i):
+                temp = matrix[i][j]
+                matrix[i][j] = matrix[j][i]
+                matrix[j][i] = temp
+
+    def overturn(self, matrix:List[List[int]]) -> None:
+        length = len(matrix)
+        for i in range(0, length//2):
+            for j in range(0, length):
+                temp = matrix[j][i]
+                matrix[j][i] = matrix[j][length - 1 - i]
+                matrix[j][length - 1 - i] = temp
+
+    def rotate(self, matrix: List[List[int]]) -> None:
+        """
+        Do not return anything, modify matrix in-place instead.
+        """
+        self.transpose(matrix)
+        self.overturn(matrix)
+```
+
+
+- 时间复杂度: O(N²)
+- 空间复杂度: O(1)
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git a/Algorithm/34..md b/Algorithm/37..md
similarity index 100%
rename from Algorithm/34..md
rename to Algorithm/37..md
diff --git a/Algorithm/35..md b/Algorithm/38..md
similarity index 100%
rename from Algorithm/35..md
rename to Algorithm/38..md
diff --git a/Algorithm/39..md b/Algorithm/39..md
new file mode 100644
index 00000000..0970b4ab
--- /dev/null
+++ b/Algorithm/39..md
@@ -0,0 +1,17 @@
+18.整数转罗马数字
+===
+
+
+### 题目
+
+
+
+### 思路
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git a/Algorithm/40..md b/Algorithm/40..md
new file mode 100644
index 00000000..0970b4ab
--- /dev/null
+++ b/Algorithm/40..md
@@ -0,0 +1,17 @@
+18.整数转罗马数字
+===
+
+
+### 题目
+
+
+
+### 思路
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	

From 57a26f717ca5f03971fc8e0a6de075817da60e3c Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Tue, 16 Sep 2025 11:01:21 +0800
Subject: [PATCH 210/213] add algorithm

---
 .../KMP\345\274\200\345\217\221.md"           |  34 +++
 ...51\351\230\265\347\275\256\351\233\266.md" | 165 +++++++++++++++
 ...37\345\221\275\346\270\270\346\210\217.md" | 137 ++++++++++++
 ...9.\350\265\216\351\207\221\344\277\241.md" |  97 +++++++++
 ...04\345\255\227\347\254\246\344\270\262.md" |  98 +++++++++
 ...25\350\257\215\350\247\204\345\276\213.md" | 114 ++++++++++
 ...15\345\274\202\344\275\215\350\257\215.md" | 194 +++++++++++++++++
 ...15\350\257\215\345\210\206\347\273\204.md" | 118 +++++++++++
 ...44\346\225\260\344\271\213\345\222\214.md" | 121 +++++++++++
 ...5.\345\277\253\344\271\220\346\225\260.md" | 198 ++++++++++++++++++
 ...345\244\215\345\205\203\347\264\240 II.md" | 112 ++++++++++
 ...36\347\273\255\345\272\217\345\210\227.md" | 133 ++++++++++++
 ...07\346\200\273\345\214\272\351\227\264.md" | 134 ++++++++++++
 ...10\345\271\266\345\214\272\351\227\264.md" |  82 ++++++++
 ...22\345\205\245\345\214\272\351\227\264.md" | 102 +++++++++
 ...25\347\210\206\346\260\224\347\220\203.md" | 110 ++++++++++
 ...10\347\232\204\346\213\254\345\217\267.md" | 140 +++++++++++++
 ...00\345\214\226\350\267\257\345\276\204.md" | 127 +++++++++++
 ...4.\346\234\200\345\260\217\346\240\210.md" | 103 +++++++++
 ...76\345\274\217\346\261\202\345\200\274.md" | 137 ++++++++++++
 ...54\350\256\241\347\256\227\345\231\250.md" | 163 ++++++++++++++
 Algorithm/{37..md => 57..md}                  |   0
 Algorithm/{38..md => 58..md}                  |   0
 Algorithm/{39..md => 59..md}                  |   0
 Algorithm/{40..md => 60..md}                  |   0
 Algorithm/61..md                              |  17 ++
 Algorithm/62..md                              |  17 ++
 27 files changed, 2653 insertions(+)
 create mode 100644 "AdavancedPart/KMP\345\274\200\345\217\221.md"
 create mode 100644 "Algorithm/37.\347\237\251\351\230\265\347\275\256\351\233\266.md"
 create mode 100644 "Algorithm/38.\347\224\237\345\221\275\346\270\270\346\210\217.md"
 create mode 100644 "Algorithm/39.\350\265\216\351\207\221\344\277\241.md"
 create mode 100644 "Algorithm/40.\345\220\214\346\236\204\345\255\227\347\254\246\344\270\262.md"
 create mode 100644 "Algorithm/41.\345\215\225\350\257\215\350\247\204\345\276\213.md"
 create mode 100644 "Algorithm/42.\346\234\211\346\225\210\347\232\204\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215.md"
 create mode 100644 "Algorithm/43.\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215\345\210\206\347\273\204.md"
 create mode 100644 "Algorithm/44.\344\270\244\346\225\260\344\271\213\345\222\214.md"
 create mode 100644 "Algorithm/45.\345\277\253\344\271\220\346\225\260.md"
 create mode 100644 "Algorithm/46.\345\255\230\345\234\250\351\207\215\345\244\215\345\205\203\347\264\240 II.md"
 create mode 100644 "Algorithm/47.\346\234\200\351\225\277\350\277\236\347\273\255\345\272\217\345\210\227.md"
 create mode 100644 "Algorithm/48.\346\261\207\346\200\273\345\214\272\351\227\264.md"
 create mode 100644 "Algorithm/49.\345\220\210\345\271\266\345\214\272\351\227\264.md"
 create mode 100644 "Algorithm/50.\346\217\222\345\205\245\345\214\272\351\227\264.md"
 create mode 100644 "Algorithm/51.\347\224\250\346\234\200\345\260\221\346\225\260\351\207\217\347\232\204\347\256\255\345\274\225\347\210\206\346\260\224\347\220\203.md"
 create mode 100644 "Algorithm/52.\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267.md"
 create mode 100644 "Algorithm/53.\347\256\200\345\214\226\350\267\257\345\276\204.md"
 create mode 100644 "Algorithm/54.\346\234\200\345\260\217\346\240\210.md"
 create mode 100644 "Algorithm/55.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217\346\261\202\345\200\274.md"
 create mode 100644 "Algorithm/56.\345\237\272\346\234\254\350\256\241\347\256\227\345\231\250.md"
 rename Algorithm/{37..md => 57..md} (100%)
 rename Algorithm/{38..md => 58..md} (100%)
 rename Algorithm/{39..md => 59..md} (100%)
 rename Algorithm/{40..md => 60..md} (100%)
 create mode 100644 Algorithm/61..md
 create mode 100644 Algorithm/62..md

diff --git "a/AdavancedPart/KMP\345\274\200\345\217\221.md" "b/AdavancedPart/KMP\345\274\200\345\217\221.md"
new file mode 100644
index 00000000..b4d7e54c
--- /dev/null
+++ "b/AdavancedPart/KMP\345\274\200\345\217\221.md"
@@ -0,0 +1,34 @@
+KMP开发
+===
+
+Kotlin Multiplatform（简称 KMP）是 JetBrains 推出的开源跨平台开发框架。
+
+它可以通过共享 Kotlin 编写的业务逻辑代码实现多平台复用。
+
+
+从应用场景来看，KMP 不仅局限于移动端，它支持 iOS、Android、Web、桌面端（Windows/macOS/Linux）以及服务器端的代码共享。这种扩展性使得开发者能够用同一套代码库构建全平台应用，大幅提升开发效率。
+
+
+
+KMP 有三大编译目标，分别是： Kotlin/JVM、Kotlin/Native、Kotlin/JS。通过编译不同的目标文件实现各端的跨平台能力。除此之外，KMP 还实验性地支持 WebAssembly（Kotlin/Wasm）编译目标，不过目前实际应用场景相对较少。
+
+
+### KMP编译器
+
+
+我们知道，一个语言的编译需要经过词法分析和语法分析，解析成抽象语法树 AST。
+而 KMP 为了将 Kotlin 源代码编译成不同的目标平台代码，就需要将 Kotlin 的编译产物进一步向不同的平台转化。
+Kotlin 语言的编译，与向不同的平台转化，明显是不同的职责，需要解耦，所以 KMP 的编译器必然有两个部分，也就是编译器前端（Frontend）与编译器后端（Backend）。
+Frontend 会将 AST 进一步转换为 Kotlin IR（Kotlin Intermediate Representation），是 Kotlin 源代码的中间表示形式，Kotlin IR 是编译器前端的输出，也是编译器后端的输入。
+Backend 则会吧 Kotlin IR 转换为不同平台的中间表示形式，最终生成目标代码。
+
+作者：A0微声z
+链接：https://juejin.cn/post/7507888457705275455
+来源：稀土掘金
+著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
+
+    	
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/Algorithm/37.\347\237\251\351\230\265\347\275\256\351\233\266.md" "b/Algorithm/37.\347\237\251\351\230\265\347\275\256\351\233\266.md"
new file mode 100644
index 00000000..774d552c
--- /dev/null
+++ "b/Algorithm/37.\347\237\251\351\230\265\347\275\256\351\233\266.md"
@@ -0,0 +1,165 @@
+37.矩阵置零
+===
+
+
+
+### 题目
+
+给定一个 m x n 的矩阵，如果一个元素为 0 ，则将其所在行和列的所有元素都设为 0 。请使用 原地 算法。
+
+
+示例:    
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_setzeros_1.png?raw=true)
+
+- 输入: matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]
+- 输出: [[0,0,0,0],[0,4,5,0],[0,3,1,0]]
+
+提示:    
+
+- m == matrix.length
+- n == matrix[0].length
+- 1 <= m, n <= 200
+- -231 <= matrix[i][j] <= 231 - 1
+ 
+
+进阶:     
+
+- 一个直观的解决方案是使用  O(mn) 的额外空间，但这并不是一个好的解决方案。
+- 一个简单的改进方案是使用 O(m + n) 的额外空间，但这仍然不是最好的解决方案。
+
+你能想出一个仅使用常量空间的解决方案吗？
+
+
+### 思路
+
+
+思路一:   用 O(m+n)额外空间
+ 
+- 两遍扫matrix,第一遍用集合记录哪些行,哪些列有0;第二遍置0
+
+```java
+class Solution {
+    public void setZeroes(int[][] matrix) {
+        Set<Integer> row_zero = new HashSet<>();
+        Set<Integer> col_zero = new HashSet<>();
+        int row = matrix.length;
+        int col = matrix[0].length;
+        for (int i = 0; i < row; i++) {
+            for (int j = 0; j < col; j++) {
+                if (matrix[i][j] == 0) {
+                    row_zero.add(i);
+                    col_zero.add(j);
+                }
+            }
+        }
+        for (int i = 0; i < row; i++) {
+            for (int j = 0; j < col; j++) {
+                if (row_zero.contains(i) || col_zero.contains(j)) matrix[i][j] = 0;
+            }
+        }  
+    }
+}
+```
+
+思路二: 用O(1)空间      
+
+关键思想: 用matrix第一行和第一列记录该行该列是否有0,作为标志位
+
+但是对于第一行,和第一列要设置一个标志位,为了防止自己这一行(一列)也有0的情况.注释写在代码里,直接看代码很好理解!
+
+思路：第一次循环
+1、0行数组的每个元素临时标识该元素所在列是否有0，0列数组的每个元素临时标识该元素所在行是否有0。
+2、判断每行的第0列是否为0，有则赋值额外的标识字段，该字段的作用是用于后续对称遍历的时候，赋值所有行的0列是否应该赋值0使用
+
+```
+比如原始数组为
+[
+	[2,1,2,3],
+	[2,1,2,3],
+	[3,0,5,2],
+	[1,3,0,5]
+]
+
+
+// 如果当前遍历位置为0，则该行0列设置标识，以便后续使用
+// 如果当前遍历位置为0，则0行该列设置标识，以便后续使用
+[
+    [2,0,0,3],
+    [2,1,2,3],
+    [0,0,5,2],
+    [0,3,0,5]
+]
+// 第二次循环-从右下角遍历处理：行从最后一行遍历（直到0行），列从最后一列遍历(直到第一列)
+// 使用0行数组、0列数组判断当前遍历位置是否应该置0
+// 注意需要额外使用标识字段判断该行0列是否应该置0
+// 处理完成之后
+[
+    [2,0,0,3],
+    [2,0,0,3],
+    [0,0,0,0],
+    [0,0,0,0]
+]
+
+```
+
+
+```java
+
+class Solution {
+    public void setZeroes(int[][] matrix) {
+        int row = matrix.length;
+        int col = matrix[0].length;
+        boolean row0_flag = false;
+        boolean col0_flag = false;
+        // 第一行是否有零
+        for (int j = 0; j < col; j++) {
+            if (matrix[0][j] == 0) {
+                row0_flag = true;
+                break;
+            }
+        }
+        // 第一列是否有零
+        for (int i = 0; i < row; i++) {
+            if (matrix[i][0] == 0) {
+                col0_flag = true;
+                break;
+            }
+        }
+        // 把第一行第一列作为标志位
+        for (int i = 1; i < row; i++) {
+            for (int j = 1; j < col; j++) {
+                if (matrix[i][j] == 0) {
+                    matrix[i][0] = matrix[0][j] = 0;
+                }
+            }
+        }
+        // 置0
+        for (int i = 1; i < row; i++) {
+            for (int j = 1; j < col; j++) {
+                if (matrix[i][0] == 0 || matrix[0][j] == 0) {
+                    matrix[i][j] = 0;
+                }
+            }
+        }
+        if (row0_flag) {
+            for (int j = 0; j < col; j++) {
+                matrix[0][j] = 0;
+            }
+        }
+        if (col0_flag) {
+            for (int i = 0; i < row; i++) {
+                matrix[i][0] = 0;
+            }
+        } 
+    }
+}
+```
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/38.\347\224\237\345\221\275\346\270\270\346\210\217.md" "b/Algorithm/38.\347\224\237\345\221\275\346\270\270\346\210\217.md"
new file mode 100644
index 00000000..f2e79bb5
--- /dev/null
+++ "b/Algorithm/38.\347\224\237\345\221\275\346\270\270\346\210\217.md"
@@ -0,0 +1,137 @@
+38.生命游戏
+===
+
+
+### 题目
+
+
+生命游戏，简称为 生命 ，是英国数学家约翰·何顿·康威在 1970 年发明的细胞自动机。    
+
+给定一个包含 m × n 个格子的面板，每一个格子都可以看成是一个细胞。每个细胞都具有一个初始状态： 1 即为 活细胞 （live），或 0 即为 死细胞 （dead）。每个细胞与其八个相邻位置（水平，垂直，对角线）的细胞都遵循以下四条生存定律:    
+
+- 如果活细胞周围八个位置的活细胞数少于两个，则该位置活细胞死亡；
+- 如果活细胞周围八个位置有两个或三个活细胞，则该位置活细胞仍然存活；
+- 如果活细胞周围八个位置有超过三个活细胞，则该位置活细胞死亡；
+- 如果死细胞周围正好有三个活细胞，则该位置死细胞复活；
+
+下一个状态是通过将上述规则同时应用于当前状态下的每个细胞所形成的，其中细胞的出生和死亡是 同时 发生的。给你 m x n 网格面板 board 的当前状态，返回下一个状态。
+
+给定当前 board 的状态，更新 board 到下一个状态。
+
+注意 你不需要返回任何东西。
+
+
+示例1:   
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_gameOfLife_1.jpg?raw=true)
+
+- 输入：board = [[0,1,0],[0,0,1],[1,1,1],[0,0,0]]
+- 输出：[[0,0,0],[1,0,1],[0,1,1],[0,1,0]]
+
+
+示例2:   
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_gameOfLife_1.jpg?raw=true)
+
+- 输入：board = [[1,1],[1,0]]
+- 输出：[[1,1],[1,1]]
+
+
+提示：
+
+- m == board.length
+- n == board[i].length
+- 1 <= m, n <= 25
+- board[i][j] 为 0 或 1
+
+
+进阶：
+
+你可以使用原地算法解决本题吗？请注意，面板上所有格子需要同时被更新：你不能先更新某些格子，然后使用它们的更新后的值再更新其他格子。
+本题中，我们使用二维数组来表示面板。原则上，面板是无限的，但当活细胞侵占了面板边界时会造成问题。你将如何解决这些问题？
+
+
+### 思路
+
+简化规则:     
+1. 原来是活的，周围有2-3个活的，成为活的
+2. 原来是死的，周围有3个活的，成为活的
+3. 其他都是死了
+
+这道题主要就是模拟，遍历每一个格子，然后统计其周围八个格子的活细胞个数，来看这个格子的状态是否改变。
+但难点在于：如果这个格子的状态改变，不能直接改变。这样会影响后面格子的统计。即题目中说的：你不能先更新某些格子，然后使用它们的更新后的值再更新其他格子。
+
+因此我们需要使用特殊值去标记发生改变的格子，从而根据特殊值可以知道这个格子原状态是什么，要更新的状态是什么。
+
+
+- 可以使用 2表示活细胞变成死细胞，3表示死细胞变成活细胞。【这样的好处是最终是死细胞的都是偶数，活细胞的都是奇数，模2即结果；】
+
+也可以用下面的方式:       
+
+- 由于每个位置的细胞的状态是取决于当前四周其他状态的，而且每个细胞的状态是同时变化的，所以不能一个一个地更新，只能在一个新的数组里创建新的状态。
+
+- 当然上面所说的也不是绝对的，因为这道题目的输入是int[][]，矩阵是 int 类型的，有 32 位，而状态只有 0,1 两种，只需一位且只有最低位用上了，我们用其他位存储下一个状态即可，相当于用原矩阵当一个复制的矩阵。   
+
+- 所以可以，原有的最低位存储的是当前状态，那倒数第二低位存储下一个状态就行了。
+
+
+```java
+class Solution {
+    public void gameOfLife(int[][] board) {
+        int m = board.length;       // 行数
+        int n = board[0].length;    // 列数
+        int count = 0;              // 统计每个格子周围八个位置的活细胞数
+        for(int i = 0; i < m; i++){
+            for(int j = 0; j < n; j++){
+                count = 0;      // 每个格子计数重置为0
+                for(int x = -1; x <= 1; x++){ // -1 0 1 分别代表当前位置左边的格子、当前格子、当前位置右边的格子
+                    for(int y = -1; y <= 1; y++){ // -1 0 1 分别代表当前位置下边的格子、当前格子、当前位置上边的格子
+                        // 枚举周围八个位置，其中去掉本身（x = y = 0）和越界(靠近边缘)的情况
+                        if((x == 0 && y == 0) || i + x < 0 || i + x >= m || j + y < 0 || j + y >= n)continue;
+                        // 如果周围格子是活细胞（1）或者是活细胞变死细胞（2）的，都算一个活细胞
+                        if(board[i + x][j + y] == 1 || board[i + x][j + y] == 2) {
+                        	count++; 
+                        }
+                    }
+                }
+
+                if(board[i][j] == 1 && (count < 2 || count > 3)) {
+                	board[i][j] = 2;    // 格子本身是活细胞，周围满足变成死细胞的条件，标记为2
+            	}
+
+                if(board[i][j] == 0 && count == 3) {
+                	board[i][j] = 3;      // 格子本身是死细胞，周围满足复活条件，标记为3
+                }
+            }
+        }
+
+        for(int i = 0; i < m; i++){
+            for(int j = 0; j < n; j++){
+                // 死细胞为0，活细胞变成死细胞为2，都为偶数，模2为0，刚好是死细胞
+                // 活细胞为1，死细胞变成活细胞为3，都为奇数，模2为1，刚好是活细胞
+                board[i][j] %= 2;
+            }
+        }
+    }
+}
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/39.\350\265\216\351\207\221\344\277\241.md" "b/Algorithm/39.\350\265\216\351\207\221\344\277\241.md"
new file mode 100644
index 00000000..63cff051
--- /dev/null
+++ "b/Algorithm/39.\350\265\216\351\207\221\344\277\241.md"
@@ -0,0 +1,97 @@
+39.赎金信
+===
+
+
+### 题目
+
+
+给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成。     
+
+如果可以，返回 true ；否则返回 false 。     
+
+magazine 中的每个字符只能在 ransomNote 中使用一次。   
+
+ 
+
+示例 1:   
+
+- 输入：ransomNote = "a", magazine = "b"
+- 输出：false
+
+示例 2:     
+
+- 输入：ransomNote = "aa", magazine = "ab"
+- 输出：false
+
+示例 3:    
+
+- 输入：ransomNote = "aa", magazine = "aab"
+- 输出：true
+ 
+
+提示:    
+
+- 1 <= ransomNote.length, magazine.length <= 105
+- ransomNote 和 magazine 由小写英文字母组成
+
+
+### 思路
+
+用hash表还是一个大小为26的数组，记录26个单词每一个出现的次数
+
+```java
+class Solution {
+    public boolean canConstruct(String ransomNote, String magazine) {
+        //记录杂志字符串出现的次数
+        int[] arr = new int[26];
+        int temp;
+        for (int i = 0; i < magazine.length(); i++) {
+            temp = magazine.charAt(i) - 'a';
+            arr[temp]++;
+        }
+        for (int i = 0; i < ransomNote.length(); i++) {
+            temp = ransomNote.charAt(i) - 'a';
+            //对于金信中的每一个字符都在数组中查找
+            //找到相应位减一，否则找不到返回false
+            if (arr[temp] > 0) {
+                arr[temp]--;
+            } else {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+```
+
+
+```python
+class Solution:
+    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
+        if len(ransomNote) > len(magazine):
+            return False
+
+        arr = [0] * 26
+        for i in magazine:
+            arr[ord(i) -ord('a')] += 1
+
+        for i in ransomNote:
+            index = ord(i) - ord('a')
+            arr[index] -= 1
+            if arr[index] < 0:
+                return False
+
+        return True
+```
+
+
+复杂度:   
+
+- 时间复杂度: O(N)
+- 空间复杂度: O(1)
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/40.\345\220\214\346\236\204\345\255\227\347\254\246\344\270\262.md" "b/Algorithm/40.\345\220\214\346\236\204\345\255\227\347\254\246\344\270\262.md"
new file mode 100644
index 00000000..aa801292
--- /dev/null
+++ "b/Algorithm/40.\345\220\214\346\236\204\345\255\227\347\254\246\344\270\262.md"
@@ -0,0 +1,98 @@
+40.同构字符串
+===
+
+
+### 题目
+
+给定两个字符串 s 和 t ，判断它们是否是同构的。
+
+如果 s 中的字符可以按某种映射关系替换得到 t ，那么这两个字符串是同构的。
+
+每个出现的字符都应当映射到另一个字符，同时不改变字符的顺序。不同字符不能映射到同一个字符上，相同字符只能映射到同一个字符上，字符可以映射到自己本身。
+
+ 
+
+示例 1:   
+
+- 输入：s = "egg", t = "add"
+- 输出：true
+
+示例 2:   
+
+- 输入：s = "foo", t = "bar"
+- 输出：false
+
+示例 3:   
+
+- 输入：s = "paper", t = "title"
+- 输出：true
+ 
+
+提示:    
+
+- 1 <= s.length <= 5 * 104
+- t.length == s.length
+- s 和 t 由任意有效的 ASCII 字符组成
+
+### 思路
+
+
+
+
+- “每个出现的字符都应当映射到另一个字符”。代表字符集合 s , t 之间是「满射」。
+- “相同字符只能映射到同一个字符上，不同字符不能映射到同一个字符上”。代表字符集合 s , t 之间是「单射」。
+- 因此， s 和 t 之间是「双射」，满足一一对应。考虑遍历字符串，使用哈希表 s2t , t2s 分别记录 s→t , t→s 的映射，当发现任意「一对多」的关系时返回 false 即可。
+
+
+```java
+
+class Solution {
+    public boolean isIsomorphic(String s, String t) {
+        Map<Character, Character> s2t = new HashMap<>(), t2s = new HashMap<>();
+        for (int i = 0; i < s.length(); i++) {
+            char a = s.charAt(i), b = t.charAt(i);
+            // 对于已有映射 a -> s2t[a]，若和当前字符映射 a -> b 不匹配，
+            // 说明有一对多的映射关系，则返回 false ；
+            // 对于映射 b -> a 也同理
+            if (s2t.containsKey(a) && s2t.get(a) != b || 
+                t2s.containsKey(b) && t2s.get(b) != a) {
+                return false;
+            }
+            s2t.put(a, b);
+            t2s.put(b, a);
+        }
+        return true;
+    }
+}
+```
+
+
+```python
+class Solution:
+    def isIsomorphic(self, s: str, t: str) -> bool:
+        s2t = {}
+        t2s = {}
+
+        for i in range(len(s)):
+            a = s[i]
+            b = t[i]
+
+            if (a in s2t and s2t.get(a) != b) or (b in t2s and t2s.get(b) != a):
+                return False
+            s2t[a] = b
+            t2s[b] = a
+
+        return True
+```
+
+复杂度分析:    
+
+- 时间复杂度 O(N) : 其中 N 为字符串 s , t 的长度。遍历字符串 s , t 使用线性时间，hashmap 查询操作使用 O(1) 时间。
+- 空间复杂度 O(1) : 题目说明 s 和 t 由任意有效的 ASCII 字符组成。由于 ASCII 字符共 128 个，因此 hashmap s2t , t2s 使用 O(128)=O(1) 空间。
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/41.\345\215\225\350\257\215\350\247\204\345\276\213.md" "b/Algorithm/41.\345\215\225\350\257\215\350\247\204\345\276\213.md"
new file mode 100644
index 00000000..33cae539
--- /dev/null
+++ "b/Algorithm/41.\345\215\225\350\257\215\350\247\204\345\276\213.md"
@@ -0,0 +1,114 @@
+41.单词规律
+===
+
+
+### 题目
+
+给定一种规律pattern和一个字符串s，判断s是否遵循相同的规律。
+
+这里的遵循指完全匹配，例如，pattern里的每个字母和字符串s中的每个非空单词之间存在着双向连接的对应规律。     
+
+ 
+
+示例1:    
+
+- 输入: pattern = "abba", s = "dog cat cat dog"
+- 输出: true
+
+示例 2:   
+
+- 输入:pattern = "abba", s = "dog cat cat fish"
+- 输出: false
+
+示例 3:     
+
+- 输入: pattern = "aaaa", s = "dog cat cat dog"
+- 输出: false
+ 
+
+提示:      
+
+- 1 <= pattern.length <= 300
+- pattern 只包含小写英文字母
+- 1 <= s.length <= 3000
+- s 只包含小写英文字母和 ' '
+- s 不包含 任何前导或尾随对空格
+- s 中每个单词都被 单个空格 分隔
+
+
+### 思路
+
+和上一题的思路完全一样，由字符之间的一一映射升级成了字符与字符串之间的一一映射。
+首先本质是一样的，要实现一一映射，就要用到两个哈希表分别记录字符到字符串的映射和字符串到字符的映射。
+其次，我们要对s中的单词进行提取，比较单词数量和pattern中的数量是否一致，如果数量上不一致，二者一定不匹配；
+
+
+
+```java
+
+class Solution {
+    public boolean wordPattern(String pattern, String s) {
+        Map<Character, String> p2s = new HashMap<>();   // pattern中的字符到s中的字符子串的映射表
+        Map<String, Character> s2p = new HashMap<>();   // s中的字符字串到pattern中的字符的映射表
+        String[] words = s.split(" ");                  // 根据空格，提取s中的单词
+        int n = pattern.length();
+        int m = words.length;
+        if(n != m){
+            return false;   // 字符数和单词数不一致，一定不匹配
+        }
+        char ch;
+        String word;
+        for(int i = 0; i < n; i++){
+            ch = pattern.charAt(i);
+            word = words[i];
+            if((p2s.containsKey(ch) && !p2s.get(ch).equals(word)) || (s2p.containsKey(word) && s2p.get(word) != ch)){
+                // 字符与单词没有一一映射：即字符记录的映射不是当前单词或单词记录的映射不是当前字符
+                return false;
+            }
+            // 更新映射，已存在的映射更新后仍然是不变的；不存在的映射将被加入
+            p2s.put(ch, word);
+            s2p.put(word, ch);
+        }
+        return true;
+    }
+}
+```
+
+
+```python
+
+class Solution:
+    def wordPattern(self, pattern: str, s: str) -> bool:
+        words = s.split(' ')
+        length = len(words)
+        if length != len(pattern):
+            return False
+
+        p2s = {}
+        s2p = {}
+
+        for i in range(length):
+            word = words[i]
+            p = pattern[i]
+
+            if (word in s2p and s2p[word] != p) or (p in p2s and p2s[p] != word):
+                return False
+
+            p2s[p] = word
+            s2p[word] = p
+
+        return True
+```
+
+复杂度分析:     
+
+- 时间复杂度：O(n+m)，其中 n 为 pattern 的长度，m 为 str 的长度。插入和查询哈希表的均摊时间复杂度均为 O(n+m)。每一个字符至多只被遍历一次。
+
+- 空间复杂度：O(n+m)，其中 n 为 pattern 的长度，m 为 str 的长度。最坏情况下，我们需要存储 pattern 中的每一个字符和 str 中的每一个字符串。
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/42.\346\234\211\346\225\210\347\232\204\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215.md" "b/Algorithm/42.\346\234\211\346\225\210\347\232\204\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215.md"
new file mode 100644
index 00000000..b72a4c92
--- /dev/null
+++ "b/Algorithm/42.\346\234\211\346\225\210\347\232\204\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215.md"
@@ -0,0 +1,194 @@
+42.有效的字母异位词
+===
+
+
+### 题目
+
+给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的 字母异位词。
+
+ 
+
+示例 1:     
+
+- 输入: s = "anagram", t = "nagaram"
+- 输出: true
+
+示例 2:   
+
+- 输入: s = "rat", t = "car"
+- 输出: false
+ 
+
+提示:   
+
+- 1 <= s.length, t.length <= 5 * 104
+- s 和 t 仅包含小写字母
+ 
+
+进阶: 如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？
+
+
+### 思路
+
+设两字符串 s 
+1
+​	
+  , s 
+2
+​	
+  ，则两者互为重排的「充要条件」为：两字符串 s 
+1
+​	
+  , s 
+2
+​	
+  包含的字符是一致的，即 s 
+1
+​	
+  , s 
+2
+​	
+  所有对应字符数量都相同，仅排列顺序不同。
+
+根据以上分析，可借助「哈希表」分别统计 s 
+1
+​	
+  , s 
+2
+​	
+  中各字符数量 key: 字符, value: 数量 ，分为以下情况：
+
+若 s 
+1
+​	
+  , s 
+2
+​	
+  字符串长度不相等，则「不互为重排」；
+若 s 
+1
+​	
+  , s 
+2
+​	
+  某对应字符数量不同，则「不互为重排」；
+否则，若 s 
+1
+​	
+  , s 
+2
+​	
+  所有对应字符数量都相同，则「互为重排」；
+具体上看，我们可以统计 s 
+1
+​	
+  各字符时执行 +1 ，统计 s 
+2
+​	
+  各字符时 −1 。若两字符串互为重排，则最终哈希表中所有字符统计数值都应为 0 。
+
+作者：Krahets
+链接：https://leetcode.cn/problems/valid-anagram/solutions/2362065/242-you-xiao-de-zi-mu-yi-wei-ci-ha-xi-bi-cch7/
+来源：力扣（LeetCode）
+著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
+
+```java
+class Solution {
+    public boolean isAnagram(String s, String t) {
+        int len1 = s.length(), len2 = t.length();
+        if (len1 != len2)
+            return false;
+        HashMap<Character, Integer> dic = new HashMap<>();
+        for (int i = 0; i < len1; i++) {
+            dic.put(s.charAt(i) , dic.getOrDefault(s.charAt(i), 0) + 1);
+        }
+        for (int i = 0; i < len2; i++) {
+            dic.put(t.charAt(i) , dic.getOrDefault(t.charAt(i), 0) - 1);
+        }
+        for (int val : dic.values()) {
+            if (val != 0)
+                return false;
+        }
+        return true;
+    }
+}
+```
+
+
+```python
+class Solution:
+    def isAnagram(self, s: str, t: str) -> bool:
+        if len(s) != len(t):
+            return False
+        dic = defaultdict(int)
+        for c in s:
+            dic[c] += 1
+        for c in t:
+            dic[c] -= 1
+        for val in dic.values():
+            if val != 0:
+                return False
+        return True
+```
+
+
+复杂度分析:    
+
+- 时间复杂度 O(M+N) ： 其 M , N 分别为字符串 s1, s2长度。当 s1, s2无相同字符时，三轮循环的总迭代次数最多为 2M+2N ，使用 O(M+N) 线性时间。
+
+- 空间复杂度 O(1) ： 由于字符种类是有限的（常量），一般 ASCII 码共包含 128 个字符，因此可假设使用 O(1) 大小的额外空间。
+
+
+对于进阶问题，Unicode 是为了解决传统字符编码的局限性而产生的方案，它为每个语言中的字符规定了一个唯一的二进制编码。而 Unicode 中可能存在一个字符对应多个字节的问题，为了让计算机知道多少字节表示一个字符，面向传输的编码方式的 UTF−8 和 UTF−16 也随之诞生逐渐广泛使用，具体相关的知识读者可以继续查阅相关资料拓展视野，这里不再展开。
+
+回到本题，进阶问题的核心点在于「字符是离散未知的」，因此我们用哈希表维护对应字符的频次即可。同时读者需要注意 Unicode 一个字符可能对应多个字节的问题，不同语言对于字符串读取处理的方式是不同的。
+
+
+
+```java
+
+class Solution {
+    public boolean isAnagram(String s, String t) {
+        if (s.length() != t.length()) {
+            return false;
+        }
+        Map<Character, Integer> table = new HashMap<Character, Integer>();
+        for (int i = 0; i < s.length(); i++) {
+            char ch = s.charAt(i);
+            table.put(ch, table.getOrDefault(ch, 0) + 1);
+        }
+        for (int i = 0; i < t.length(); i++) {
+            char ch = t.charAt(i);
+            table.put(ch, table.getOrDefault(ch, 0) - 1);
+            if (table.get(ch) < 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+
+作者：力扣官方题解
+链接：https://leetcode.cn/problems/valid-anagram/solutions/493231/you-xiao-de-zi-mu-yi-wei-ci-by-leetcode-solution/
+来源：力扣（LeetCode）
+著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
+```
+
+复杂度分析
+
+时间复杂度：O(n)，其中 n 为 s 的长度。
+
+空间复杂度：O(S)，其中 S 为字符集大小，此处 S=26。
+
+
+
+class Solution:
+    def isAnagram(self, s: str, t: str) -> bool:
+        return Counter(s) == Counter(t)
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/43.\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215\345\210\206\347\273\204.md" "b/Algorithm/43.\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215\345\210\206\347\273\204.md"
new file mode 100644
index 00000000..69eee016
--- /dev/null
+++ "b/Algorithm/43.\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215\345\210\206\347\273\204.md"
@@ -0,0 +1,118 @@
+43.字母异位词分组
+===
+
+
+### 题目
+
+给你一个字符串数组，请你将 字母异位词(字母异位词是通过重新排列不同单词或短语的字母而形成的单词或短语，并使用所有原字母一次) 组合在一起。可以按任意顺序返回结果列表。
+
+ 
+
+示例 1:
+
+输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
+
+输出: [["bat"],["nat","tan"],["ate","eat","tea"]]
+
+解释:    
+
+- 在 strs 中没有字符串可以通过重新排列来形成 "bat"。
+- 字符串 "nat" 和 "tan" 是字母异位词，因为它们可以重新排列以形成彼此。
+- 字符串 "ate" ，"eat" 和 "tea" 是字母异位词，因为它们可以重新排列以形成彼此。
+
+示例 2:    
+
+- 输入: strs = [""]
+
+- 输出: [[""]]
+
+示例 3:    
+
+- 输入: strs = ["a"]
+
+- 输出: [["a"]]
+
+ 
+
+提示:    
+
+- 1 <= strs.length <= 104
+- 0 <= strs[i].length <= 100
+- strs[i] 仅包含小写字母
+
+### 思路
+
+##### 方法一: 排序
+
+由于互为字母异位词的两个字符串包含的字母相同，因此对两个字符串分别进行排序之后得到的字符串一定是相同的，故可以将排序之后的字符串作为哈希表的键。
+
+```java
+class Solution {
+    public List<List<String>> groupAnagrams(String[] strs) {
+        Map<String, List<String>> map = new HashMap<String, List<String>>();
+        for (String str : strs) {
+            char[] array = str.toCharArray();
+            Arrays.sort(array);
+            String key = new String(array);
+            List<String> list = map.getOrDefault(key, new ArrayList<String>());
+            list.add(str);
+            map.put(key, list);
+        }
+        return new ArrayList<List<String>>(map.values());
+    }
+}
+```
+
+复杂度分析
+
+- 时间复杂度：O(nklogk)，其中 n 是 strs 中的字符串的数量，k 是 strs 中的字符串的的最大长度。需要遍历 n 个字符串，对于每个字符串，需要 O(klogk) 的时间进行排序以及 O(1) 的时间更新哈希表，因此总时间复杂度是 O(nklogk)。
+
+- 空间复杂度：O(nk)，其中 n 是 strs 中的字符串的数量，k 是 strs 中的字符串的的最大长度。需要用哈希表存储全部字符串。
+
+##### 方法二: 计数
+
+- 由于互为字母异位词的两个字符串包含的字母相同，因此两个字符串中的相同字母出现的次数一定是相同的
+- 所以可以将每个字母出现的次数使用字符串表示，作为哈希表的键
+
+```java
+
+class Solution {
+    public List<List<String>> groupAnagrams(String[] strs) {
+        Map<String, List<String>> map = new HashMap<String, List<String>>();
+        for (String str : strs) {
+            int[] counts = new int[26];
+            int length = str.length();
+            for (int i = 0; i < length; i++) {
+                counts[str.charAt(i) - 'a']++;
+            }
+            // 将每个出现次数大于 0 的字母和出现次数按顺序拼接成字符串，作为哈希表的键
+            StringBuffer sb = new StringBuffer();
+            for (int i = 0; i < 26; i++) {
+                if (counts[i] != 0) {
+                    sb.append((char) ('a' + i));
+                    sb.append(counts[i]);
+                }
+            }
+            String key = sb.toString();
+            List<String> list = map.getOrDefault(key, new ArrayList<String>());
+            list.add(str);
+            map.put(key, list);
+        }
+        return new ArrayList<List<String>>(map.values());
+    }
+}
+```
+
+
+复杂度分析:    
+
+- 时间复杂度：O(nk))，其中 n 是 strs 中的字符串的数量，k 是 strs 中的字符串的的最大长度.
+
+- 空间复杂度：O(nk))，其中 n 是 strs 中的字符串的数量，k 是 strs 中的字符串的最大长度.
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/44.\344\270\244\346\225\260\344\271\213\345\222\214.md" "b/Algorithm/44.\344\270\244\346\225\260\344\271\213\345\222\214.md"
new file mode 100644
index 00000000..9e1fba5d
--- /dev/null
+++ "b/Algorithm/44.\344\270\244\346\225\260\344\271\213\345\222\214.md"
@@ -0,0 +1,121 @@
+44.两数之和
+===
+
+
+### 题目
+
+给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。
+
+你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。
+
+你可以按任意顺序返回答案。
+
+ 
+
+示例 1:    
+
+- 输入：nums = [2,7,11,15], target = 9
+- 输出：[0,1]
+- 解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
+
+示例 2:    
+
+- 输入：nums = [3,2,4], target = 6
+- 输出：[1,2]
+
+示例 3:   
+
+- 输入：nums = [3,3], target = 6
+- 输出：[0,1]
+ 
+
+提示:   
+
+- 2 <= nums.length <= 104
+- -109 <= nums[i] <= 109
+- -109 <= target <= 109
+- 只会存在一个有效答案
+ 
+
+进阶：你可以想出一个时间复杂度小于 O(n2) 的算法吗？
+
+
+
+### 思路
+
+这道题本身如果通过暴力遍历的话也是很容易解决的，时间复杂度在 O(n²)
+
+##### 方法一：暴力枚举
+
+
+最容易想到的方法是枚举数组中的每一个数 x，寻找数组中是否存在 target - x。
+
+```java
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        int n = nums.length;
+        for (int i = 0; i < n; ++i) {
+            for (int j = i + 1; j < n; ++j) {
+                if (nums[i] + nums[j] == target) {
+                    return new int[]{i, j};
+                }
+            }
+        }
+        return new int[0];
+    }
+}
+```
+
+复杂度分析:    
+
+- 时间复杂度：O(N²)，其中 N 是数组中的元素数量。最坏情况下数组中任意两个数都要被匹配一次。
+
+- 空间复杂度：O(1)。
+
+
+##### 方法二: 哈希表
+
+
+- 注意到方法一的时间复杂度较高的原因是寻找 target - x 的时间复杂度过高。       
+- 因此，我们需要一种更优秀的方法，能够快速寻找数组中是否存在目标元素。如果存在，我们需要找出它的索引。
+- 使用哈希表，可以将寻找 target - x 的时间复杂度降低到从 O(N) 降低到 O(1)。
+- 这样我们创建一个哈希表，对于每一个 x，我们首先查询哈希表中是否存在 target - x，然后将 x 插入到哈希表中，即可保证不会让 x 和自己匹配。
+
+
+```java
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for(int i = 0; i< nums.length; i++) {
+            if(map.containsKey(target - nums[i])) {
+                return new int[] {map.get(target-nums[i]),i};
+            }
+            map.put(nums[i], i);
+        }
+        throw new IllegalArgumentException("No two sum solution");
+    }
+}
+```
+
+```python
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        hashTable = dict()
+        for i, num in enumerate(nums):
+            if target - num in hashTable:
+                return [hashTable[target-num], i]
+            hashTable[nums[i]] = i
+        return []
+```
+
+复杂度分析:    
+
+- 时间复杂度：O(N)，其中 N 是数组中的元素数量。对于每一个元素 x，我们可以 O(1) 地寻找 target - x。
+
+- 空间复杂度：O(N)，其中 N 是数组中的元素数量。主要为哈希表的开销。
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/45.\345\277\253\344\271\220\346\225\260.md" "b/Algorithm/45.\345\277\253\344\271\220\346\225\260.md"
new file mode 100644
index 00000000..bd557384
--- /dev/null
+++ "b/Algorithm/45.\345\277\253\344\271\220\346\225\260.md"
@@ -0,0 +1,198 @@
+45.快乐数
+===
+
+
+### 题目
+
+编写一个算法来判断一个数 n 是不是快乐数。
+
+「快乐数」 定义为:     
+
+- 对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和。
+- 然后重复这个过程直到这个数变为 1，也可能是 无限循环 但始终变不到 1。
+- 如果这个过程 结果为 1，那么这个数就是快乐数。
+- 如果 n 是 快乐数 就返回 true ；不是，则返回 false 。
+
+ 
+
+示例 1:    
+
+- 输入：n = 19
+- 输出：true
+
+- 解释:     
+    - 1² + 9² = 82
+    - 8² + 2² = 68
+    - 6² + 8² = 100
+    - 1² + 0² + 0² = 1
+
+示例 2:    
+
+- 输入：n = 2
+- 输出：false
+ 
+
+提示:    
+
+- 1 <= n <= 231 - 1
+
+
+### 思路
+
+- 快乐数的定义是基于一个计算过程，即对一个正整数，不断将其替换为它各个位上数字的平方和，如果最终这个过程能够收敛到1，则这个数被称为快乐数。    
+
+- 相反，如果在这个过程中形成了一个不包含1的循环，则该数不是快乐数。    
+
+- 对于非快乐数，它们的平方和序列会进入一个固定的循环，例如4 → 16 → 37 → 58 → 89 → 145 → 42 → 20 → 4。
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_happy_1.png?raw=true)
+
+根据我们的探索，我们猜测会有以下三种可能:    
+
+- 最终会得到 1。
+- 最终会进入循环。
+- 值会越来越大，最后接近无穷大(不会发生，因为假设9999999999999，那他每个位置的数值平方相加后的值是1053，再往后循环只会越来越小)。
+
+
+第三个情况比较难以检测和处理。我们怎么知道它会继续变大，而不是最终得到 1 呢？我们可以仔细想一想，每一位数的最大数字的下一位数是多少。
+
+| 位数   | 最大值        | Next |
+|--------|----------------|------|
+| 1      | 9              | 81   |
+| 2      | 99             | 162  |
+| 3      | 999            | 243  |
+| 4      | 9999           | 324  |
+| 13     | 9999999999999  | 1053 |
+
+
+- 对于 3 位数的数字，它不可能大于 243。这意味着它要么被困在 243 以下的循环内，要么跌到 1。
+
+- 4 位或 4 位以上的数字在每一步都会丢失一位，直到降到 3 位为止。
+
+- 所以我们知道，最坏的情况下，算法可能会在 243 以下的所有数字上循环，然后回到它已经到过的一个循环或者回到 1。但它不会无限期地进行下去，所以我们排除第三种选择。
+
+
+
+##### 方法一：哈希表检测
+
+所以这道题的解法主要是两部分:   
+
+- 按照题目的要求做数位分离，求平方和。
+
+- 使用哈希集合完成。每次生成链中的下一个数字时，我们都会检查它是否已经在哈希集合中。
+
+    - 如果它不在哈希集合中，我们应该添加它。     
+    - 如果它在哈希集合中，这意味着我们处于一个循环中，因此应该返回 false。
+
+
+
+```java
+class Solution {
+    private int getNext(int n) {
+        int totalSum = 0;
+        while (n > 0) {
+            int d = n % 10;
+            n = n / 10;
+            totalSum += d * d;
+        }
+        return totalSum;
+    }
+
+    public boolean isHappy(int n) {
+        Set<Integer> seen = new HashSet<>();
+        while (n != 1 && !seen.contains(n)) {
+            seen.add(n);
+            n = getNext(n);
+        }
+        return n == 1;
+    }
+}
+```
+
+
+- 时间复杂度: O(Logn)
+- 空间复杂度: O(Logn)
+
+##### 方法二：快慢指针法
+
+通过反复调用 getNext(n) 得到的链是一个隐式的链表。隐式意味着我们没有实际的链表节点和指针，但数据仍然形成链表结构。起始数字是链表的头 “节点”，链中的所有其他数字都是节点。next 指针是通过调用 getNext(n) 函数获得。
+
+意识到我们实际有个链表，那么这个问题就可以转换为检测一个链表是否有环。因此我们在这里可以使用弗洛伊德循环查找算法。这个算法是两个奔跑选手，一个跑的快，一个跑得慢。在龟兔赛跑的寓言中，跑的慢的称为 “乌龟”，跑得快的称为 “兔子”。
+
+不管乌龟和兔子在循环中从哪里开始，它们最终都会相遇。这是因为兔子每走一步就向乌龟靠近一个节点（在它们的移动方向上）。
+
+```java
+class Solution {
+
+     public int getNext(int n) {
+        int totalSum = 0;
+        while (n > 0) {
+            int d = n % 10;
+            n = n / 10;
+            totalSum += d * d;
+        }
+        return totalSum;
+    }
+
+    public boolean isHappy(int n) {
+        int slowRunner = n;
+        int fastRunner = getNext(n);
+        while (fastRunner != 1 && slowRunner != fastRunner) {
+            slowRunner = getNext(slowRunner);
+            fastRunner = getNext(getNext(fastRunner));
+        }
+        return fastRunner == 1;
+    }
+}
+
+```
+
+复杂度分析:     
+
+- 时间复杂度：O(logn)。该分析建立在对前一种方法的分析的基础上，但是这次我们需要跟踪两个指针而不是一个指针来分析，以及在它们相遇前需要绕着这个循环走多少次。
+如果没有循环，那么快跑者将先到达 1，慢跑者将到达链表中的一半。我们知道最坏的情况下，成本是 O(2⋅logn)=O(logn)。       
+一旦两个指针都在循环中，在每个循环中，快跑者将离慢跑者更近一步。一旦快跑者落后慢跑者一步，他们就会在下一步相遇。假设循环中有 k 个数字。如果他们的起点是相隔 k−1 的位置（这是他们可以开始的最远的距离），那么快跑者需要 k−1 步才能到达慢跑者，这对于我们的目的来说也是不变的。因此，主操作仍然在计算起始 n 的下一个值，即 O(logn)。
+- 空间复杂度：O(1)，对于这种方法，我们不需要哈希集来检测循环。指针需要常数的额外空间。     
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/46.\345\255\230\345\234\250\351\207\215\345\244\215\345\205\203\347\264\240 II.md" "b/Algorithm/46.\345\255\230\345\234\250\351\207\215\345\244\215\345\205\203\347\264\240 II.md"
new file mode 100644
index 00000000..2051ee00
--- /dev/null
+++ "b/Algorithm/46.\345\255\230\345\234\250\351\207\215\345\244\215\345\205\203\347\264\240 II.md"	
@@ -0,0 +1,112 @@
+46.存在重复元素 II
+===
+
+
+### 题目
+
+给你一个整数数组 nums 和一个整数 k ，判断数组中是否存在两个 不同的索引 i 和 j ，满足 nums[i] == nums[j] 且 abs(i - j) <= k 。如果存在，返回 true ；否则，返回 false 。
+
+ 
+
+示例 1:    
+
+- 输入：nums = [1,2,3,1], k = 3
+- 输出：true
+
+示例 2:    
+
+- 输入：nums = [1,0,1,1], k = 1
+- 输出：true
+
+示例 3:      
+
+- 输入：nums = [1,2,3,1,2,3], k = 2
+- 输出：false
+ 
+
+ 
+
+提示:    
+
+- 1 <= nums.length <= 105
+- -109 <= nums[i] <= 109
+- 0 <= k <= 105
+
+
+### 思路
+
+##### 方法一: 哈希表
+
+```python
+class Solution:
+    def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
+        map = defaultdict()
+        for i, num in enumerate(nums):
+            if num in map:
+                m = map[num]
+                if i - m > k:
+                    return True
+            map[num] = i
+        return False
+```
+
+复杂度分析:    
+
+- 时间复杂度：O(n)
+- 空间复杂度：O(n)
+
+
+##### 方法二: 定长滑动窗口
+
+
+整理题意：是否存在长度不超过的 k+1 窗口，窗口内有相同元素。
+
+
+我们可以从前往后遍历 nums，同时使用 Set 记录遍历当前滑窗内出现过的元素。
+
+假设当前遍历的元素为 nums[i]：
+
+- 下标小于等于 k（起始滑窗长度还不足 k+1）：直接往滑窗加数，即将当前元素加入 Set 中；
+- 下标大于 k：将上一滑窗的左端点元素 nums[i−k−1] 移除，判断当前滑窗的右端点元素 nums[i] 是否存在 Set 中，若存在，返回 True，否则将当前元素 nums[i] 加入 Set 中。
+- 重复上述过程，若整个 nums 处理完后仍未找到，返回 False。
+
+```python
+class Solution:
+    def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
+        n = len(nums)
+        s = set()
+        for i in range(n):
+            if i > k:
+                s.remove(nums[i - k - 1])
+            if nums[i] in s:
+                return True
+            s.add(nums[i])
+        return False
+```
+
+```java
+class Solution {
+    public boolean containsNearbyDuplicate(int[] nums, int k) {
+        int n = nums.length;
+        Set<Integer> set = new HashSet<>();
+        for (int i = 0; i < n; i++) {
+            if (i > k) set.remove(nums[i - k - 1]);
+            if (set.contains(nums[i])) return true;
+            set.add(nums[i]);
+        }
+        return false;
+    }
+}
+```
+
+复杂度分析:    
+
+- 时间复杂度：O(n)
+- 空间复杂度：O(k)
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/47.\346\234\200\351\225\277\350\277\236\347\273\255\345\272\217\345\210\227.md" "b/Algorithm/47.\346\234\200\351\225\277\350\277\236\347\273\255\345\272\217\345\210\227.md"
new file mode 100644
index 00000000..0dd4b5f5
--- /dev/null
+++ "b/Algorithm/47.\346\234\200\351\225\277\350\277\236\347\273\255\345\272\217\345\210\227.md"
@@ -0,0 +1,133 @@
+47.最长连续序列
+===
+
+
+### 题目
+
+给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。
+
+请你设计并实现时间复杂度为 O(n) 的算法解决此问题。
+
+ 
+
+示例 1:    
+
+- 输入：nums = [100,4,200,1,3,2]
+- 输出：4
+- 解释：最长数字连续序列是 [1, 2, 3, 4]。它的长度为 4。
+
+示例 2:    
+
+- 输入：nums = [0,3,7,2,5,8,4,6,0,1]
+- 输出：9
+
+示例 3:    
+
+- 输入：nums = [1,0,1,2]
+- 输出：3
+ 
+
+提示:    
+
+- 0 <= nums.length <= 105
+- -109 <= nums[i] <= 109
+
+
+### 思路
+
+首先，本题是不能排序的，因为排序的时间复杂度是 O(nlogn)，不符合题目 O(n) 的要求。
+
+
+题解说的比较复杂，不太容易懂，简单来说就是每个数都判断一次这个数是不是连续序列的开头那个数。
+
+怎么判断呢，就是用哈希表查找这个数前面一个数是否存在，即num-1在序列中是否存在。
+
+为了做到 O(n) 的时间复杂度，需要两个关键优化:    
+
+- 把 nums 中的数都放入一个哈希集合中，这样可以 O(1) 判断数字是否在 nums 中。
+- 存在那这个数肯定不是开头，直接跳过。
+- 因此只需要对每个开头的数进行循环，直到这个序列不再连续，因此复杂度是O(n)。
+
+以题解中的序列举例:     
+[100，4，200，1，3，4，2]
+去重后的哈希序列为:      
+[100，4，200，1，3，2]
+
+按照上面逻辑进行判断:     
+
+- 元素100是开头,因为没有99，且以100开头的序列长度为1    
+- 元素4不是开头，因为有3存在，过
+- 元素200是开头，因为没有199，且以200开头的序列长度为1
+- 元素1是开头，因为没有0，且以1开头的序列长度为4，因为依次累加，2，3，4都存在。
+- 元素3不是开头，因为2存在，过，
+- 元素2不是开头，因为1存在，过。
+
+
+```java
+class Solution {
+    public int longestConsecutive(int[] nums) {
+        Set<Integer> num_set = new HashSet<Integer>();
+        for (int num : nums) {
+            num_set.add(num);
+        }
+
+        int longestStreak = 0;
+
+        for (int num : num_set) {
+            if (!num_set.contains(num - 1)) {
+                int currentNum = num;
+                int currentStreak = 1;
+
+                while (num_set.contains(currentNum + 1)) {
+                    currentNum += 1;
+                    currentStreak += 1;
+                }
+
+                longestStreak = Math.max(longestStreak, currentStreak);
+            }
+        }
+
+        return longestStreak;
+    }
+}
+```
+
+```python
+class Solution:
+    def longestConsecutive(self, nums: List[int]) -> int:
+        longest = 0
+        numSet = set(nums)
+
+        for num in numSet:
+            if num -1 not in numSet:
+                # 这就是开头，可以开始计数
+                currentNum = num
+                currentStreak = 1
+
+                while currentNum + 1 in numSet:
+                    currentNum += 1
+                    currentStreak += 1
+
+
+                longest = max(longest, currentStreak)
+
+        return longest
+```
+
+复杂度分析:    
+
+- 时间复杂度：O(n)，其中 n 为数组的长度。具体分析已在上面正文中给出。
+
+- 空间复杂度：O(n)。哈希表存储数组中所有的数需要 O(n) 的空间。
+
+
+
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/48.\346\261\207\346\200\273\345\214\272\351\227\264.md" "b/Algorithm/48.\346\261\207\346\200\273\345\214\272\351\227\264.md"
new file mode 100644
index 00000000..60983af9
--- /dev/null
+++ "b/Algorithm/48.\346\261\207\346\200\273\345\214\272\351\227\264.md"
@@ -0,0 +1,134 @@
+48.汇总区间
+===
+
+
+### 题目
+
+
+给定一个 无重复元素 的 有序 整数数组 nums 。     
+
+区间 [a,b] 是从 a 到 b（包含）的所有整数的集合。      
+
+返回 恰好覆盖数组中所有数字 的 最小有序 区间范围列表 。也就是说，nums 的每个元素都恰好被某个区间范围所覆盖，并且不存在属于某个区间但不属于 nums 的数字 x 。    
+
+列表中的每个区间范围 [a,b] 应该按如下格式输出:     
+
+- "a->b" ，如果 a != b
+- "a" ，如果 a == b
+ 
+
+示例 1:   
+
+- 输入：nums = [0,1,2,4,5,7]
+- 输出：["0->2","4->5","7"]
+
+解释：区间范围是:   
+- [0,2] --> "0->2"
+- [4,5] --> "4->5"
+- [7,7] --> "7"
+
+示例 2:    
+
+- 输入：nums = [0,2,3,4,6,8,9]
+- 输出：["0","2->4","6","8->9"]
+
+解释：区间范围是:     
+
+- [0,0] --> "0"
+- [2,4] --> "2->4"
+- [6,6] --> "6"
+- [8,9] --> "8->9"
+ 
+
+提示:    
+
+- 0 <= nums.length <= 20
+- -231 <= nums[i] <= 231 - 1
+- nums 中的所有值都 互不相同
+- nums 按升序排列
+
+
+### 思路
+
+
+- 我们从数组的位置 0 出发，向右遍历。     
+- 每次遇到相邻元素之间的差值大于 1 时，我们就找到了一个区间。遍历完数组之后，就能得到一系列的区间的列表。     
+- 在遍历过程中，维护下标low和high分别记录区间的起点和终点，对于任何区间都有`low≤high`。当得到一个区间时，根据`low`和`high`的值生成区间的字符串表示。     
+- 当`low<high`时，区间的字符串表示为`"low→high"`      
+- 当`low=high`时，区间的字符串表示为`"low"`     
+
+```java
+class Solution {
+    public List<String> summaryRanges(int[] nums) {
+        List<String> ret = new ArrayList<String>();
+        int i = 0;
+        int n = nums.length;
+        while (i < n) {
+            int low = i;
+            i++;
+            while (i < n && nums[i] == nums[i - 1] + 1) {
+                i++;
+            }
+            int high = i - 1;
+            StringBuffer temp = new StringBuffer(Integer.toString(nums[low]));
+            if (low < high) {
+                temp.append("->");
+                temp.append(Integer.toString(nums[high]));
+            }
+            ret.add(temp.toString());
+        }
+        return ret;
+    }
+}
+```
+
+
+```python
+class Solution:
+    def summaryRanges(self, nums: List[int]) -> List[str]:
+        def f(i: int, j: int) -> str:
+            return str(nums[i]) if i == j else f'{nums[i]}->{nums[j]}'
+
+        i = 0
+        n = len(nums)
+        ans = []
+        while i < n:
+            j = i
+            while j + 1 < n and nums[j + 1] == nums[j] + 1:
+                j += 1
+            ans.append(f(i, j))
+            i = j + 1
+        return ans
+```
+
+复杂度分析:     
+
+- 时间复杂度：O(n)，其中 n 为数组的长度。
+
+- 空间复杂度：O(1)。除了用于输出的空间外，额外使用的空间为常数。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/49.\345\220\210\345\271\266\345\214\272\351\227\264.md" "b/Algorithm/49.\345\220\210\345\271\266\345\214\272\351\227\264.md"
new file mode 100644
index 00000000..8040592e
--- /dev/null
+++ "b/Algorithm/49.\345\220\210\345\271\266\345\214\272\351\227\264.md"
@@ -0,0 +1,82 @@
+49.合并区间
+===
+
+
+### 题目
+
+以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。
+
+ 
+
+示例 1:    
+
+- 输入：intervals = [[2,6],[1,3],[8,10],[15,18]]
+- 输出：[[1,6],[8,10],[15,18]]
+- 解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
+
+示例 2:     
+
+- 输入：intervals = [[1,4],[4,5]]
+- 输出：[[1,5]]
+- 解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。
+ 
+
+提示:     
+
+- 1 <= intervals.length <= 104
+- intervals[i].length == 2
+- 0 <= starti <= endi <= 104
+
+
+### 思路
+
+如果我们按照区间的左端点排序，那么在排完序的列表中，可以合并的区间一定是连续的。如下图所示，标记为蓝色、黄色和绿色的区间分别可以合并成一个大区间，它们在排完序的列表中是连续的:    
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_merge_qujian_1.png?raw=true)
+
+- 我们用数组 merged 存储最终的答案。
+
+- 首先，我们将列表中的区间按照左端点升序排序。然后我们将第一个区间加入 merged 数组中，并按顺序依次考虑之后的每个区间：
+
+- 如果当前区间的左端点在数组 merged 中最后一个区间的右端点之后，那么它们不会重合，我们可以直接将这个区间加入数组 merged 的末尾；
+
+- 否则，它们重合，我们需要用当前区间的右端点更新数组 merged 中最后一个区间的右端点，将其置为二者的较大值。
+
+```java
+class Solution {
+    public int[][] merge(int[][] intervals) {
+        if (intervals.length == 0) {
+            return new int[0][2];
+        }
+        Arrays.sort(intervals, new Comparator<int[]>() {
+            public int compare(int[] interval1, int[] interval2) {
+                return interval1[0] - interval2[0];
+            }
+        });
+        List<int[]> merged = new ArrayList<int[]>();
+        for (int i = 0; i < intervals.length; ++i) {
+            int L = intervals[i][0], R = intervals[i][1];
+            if (merged.size() == 0 || merged.get(merged.size() - 1)[1] < L) {
+                merged.add(new int[]{L, R});
+            } else {
+                merged.get(merged.size() - 1)[1] = Math.max(merged.get(merged.size() - 1)[1], R);
+            }
+        }
+        return merged.toArray(new int[merged.size()][]);
+    }
+}
+```
+
+复杂度分析:     
+
+- 时间复杂度：O(nlogn)，其中 n 为区间的数量。除去排序的开销，我们只需要一次线性扫描，所以主要的时间开销是排序的 O(nlogn)。
+
+- 空间复杂度：O(logn)，其中 n 为区间的数量。这里计算的是存储答案之外，使用的额外空间。O(logn) 即为排序所需要的空间复杂度。
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/50.\346\217\222\345\205\245\345\214\272\351\227\264.md" "b/Algorithm/50.\346\217\222\345\205\245\345\214\272\351\227\264.md"
new file mode 100644
index 00000000..6fbe536e
--- /dev/null
+++ "b/Algorithm/50.\346\217\222\345\205\245\345\214\272\351\227\264.md"
@@ -0,0 +1,102 @@
+50.插入区间
+===
+
+
+### 题目
+
+给你一个 无重叠的 ，按照区间起始端点排序的区间列表 intervals，其中 intervals[i] = [starti, endi] 表示第 i 个区间的开始和结束，并且 intervals 按照 starti 升序排列。同样给定一个区间 newInterval = [start, end] 表示另一个区间的开始和结束。   
+
+在 intervals 中插入区间 newInterval，使得 intervals 依然按照 starti 升序排列，且区间之间不重叠（如果有必要的话，可以合并区间）。
+
+返回插入之后的 intervals。       
+
+注意 你不需要原地修改 intervals。你可以创建一个新数组然后返回它。     
+
+ 
+
+示例 1:    
+
+- 输入：intervals = [[1,3],[6,9]], newInterval = [2,5]
+- 输出：[[1,5],[6,9]]
+
+示例 2:    
+
+- 输入：intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]
+- 输出：[[1,2],[3,10],[12,16]]
+- 解释：这是因为新的区间 [4,8] 与 [3,5],[6,7],[8,10] 重叠。
+ 
+
+提示:     
+
+- 0 <= intervals.length <= 104
+- intervals[i].length == 2
+- 0 <= starti <= endi <= 105
+- intervals 根据 starti 按 升序 排列
+- newInterval.length == 2
+- 0 <= start <= end <= 105
+
+### 思路
+
+- 题目说了是无重叠的按照区间起始端点排序的，所以不用排序了。  
+- 用指针去扫 intervals，最多可能有三个阶段:   
+
+    - 不重叠的绿区间，在蓝区间的左边
+    - 有重叠的绿区间
+    - 不重叠的绿区间，在蓝区间的右边
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_insert_qujian_1.png?raw=true)
+
+- 逐个分析
+
+    - 不重叠，需满足：绿区间的右端，位于蓝区间的左端的左边，如 [1,2]。
+
+        - 则当前绿区间，推入 res 数组，指针 +1，考察下一个绿区间。
+        - 循环结束时，当前绿区间的屁股，就没落在蓝区间之前，有重叠了，如 [3,5]。
+    - 现在看重叠的。我们反过来想，没重叠，就要满足：绿区间的左端，落在蓝区间的屁股的后面，反之就有重叠：绿区间的左端 <= 蓝区间的右端，极端的例子就是 [8,10]。
+
+        - 和蓝有重叠的区间，会合并成一个区间：左端取蓝绿左端的较小者，右端取蓝绿右端的较大者，不断更新给蓝区间。
+        - 循环结束时，将蓝区间（它是合并后的新区间）推入 res 数组。
+    - 剩下的，都在蓝区间右边，不重叠。不用额外判断，依次推入 res 数组。
+
+
+
+
+```java
+class Solution {
+    public int[][] insert(int[][] intervals, int[] newInterval) {
+        ArrayList<int[]> res = new ArrayList<>();
+        int len = intervals.length;
+        int i = 0;
+        // 判断左边不重合
+        while (i < len && intervals[i][1] < newInterval[0]) {
+            res.add(intervals[i]);
+            i++;
+        }
+        // 判断重合
+        while (i < len && intervals[i][0] <= newInterval[1]) {
+            newInterval[0] = Math.min(intervals[i][0], newInterval[0]);
+            newInterval[1] = Math.max(intervals[i][1], newInterval[1]);
+            i++;
+        }
+        res.add(newInterval);
+        // 判断右边不重合
+        while (i < len && intervals[i][0] > newInterval[1]) {
+            res.add(intervals[i]);
+            i++;
+        }
+        return res.toArray(new int[0][]);
+    }
+}
+```
+
+复杂度分析:     
+
+- 时间复杂度：O(n)，其中 n 是数组 intervals 的长度，即给定的区间个数。
+
+- 空间复杂度：O(n)。
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/51.\347\224\250\346\234\200\345\260\221\346\225\260\351\207\217\347\232\204\347\256\255\345\274\225\347\210\206\346\260\224\347\220\203.md" "b/Algorithm/51.\347\224\250\346\234\200\345\260\221\346\225\260\351\207\217\347\232\204\347\256\255\345\274\225\347\210\206\346\260\224\347\220\203.md"
new file mode 100644
index 00000000..a6fcbec6
--- /dev/null
+++ "b/Algorithm/51.\347\224\250\346\234\200\345\260\221\346\225\260\351\207\217\347\232\204\347\256\255\345\274\225\347\210\206\346\260\224\347\220\203.md"
@@ -0,0 +1,110 @@
+51.用最少数量的箭引爆气球
+===
+
+
+### 题目
+
+有一些球形气球贴在一堵用 XY 平面表示的墙面上。墙面上的气球记录在整数数组 points ，其中points[i] = [xstart, xend] 表示水平直径在 xstart 和 xend之间的气球。你不知道气球的确切 y 坐标。      
+
+一支弓箭可以沿着 x 轴从不同点 完全垂直 地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend， 且满足  xstart ≤ x ≤ xend，则该气球会被 引爆 。可以射出的弓箭的数量 没有限制 。 弓箭一旦被射出之后，可以无限地前进。      
+
+给你一个数组 points ，返回引爆所有气球所必须射出的 最小 弓箭数 。     
+
+ 
+示例 1:     
+
+- 输入：points = [[10,16],[2,8],[1,6],[7,12]]
+- 输出：2
+- 解释：气球可以用2支箭来爆破:      
+    - 在x = 6处射出箭，击破气球[2,8]和[1,6]。
+    - 在x = 11处发射箭，击破气球[10,16]和[7,12]。
+
+示例 2:     
+
+- 输入：points = [[1,2],[3,4],[5,6],[7,8]]
+- 输出：4
+- 解释：每个气球需要射出一支箭，总共需要4支箭。
+
+示例 3:     
+
+- 输入：points = [[1,2],[2,3],[3,4],[4,5]]
+- 输出：2
+- 解释：气球可以用2支箭来爆破:      
+    - 在x = 2处发射箭，击破气球[1,2]和[2,3]。
+    - 在x = 4处射出箭，击破气球[3,4]和[4,5]。
+ 
+
+提示:     
+
+- 1 <= points.length <= 105
+- points[i].length == 2
+- -231 <= xstart < xend <= 231 - 1
+
+
+### 思路
+
+##### 方法一：区间合并
+
+```java
+//思路：区间重叠则合并，合并为交集
+//先排序
+class Solution {
+    public int findMinArrowShots(int[][] points) {
+        //防止相减式的比较造成溢出
+        Arrays.sort(points,(o1,o2)->Integer.compare(o1[0],o2[0]));
+        int n = points.length; // 合并一次，n-1
+        for(int i=1;i<points.length;i++){
+            if(points[i][0] <= points[i-1][1]){
+                //区间重叠，合并为交集
+                n--;
+                points[i][0] = Math.max(points[i][0],points[i-1][0]);
+                points[i][1] = Math.min(points[i][1],points[i-1][1]);
+            }
+        }
+        return n;
+    }
+}
+```
+
+##### 方法二：
+
+- 每个气球都是有宽度的，分别是左边界和右边界，这里只需要把所有的气球按照右边界的大小进行排序。
+- 然后把第一支箭尽可能的往第一个气球的右边靠，这样第一支箭引爆气球的数量就是最多的。
+- 同理，第二支箭要尽可能的往第二个气球（这里不是排序后的第二个气球，这里的第二个气球是和第一个气球坐标没有交集的那个气球）的右边靠……。
+
+下面来画个图看下，假如下面是已经按照右边界排序好的气球:      
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_qiqiu_1.png?raw=true)
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_qiqiu_2.png?raw=true)
+
+
+```java
+public int findMinArrowShots(int[][] points) {
+    //边界条件判断
+    if (points == null || points.length == 0) {
+        return 0;
+    }
+    //按照每个气球的右边界排序
+    Arrays.sort(points, (a, b) -> a[1] > b[1] ? 1 : -1);
+    //获取排序后第一个气球右边界的位置，我们可以认为是箭射入的位置
+    int last = points[0][1];
+    //统计箭的数量
+    int count = 1;
+    for (int i = 1; i < points.length; i++) {
+        //如果箭射入的位置小于下标为i这个气球的左边位置，说明这支箭不能
+        //击爆下标为i的这个气球，需要再拿出一支箭，并且要更新这支箭射入的
+        //位置
+        if (last < points[i][0]) {
+            last = points[i][1];
+            count++;
+        }
+    }
+    return count;
+}
+```
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/52.\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267.md" "b/Algorithm/52.\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267.md"
new file mode 100644
index 00000000..a9518cdc
--- /dev/null
+++ "b/Algorithm/52.\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267.md"
@@ -0,0 +1,140 @@
+52.有效的括号
+===
+
+
+### 题目
+
+给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串s，判断字符串是否有效。
+
+有效字符串需满足:      
+
+- 左括号必须用相同类型的右括号闭合。
+- 左括号必须以正确的顺序闭合。
+- 每个右括号都有一个对应的相同类型的左括号。
+ 
+
+示例 1:   
+
+- 输入：s = "()"
+
+- 输出：true
+
+示例 2:   
+
+- 输入：s = "()[]{}"
+
+- 输出：true
+
+示例 3:    
+
+- 输入：s = "(]"
+
+- 输出：false
+
+示例 4:    
+
+- 输入：s = "([])"
+
+- 输出：true
+
+ 
+
+提示:    
+
+- 1 <= s.length <= 104
+- s 仅由括号`()[]{}`组成
+
+
+### 思路
+
+要求是“以正确的顺序闭合”，所以`([)]`这种是错误的。     
+
+要判断一个仅包含括号字符`()[]{}`的字符串是否有效（即括号是否按正确顺序闭合），可通过 ​栈`Stack`这一数据结构高效解决。
+
+
+括号的闭合需满足 ​​“后进先出”​​ 的嵌套关系: 最后出现的左括号需优先匹配右括号，栈的`LIFO后进先出`特性完美契合此需求。   
+
+
+
+​- 遍历字符​: 逐个处理字符串中的字符。
+​- 左括号入栈​: 遇到`(, {, [`时压入栈。
+​- 右括号匹配​: 遇到`), }, ]`时:       
+    - 若栈为空 `→` 无效（右括号多余）。
+    - 若栈顶左括号与当前右括号不匹配 `→` 无效。
+    - 匹配则弹出栈顶元素。
+
+- 最终校验​: 遍历结束后栈必须为空（左括号全被匹配）。    
+
+使用`ArrayDeque`替代传统`Stack`类，因前者在`push/pop`操作上效率更高（无同步开销）。    
+
+
+​```java
+import java.util.ArrayDeque;
+import java.util.Deque;
+public class Solution {
+    public boolean isValid(String s) {
+        // 边界处理：空字符串有效，null 或奇数长度直接无效
+        if (s == null) {
+            return false;
+        }
+        if (s.isEmpty()) {
+            return true;
+        }
+        if (s.length() % 2 != 0) {
+            // 奇数长度不可能完全匹配
+            return false;
+        }
+
+        // 使用双端队列模拟栈（高效）
+        Deque<Character> stack = new ArrayDeque<>(); 
+        
+        for (char c : s.toCharArray()) {
+            // 左括号：入栈
+            if (c == '(' || c == '{' || c == '[') {
+                stack.push(c);
+            } 
+            // 右括号：检查匹配
+            else {
+                if (stack.isEmpty()) return false; // 栈空说明右括号多余
+                char top = stack.pop(); // 弹出栈顶左括号
+                // 检查括号类型是否匹配
+                if ((c == ')' && top != '(') || 
+                    (c == '}' && top != '{') || 
+                    (c == ']' && top != '[')) {
+                    return false;
+                }
+            }
+        }
+        return stack.isEmpty(); // 栈空说明所有左括号均被匹配
+    }
+}
+```
+
+
+
+
+```python
+# 映射表优化：用字典 bracket_map 存储括号对应关系，避免冗长的 if-else 分支
+def isValid(s: str) -> bool:
+    stack = []
+    bracket_map = {')': '(', ']': '[', '}': '{'}  # 右括号到左括号的映射
+    for char in s:
+        if char in bracket_map.values():  # 左括号入栈
+            stack.append(char)
+        elif char in bracket_map:  # 右括号匹配
+            if not stack or stack.pop() != bracket_map[char]:
+                return False
+    return not stack
+```
+
+复杂度分析:   
+
+- 时间复杂度: O(N)
+- 空间复杂度: O(N)
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/53.\347\256\200\345\214\226\350\267\257\345\276\204.md" "b/Algorithm/53.\347\256\200\345\214\226\350\267\257\345\276\204.md"
new file mode 100644
index 00000000..a9ace618
--- /dev/null
+++ "b/Algorithm/53.\347\256\200\345\214\226\350\267\257\345\276\204.md"
@@ -0,0 +1,127 @@
+53.简化路径
+===
+
+
+### 题目
+
+给你一个字符串path，表示指向某一文件或目录的 Unix 风格 绝对路径（以 '/' 开头），请你将其转化为 更加简洁的规范路径。    
+
+在Unix风格的文件系统中规则如下:    
+
+- 一个点 '.' 表示当前目录本身。
+- 此外，两个点 '..' 表示将目录切换到上一级（指向父目录）。
+- 任意多个连续的斜杠（即，'//' 或 '///'）都被视为单个斜杠 '/'。
+- 任何其他格式的点（例如，'...' 或 '....'）均被视为有效的文件/目录名称。
+
+返回的 简化路径 必须遵循下述格式:     
+
+- 始终以斜杠 '/' 开头。
+- 两个目录名之间必须只有一个斜杠 '/' 。
+- 最后一个目录名（如果存在）不能 以 '/' 结尾。
+- 此外，路径仅包含从根目录到目标文件或目录的路径上的目录（即，不含 '.' 或 '..'）。
+
+返回简化后得到的 规范路径 。
+
+ 
+
+示例 1:    
+
+- 输入：path = "/home/"
+
+- 输出："/home"
+
+解释:   
+
+- 应删除尾随斜杠。
+
+示例 2:    
+
+- 输入：path = "/home//foo/"
+
+- 输出："/home/foo"
+
+解释:    
+
+- 多个连续的斜杠被单个斜杠替换。
+
+示例 3:    
+
+- 输入：path = "/home/user/Documents/../Pictures"
+
+- 输出："/home/user/Pictures"
+
+解释:   
+
+- 两个点 ".." 表示上一级目录（父目录）。
+
+示例 4:   
+
+- 输入：path = "/../"
+
+- 输出："/"
+
+解释:    
+
+- 不可能从根目录上升一级目录。
+
+示例 5:    
+
+- 输入：path = "/.../a/../b/c/../d/./"
+
+- 输出："/.../b/d"
+
+解释:    
+
+- "..." 在这个问题中是一个合法的目录名。
+
+ 
+
+提示:    
+
+- 1 <= path.length <= 3000
+- path 由英文字母，数字，'.'，'/' 或 '_' 组成。
+- path 是一个有效的 Unix 风格绝对路径。
+
+### 思路
+
+
+根据题意，使用栈进行模拟即可。
+
+具体的，从前往后处理 path，每次以 item 为单位进行处理（有效的文件名），根据 item 为何值进行分情况讨论:     
+
+- item 为有效值 : 存入栈中
+- item 为 .. : 弹出栈顶元素（若存在）
+- item 为 . : 不作处理
+
+```java
+public String simplifyPath(String path) {
+    Deque<String> deque = new ArrayDeque<>();
+    int n = path.length();
+    for (int i = 1; i < n; i++) {
+        if (path.charAt(i) == '/') continue;   // 找到下一个不是"/"的位置
+        int j = i + 1;   // j指向下一个位置，双指针！
+        while (j < n && path.charAt(j) != '/') j++; // 直到j指向的位置是"/"
+        String temp = path.substring(i, j);   // 左闭右开，[i.j)
+        if (temp.equals("..")) {     //..的时候，栈内有元素才删
+            if (!deque.isEmpty()) {
+                deque.pollLast();
+            }
+        } else if (!(temp.equals("."))) { // .的时候就continue，这里省略了，不是.的时候就进栈
+            deque.addLast(temp);
+        }
+        i = j; //j是指向"/"的，令i=j开始下一轮循环
+    }
+    StringBuilder ans = new StringBuilder();
+    while (!deque.isEmpty()) {  // 还原栈内的路径
+        ans.append("/");
+        ans.append(deque.pollFirst());
+    }
+    return ans.length() == 0 ? "/" : ans.toString();  // 栈为空就直接返回"/",否则返回ans.toString()
+}
+```
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/54.\346\234\200\345\260\217\346\240\210.md" "b/Algorithm/54.\346\234\200\345\260\217\346\240\210.md"
new file mode 100644
index 00000000..11a8c8c2
--- /dev/null
+++ "b/Algorithm/54.\346\234\200\345\260\217\346\240\210.md"
@@ -0,0 +1,103 @@
+54.最小栈
+===
+
+
+### 题目
+
+设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。
+
+实现 MinStack 类:     
+
+- MinStack() 初始化堆栈对象。
+- void push(int val) 将元素val推入堆栈。
+- void pop() 删除堆栈顶部的元素。
+- int top() 获取堆栈顶部的元素。
+- int getMin() 获取堆栈中的最小元素。
+ 
+
+示例 1:    
+
+- 输入:     
+```
+["MinStack","push","push","push","getMin","pop","top","getMin"]
+[[],[-2],[0],[-3],[],[],[],[]]
+```
+输出:    
+[null,null,null,null,-3,null,0,-2]
+
+解释:   
+```
+MinStack minStack = new MinStack();
+minStack.push(-2);
+minStack.push(0);
+minStack.push(-3);
+minStack.getMin();   --> 返回 -3.
+minStack.pop();
+minStack.top();      --> 返回 0.
+minStack.getMin();   --> 返回 -2.
+``` 
+
+提示:     
+
+- -231 <= val <= 231 - 1
+- pop、top 和 getMin 操作总是在 非空栈 上调用
+- push, pop, top, and getMin最多被调用 3 * 104 次
+
+### 思路
+
+
+解题思路:    
+
+借用一个辅助栈min_stack，用于存获取stack中最小值。    
+
+算法流程:    
+
+- push()方法: 每当push()新值进来时，如果小于等于min_stack栈顶值，则一起push()到min_stack，即更新了栈顶最小值         
+-  pop()方法: 判断将pop()出去的元素值是否是min_stack栈顶元素值（即最小值），如果是则将min_stack栈顶元素一起pop()，这样可以保证min_stack栈顶元素始终是stack中的最小值      
+- getMin()方法: 返回min_stack栈顶即可     
+
+min_stack作用分析:     
+
+min_stack等价于遍历stack所有元素，把升序的数字都删除掉，留下一个从栈底到栈顶降序的栈。      
+相当于给stack中的降序元素做了标记，每当pop()这些降序元素，min_stack会将相应的栈顶元素pop()出去，保证其栈顶元素始终是stack中的最小元素。      
+复杂度分析:    
+
+- 时间复杂度 O(1) : 压栈，出栈，获取最小值的时间复杂度都为 O(1) 。
+- 空间复杂度 O(N) : 包含 N 个元素辅助栈占用线性大小的额外空间。
+
+```java
+class MinStack {
+    private Stack<Integer> stack;
+    private Stack<Integer> min_stack;
+    public MinStack() {
+        stack = new Stack<>();
+        min_stack = new Stack<>();
+    }
+    public void push(int x) {
+        stack.push(x);
+        if(min_stack.isEmpty() || x <= min_stack.peek()) {
+            min_stack.push(x);
+        }
+    }
+    public void pop() {
+        if(stack.pop().equals(min_stack.peek())) {
+            min_stack.pop();
+        }
+    }
+
+    public int top() {
+        return stack.peek();
+    }
+    
+    public int getMin() {
+        return min_stack.peek();
+    }
+}
+```
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/55.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217\346\261\202\345\200\274.md" "b/Algorithm/55.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217\346\261\202\345\200\274.md"
new file mode 100644
index 00000000..11250060
--- /dev/null
+++ "b/Algorithm/55.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217\346\261\202\345\200\274.md"
@@ -0,0 +1,137 @@
+55.逆波兰表达式求值
+===
+
+
+### 题目
+
+给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。
+
+请你计算该表达式。返回一个表示表达式值的整数。
+
+注意:     
+
+- 有效的算符为 '+'、'-'、'*' 和 '/' 。
+- 每个操作数（运算对象）都可以是一个整数或者另一个表达式。
+- 两个整数之间的除法总是 向零截断 。
+- 表达式中不含除零运算。
+- 输入是一个根据逆波兰表示法表示的算术表达式。
+- 答案及所有中间计算结果可以用 32 位 整数表示。
+ 
+
+示例 1:    
+
+- 输入：tokens = ["2","1","+","3","*"]
+- 输出：9
+- 解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9
+
+示例 2:     
+
+- 输入：tokens = ["4","13","5","/","+"]
+- 输出：6
+- 解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6
+
+示例 3:    
+
+- 输入：tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
+- 输出：22
+- 解释：该算式转化为常见的中缀算术表达式为:    
+```
+  ((10 * (6 / ((9 + 3) * -11))) + 17) + 5
+= ((10 * (6 / (12 * -11))) + 17) + 5
+= ((10 * (6 / -132)) + 17) + 5
+= ((10 * 0) + 17) + 5
+= (0 + 17) + 5
+= 17 + 5
+= 22
+``` 
+
+提示:   
+
+- 1 <= tokens.length <= 104
+- tokens[i]是一个算符（`+`、`-`、`*`或`/`），或是在范围`[-200, 200]`内的一个整数    
+ 
+
+逆波兰表达式:     
+
+- 逆波兰表达式是一种后缀表达式，所谓后缀就是指算符写在后面。
+
+- 平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。
+- 该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。
+
+逆波兰表达式主要有以下两个优点:    
+
+- 去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。
+- 适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中
+
+### 思路
+
+逆波兰表达式，也叫做后缀表达式。
+
+我们平时见到的运算表达式是中缀表达式，即 "操作数① 运算符② 操作数③" 的顺序，运算符在两个操作数中间。
+但是后缀表达式是 "操作数① 操作数③ 运算符②" 的顺序，运算符在两个操作数之后。
+
+
+逆波兰表达式严格遵循「从左到右」的运算。计算逆波兰表达式的值时，使用一个栈存储操作数，从左到右遍历逆波兰表达式，进行如下操作:     
+
+- 如果遇到操作数，则将操作数入栈；
+
+- 如果遇到运算符，则将两个操作数出栈，其中先出栈的是右操作数，后出栈的是左操作数，使用运算符对两个操作数进行运算，将运算得到的新操作数入栈。
+
+整个逆波兰表达式遍历完毕之后，栈内只有一个元素，该元素即为逆波兰表达式的值。
+
+
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_evalRPN1.png?raw=true)
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_evalRPN2.png?raw=true)
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_evalRPN3.png?raw=true)
+![image](https://raw.githubusercontent.com/CharonChui/Pictures/master/leetcode_evalRPN4.png?raw=true)
+
+```java
+class Solution {
+    public int evalRPN(String[] tokens) {
+        Deque<Integer> stack = new LinkedList<Integer>();
+        int n = tokens.length;
+        for (int i = 0; i < n; i++) {
+            String token = tokens[i];
+            if (isNumber(token)) {
+                stack.push(Integer.parseInt(token));
+            } else {
+                int num2 = stack.pop();
+                int num1 = stack.pop();
+                switch (token) {
+                    case "+":
+                        stack.push(num1 + num2);
+                        break;
+                    case "-":
+                        stack.push(num1 - num2);
+                        break;
+                    case "*":
+                        stack.push(num1 * num2);
+                        break;
+                    case "/":
+                        stack.push(num1 / num2);
+                        break;
+                    default:
+                }
+            }
+        }
+        return stack.pop();
+    }
+
+    public boolean isNumber(String token) {
+        return !("+".equals(token) || "-".equals(token) || "*".equals(token) || "/".equals(token));
+    }
+}
+```
+
+复杂度分析:      
+
+- 时间复杂度: O(n)，其中 n 是数组 tokens 的长度。需要遍历数组 tokens 一次，计算逆波兰表达式的值。
+
+- 空间复杂度: O(n)，其中 n 是数组 tokens 的长度。使用栈存储计算过程中的数，栈内元素个数不会超过逆波兰表达式的长度。
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git "a/Algorithm/56.\345\237\272\346\234\254\350\256\241\347\256\227\345\231\250.md" "b/Algorithm/56.\345\237\272\346\234\254\350\256\241\347\256\227\345\231\250.md"
new file mode 100644
index 00000000..10656199
--- /dev/null
+++ "b/Algorithm/56.\345\237\272\346\234\254\350\256\241\347\256\227\345\231\250.md"
@@ -0,0 +1,163 @@
+56.基本计算器
+===
+
+
+### 题目
+
+给你一个字符串表达式 s ，请你实现一个基本计算器来计算并返回它的值。
+
+注意:不允许使用任何将字符串作为数学表达式计算的内置函数，比如 eval() 。
+
+ 
+
+示例 1:    
+
+- 输入：s = "1 + 1"
+- 输出：2
+
+示例 2:   
+
+- 输入：s = " 2-1 + 2 "
+- 输出：3
+
+示例 3:    
+
+- 输入：s = "(1+(4+5+2)-3)+(6+8)"
+- 输出：23
+ 
+
+提示:    
+
+- 1 <= s.length <= 3 * 105
+- s 由数字、'+'、'-'、'('、')'、和 ' ' 组成
+- s 表示一个有效的表达式
+- '+' 不能用作一元运算(例如， "+1" 和 "+(2 + 3)" 无效)
+- '-' 可以用作一元运算(即 "-1" 和 "-(2 + 3)" 是有效的)
+- 输入中不存在两个连续的操作符
+- 每个数字和运行的计算将适合于一个有符号的 32位 整数
+
+### 思路
+
+
+【进阶补充】双栈解决通用「表达式计算」问题
+
+
+宫水三叶
+76872
+2021.03.10
+发布于 上海市
+栈
+数学
+C++
+Java
+双栈解法
+
+我们可以使用两个栈 nums 和 ops 。
+
+nums ： 存放所有的数字
+ops ：存放所有的数字以外的操作，+/- 也看做是一种操作
+然后从前往后做，对遍历到的字符做分情况讨论：
+
+空格 : 跳过
+( : 直接加入 ops 中，等待与之匹配的 )
+) : 使用现有的 nums 和 ops 进行计算，直到遇到左边最近的一个左括号为止，计算结果放到 nums
+数字 : 从当前位置开始继续往后取，将整一个连续数字整体取出，加入 nums
++/- : 需要将操作放入 ops 中。在放入之前先把栈内可以算的都算掉，使用现有的 nums 和 ops 进行计算，直到没有操作或者遇到左括号，计算结果放到 nums
+一些细节：
+
+由于第一个数可能是负数，为了减少边界判断。一个小技巧是先往 nums 添加一个 0
+为防止 () 内出现的首个字符为运算符，将所有的空格去掉，并将 (- 替换为 (0-，(+ 替换为 (0+（当然也可以不进行这样的预处理，将这个处理逻辑放到循环里去做）
+
+
+
+class Solution {
+    public int calculate(String s) {
+        // 存放所有的数字
+        Deque<Integer> nums = new ArrayDeque<>();
+        // 为了防止第一个数为负数，先往 nums 加个 0
+        nums.addLast(0);
+        // 将所有的空格去掉
+        s = s.replaceAll(" ", "");
+        // 存放所有的操作，包括 +/-
+        Deque<Character> ops = new ArrayDeque<>();
+        int n = s.length();
+        char[] cs = s.toCharArray();
+        for (int i = 0; i < n; i++) {
+            char c = cs[i];
+            if (c == '(') {
+                ops.addLast(c);
+            } else if (c == ')') {
+                // 计算到最近一个左括号为止
+                while (!ops.isEmpty()) {
+                    char op = ops.peekLast();
+                    if (op != '(') {
+                        calc(nums, ops);
+                    } else {
+                        ops.pollLast();
+                        break;
+                    }
+                }
+            } else {
+                if (isNum(c)) {
+                    int u = 0;
+                    int j = i;
+                    // 将从 i 位置开始后面的连续数字整体取出，加入 nums
+                    while (j < n && isNum(cs[j])) u = u * 10 + (int)(cs[j++] - '0');
+                    nums.addLast(u);
+                    i = j - 1;
+                } else {
+                    if (i > 0 && (cs[i - 1] == '(' || cs[i - 1] == '+' || cs[i - 1] == '-')) {
+                        nums.addLast(0);
+                    }
+                    // 有一个新操作要入栈时，先把栈内可以算的都算了
+                    while (!ops.isEmpty() && ops.peekLast() != '(') calc(nums, ops);
+                    ops.addLast(c);
+                }
+            }
+        }
+        while (!ops.isEmpty()) calc(nums, ops);
+        return nums.peekLast();
+    }
+    void calc(Deque<Integer> nums, Deque<Character> ops) {
+        if (nums.isEmpty() || nums.size() < 2) return;
+        if (ops.isEmpty()) return;
+        int b = nums.pollLast(), a = nums.pollLast();
+        char op = ops.pollLast();
+        nums.addLast(op == '+' ? a + b : a - b);
+    }
+    boolean isNum(char c) {
+        return Character.isDigit(c);
+    }
+}
+
+作者：宫水三叶
+链接：https://leetcode.cn/problems/basic-calculator/solutions/646865/shuang-zhan-jie-jue-tong-yong-biao-da-sh-olym/
+来源：力扣（LeetCode）
+著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git a/Algorithm/37..md b/Algorithm/57..md
similarity index 100%
rename from Algorithm/37..md
rename to Algorithm/57..md
diff --git a/Algorithm/38..md b/Algorithm/58..md
similarity index 100%
rename from Algorithm/38..md
rename to Algorithm/58..md
diff --git a/Algorithm/39..md b/Algorithm/59..md
similarity index 100%
rename from Algorithm/39..md
rename to Algorithm/59..md
diff --git a/Algorithm/40..md b/Algorithm/60..md
similarity index 100%
rename from Algorithm/40..md
rename to Algorithm/60..md
diff --git a/Algorithm/61..md b/Algorithm/61..md
new file mode 100644
index 00000000..0970b4ab
--- /dev/null
+++ b/Algorithm/61..md
@@ -0,0 +1,17 @@
+18.整数转罗马数字
+===
+
+
+### 题目
+
+
+
+### 思路
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	
diff --git a/Algorithm/62..md b/Algorithm/62..md
new file mode 100644
index 00000000..0970b4ab
--- /dev/null
+++ b/Algorithm/62..md
@@ -0,0 +1,17 @@
+18.整数转罗马数字
+===
+
+
+### 题目
+
+
+
+### 思路
+
+
+
+---
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
+
+	

From 94ae56aebb00c697e7846788aa9326e2a8f86a72 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 17 Sep 2025 14:35:37 +0800
Subject: [PATCH 211/213] add notes

---
 VideoDevelopment/JPEG 2.md                    | 102 ++++++++
 VideoDevelopment/JPEG.md                      | 102 ++++++++
 .../JPEG.md"                                  | 117 +++++++++
 .../PNG.md"                                   | 247 ++++++++++++++++++
 4 files changed, 568 insertions(+)
 create mode 100644 VideoDevelopment/JPEG 2.md
 create mode 100644 VideoDevelopment/JPEG.md
 create mode 100644 "VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/JPEG.md"
 create mode 100644 "VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/PNG.md"

diff --git a/VideoDevelopment/JPEG 2.md b/VideoDevelopment/JPEG 2.md
new file mode 100644
index 00000000..fa200838
--- /dev/null
+++ b/VideoDevelopment/JPEG 2.md	
@@ -0,0 +1,102 @@
+# JPEG
+
+JPEG（Joint Photographic Experts Group)，全称为联合图像专家小组，是国际标准化组织（ISO）制定的静态图像压缩标准，文件扩展名为.jpg或.jpeg，适用于连续色调静止图像处理。
+
+
+JPEG只描述一副图像如何转换成一组数据流，而不论这些字节存储在何种介质上。由独立JPEG组创立的另一个进阶标准，JFIF（JPEGFileInterchangeFormat，JPEG文件交换格式）则描述JPEG数据流如何生成适于电脑存储或传送的图像。在一般应用中，我们从数码相机等来源获得的“JPEG文件”，指的就是JFIF文件，有时是ExifJPEG文件。
+
+
+该格式采用有损压缩算法，通过牺牲部分画质换取较小文件体积，压缩过程包含色彩空间转换（RGB转YCbCr）、离散余弦变换（DCT）、量化和熵编码等步骤。
+
+支持标准JPEG、渐进式JPEG和JPEG2000三种格式，其中渐进式格式可实现图像由模糊到清晰的渐进加载.  
+
+JPEG压缩技术通过分离高频与低频信息并对高频部分进行压缩，压缩比可通过量化表参数调节，典型压缩率为原始大小的10%.   
+
+
+### 说明
+1. jpeg是一种压缩标准，大幅度缩小数据流，jpeg以FF D8开头，FF D9结束。
+2. jpeg文件中有一些形如0xFF**这样的数据，它们被称为标志(Markeer),它表示jpeg信息数据段。例如0xFFD8代表SOI(Startof image)。OxFFD9代表EOI(End of image)。
+4. jpeg图像由多个maker组成，多个maker+compressed组成了jpeg。
+5. jiff是一种在万维网上进行jpeg传输的格式，可以理解是对jpeg图片的封装，符合jpeg标准，jiff的maker是app0，记录了图像的基本信息，也可能有缩略图。jiff格式比较老，老式的数码相机使用此格式。
+6. exif新比较新的jpeg封装格式，exif的maker是app1，记录了更多的东西，如ISP信息、GPS信息、相机信息，图像旋转等等
+7. jiff和exif可以共存，很多jpeg图像都有app0的jiff段和app1的exif段
+
+
+
+## 压缩流程
+
+1. 原始图像
+2. 8x8分块
+3. DCT(Discrete Cosine Transform,离散余弦变换)变换: 把数据从时域转化到频域的数学方法，把图像数据转换到频域之后，可以从中分离出各种频率的信息。   
+4. 量化
+5. Z字形扫描
+6. 对系数编码
+7. 熵编码
+8. 压缩数据
+
+
+ 
+
+ 
+JPEG文件除了图像数据之外，还保存了与图片相关的各种信息，这些信息通过不同类型的TAG存储在文件中。 
+
+
+## TAG
+
+JPEG通过TAG编辑压缩数据之外的信息。    
+
+所有的TAG都包含一个TAG类型，TAG类型的大小为两个字节，位于一个TAG的最前面。TAG类型的第一个字节一定为0xFF
+
+一般情况下，是按照这个顺序排列的:     
+
+
+| TAG 类型          | 数值(十六进制标识符)     | 全称                       | 其他备注                          |
+|-------------------|----------|----------------------------|-----------------------------------|
+| SOI               | 0xFFD8   | Start of Image             | 必带                              |
+| APP0              | 0xFFE0   | application0               | 必带                              |
+| APPn              | 0xFFEn   | applicationn               | 可选带(APP1一般为Exif信息)        |
+| DQT               | 0xFFDB   | Define Quantization Table  | 必带                              |
+| SOF               | 0xFFC0   | Start of Frame             | 必带                              |
+| DHT               | 0xFFC4   | Define Huffman Table       | 必带                              |
+| SOS               | 0xFFDA   | Start of Scan              | 必带                              |
+| compress data     | ...      | ...                        | 必带                              |
+| EOI               | 0xFFD9   | End of Image               | 必带                              |
+
+标志OxFFE0~OxFFEF被称为"Application Marker"，它们不是解码JPEG文件必须得，可以被用来存储配置信息等。    
+EXIF也是利用这个标志段来插入信息的。具体来说，是APP1(0xFFE1)Marker，所有的EXIF信息都存储在该数据段。    
+​EXIF（Exchangeable Image File Format）​​ 是嵌入在 JPEG 文件中的 ​元数据标准，记录拍摄设备、参数和场景信息，相当于照片的“数字身份证”。
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/jpeg_1.png?raw=true)             
+
+
+#### 典型JPEG文件结构    
+
+[SOI] -> [APP0] -> [APP1(EXIF)] -> [DQT] -> [SOF] -> [DHT] -> [SOS] -> [压缩数据] -> [EOI]
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/jpeg_2.png?raw=true)             
+
+##### 怎么判断是不是JPEG图片？ 
+
+jpeg是一种压缩标准，大幅度缩小数据流，jpeg以FF D8开头，FF D9结束。
+
+
+其实很简单，就是判断前面3个字节是什么，如果发现是FF D8 FF开始，那就认为它是JEPG图片。(注意android不是根据后缀名来判断是什么文件的，当然你必须是图片的后缀名文件管理器才可以打开
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/VideoDevelopment/JPEG.md b/VideoDevelopment/JPEG.md
new file mode 100644
index 00000000..fa200838
--- /dev/null
+++ b/VideoDevelopment/JPEG.md
@@ -0,0 +1,102 @@
+# JPEG
+
+JPEG（Joint Photographic Experts Group)，全称为联合图像专家小组，是国际标准化组织（ISO）制定的静态图像压缩标准，文件扩展名为.jpg或.jpeg，适用于连续色调静止图像处理。
+
+
+JPEG只描述一副图像如何转换成一组数据流，而不论这些字节存储在何种介质上。由独立JPEG组创立的另一个进阶标准，JFIF（JPEGFileInterchangeFormat，JPEG文件交换格式）则描述JPEG数据流如何生成适于电脑存储或传送的图像。在一般应用中，我们从数码相机等来源获得的“JPEG文件”，指的就是JFIF文件，有时是ExifJPEG文件。
+
+
+该格式采用有损压缩算法，通过牺牲部分画质换取较小文件体积，压缩过程包含色彩空间转换（RGB转YCbCr）、离散余弦变换（DCT）、量化和熵编码等步骤。
+
+支持标准JPEG、渐进式JPEG和JPEG2000三种格式，其中渐进式格式可实现图像由模糊到清晰的渐进加载.  
+
+JPEG压缩技术通过分离高频与低频信息并对高频部分进行压缩，压缩比可通过量化表参数调节，典型压缩率为原始大小的10%.   
+
+
+### 说明
+1. jpeg是一种压缩标准，大幅度缩小数据流，jpeg以FF D8开头，FF D9结束。
+2. jpeg文件中有一些形如0xFF**这样的数据，它们被称为标志(Markeer),它表示jpeg信息数据段。例如0xFFD8代表SOI(Startof image)。OxFFD9代表EOI(End of image)。
+4. jpeg图像由多个maker组成，多个maker+compressed组成了jpeg。
+5. jiff是一种在万维网上进行jpeg传输的格式，可以理解是对jpeg图片的封装，符合jpeg标准，jiff的maker是app0，记录了图像的基本信息，也可能有缩略图。jiff格式比较老，老式的数码相机使用此格式。
+6. exif新比较新的jpeg封装格式，exif的maker是app1，记录了更多的东西，如ISP信息、GPS信息、相机信息，图像旋转等等
+7. jiff和exif可以共存，很多jpeg图像都有app0的jiff段和app1的exif段
+
+
+
+## 压缩流程
+
+1. 原始图像
+2. 8x8分块
+3. DCT(Discrete Cosine Transform,离散余弦变换)变换: 把数据从时域转化到频域的数学方法，把图像数据转换到频域之后，可以从中分离出各种频率的信息。   
+4. 量化
+5. Z字形扫描
+6. 对系数编码
+7. 熵编码
+8. 压缩数据
+
+
+ 
+
+ 
+JPEG文件除了图像数据之外，还保存了与图片相关的各种信息，这些信息通过不同类型的TAG存储在文件中。 
+
+
+## TAG
+
+JPEG通过TAG编辑压缩数据之外的信息。    
+
+所有的TAG都包含一个TAG类型，TAG类型的大小为两个字节，位于一个TAG的最前面。TAG类型的第一个字节一定为0xFF
+
+一般情况下，是按照这个顺序排列的:     
+
+
+| TAG 类型          | 数值(十六进制标识符)     | 全称                       | 其他备注                          |
+|-------------------|----------|----------------------------|-----------------------------------|
+| SOI               | 0xFFD8   | Start of Image             | 必带                              |
+| APP0              | 0xFFE0   | application0               | 必带                              |
+| APPn              | 0xFFEn   | applicationn               | 可选带(APP1一般为Exif信息)        |
+| DQT               | 0xFFDB   | Define Quantization Table  | 必带                              |
+| SOF               | 0xFFC0   | Start of Frame             | 必带                              |
+| DHT               | 0xFFC4   | Define Huffman Table       | 必带                              |
+| SOS               | 0xFFDA   | Start of Scan              | 必带                              |
+| compress data     | ...      | ...                        | 必带                              |
+| EOI               | 0xFFD9   | End of Image               | 必带                              |
+
+标志OxFFE0~OxFFEF被称为"Application Marker"，它们不是解码JPEG文件必须得，可以被用来存储配置信息等。    
+EXIF也是利用这个标志段来插入信息的。具体来说，是APP1(0xFFE1)Marker，所有的EXIF信息都存储在该数据段。    
+​EXIF（Exchangeable Image File Format）​​ 是嵌入在 JPEG 文件中的 ​元数据标准，记录拍摄设备、参数和场景信息，相当于照片的“数字身份证”。
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/jpeg_1.png?raw=true)             
+
+
+#### 典型JPEG文件结构    
+
+[SOI] -> [APP0] -> [APP1(EXIF)] -> [DQT] -> [SOF] -> [DHT] -> [SOS] -> [压缩数据] -> [EOI]
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/jpeg_2.png?raw=true)             
+
+##### 怎么判断是不是JPEG图片？ 
+
+jpeg是一种压缩标准，大幅度缩小数据流，jpeg以FF D8开头，FF D9结束。
+
+
+其实很简单，就是判断前面3个字节是什么，如果发现是FF D8 FF开始，那就认为它是JEPG图片。(注意android不是根据后缀名来判断是什么文件的，当然你必须是图片的后缀名文件管理器才可以打开
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/JPEG.md" "b/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/JPEG.md"
new file mode 100644
index 00000000..bf05b544
--- /dev/null
+++ "b/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/JPEG.md"
@@ -0,0 +1,117 @@
+# JPEG
+
+[JPEG](https://www.w3.org/Graphics/JPEG/itu-t81.pdf)
+JPEG（Joint Photographic Experts Group)，全称为联合图像专家小组，是国际标准化组织（ISO）制定的静态图像压缩标准，文件扩展名为.jpg或.jpeg，适用于连续色调静止图像处理。
+
+
+
+JPEG只描述一副图像如何转换成一组数据流，而不论这些字节存储在何种介质上。由独立JPEG组创立的另一个进阶标准，JFIF（JPEGFileInterchangeFormat，JPEG文件交换格式）则描述JPEG数据流如何生成适于电脑存储或传送的图像。在一般应用中，我们从数码相机等来源获得的“JPEG文件”，指的就是JFIF文件，有时是ExifJPEG文件。
+
+
+该格式采用有损压缩算法，通过牺牲部分画质换取较小文件体积，压缩过程包含色彩空间转换（RGB转YCbCr）、离散余弦变换（DCT）、量化和熵编码等步骤。
+
+支持标准JPEG、渐进式JPEG和JPEG2000三种格式，其中渐进式格式可实现图像由模糊到清晰的渐进加载.  
+
+JPEG压缩技术通过分离高频与低频信息并对高频部分进行压缩，压缩比可通过量化表参数调节，典型压缩率为原始大小的10%.   
+
+
+### 说明
+1. jpeg是一种压缩标准，大幅度缩小数据流，jpeg以FF D8开头，FF D9结束。
+2. jpeg文件中有一些形如0xFF**这样的数据，它们被称为标志(Markeer),它表示jpeg信息数据段。例如0xFFD8代表SOI(Startof image)。OxFFD9代表EOI(End of image)。
+4. jpeg图像由多个maker组成，多个maker+compressed组成了jpeg。
+5. jiff是一种在万维网上进行jpeg传输的格式，可以理解是对jpeg图片的封装，符合jpeg标准，jiff的maker是app0，记录了图像的基本信息，也可能有缩略图。jiff格式比较老，老式的数码相机使用此格式。
+6. exif新比较新的jpeg封装格式，exif的maker是app1，记录了更多的东西，如ISP信息、GPS信息、相机信息，图像旋转等等
+7. jiff和exif可以共存，很多jpeg图像都有app0的jiff段和app1的exif段
+
+
+
+## 压缩流程
+
+1. 原始图像
+2. 8x8分块
+3. DCT(Discrete Cosine Transform,离散余弦变换)变换: 把数据从时域转化到频域的数学方法，把图像数据转换到频域之后，可以从中分离出各种频率的信息。   
+4. 量化
+5. Z字形扫描
+6. 对系数编码
+7. 熵编码
+8. 压缩数据
+
+
+ 
+
+ 
+JPEG文件除了图像数据之外，还保存了与图片相关的各种信息，这些信息通过不同类型的TAG存储在文件中。 
+
+
+## TAG
+
+JPEG通过TAG编辑压缩数据之外的信息。    
+
+所有的TAG都包含一个TAG类型，TAG类型的大小为两个字节，位于一个TAG的最前面。TAG类型的第一个字节一定为0xFF
+
+一般情况下，是按照这个顺序排列的:     
+
+
+| TAG 类型          | 数值(十六进制标识符)     | 全称                       | 其他备注                          |
+|-------------------|----------|----------------------------|-----------------------------------|
+| SOI               | 0xFFD8   | Start of Image             | 必带                              |
+| APP0              | 0xFFE0   | application0               | 必带                              |
+| APPn              | 0xFFEn   | applicationn               | 可选带(APP1一般为Exif信息)        |
+| DQT               | 0xFFDB   | Define Quantization Table  | 必带                              |
+| SOF               | 0xFFC0   | Start of Frame             | 必带                              |
+| DHT               | 0xFFC4   | Define Huffman Table       | 必带                              |
+| SOS               | 0xFFDA   | Start of Scan              | 必带                              |
+| compress data     | ...      | ...                        | 必带                              |
+| EOI               | 0xFFD9   | End of Image               | 必带                              |
+
+标志OxFFE0~OxFFEF被称为"Application Marker"，它们不是解码JPEG文件必须得，可以被用来存储配置信息等。    
+EXIF也是利用这个标志段来插入信息的。具体来说，是APP1(0xFFE1)Marker，所有的EXIF信息都存储在该数据段。    
+​EXIF（Exchangeable Image File Format）​​ 是嵌入在 JPEG 文件中的 ​元数据标准，记录拍摄设备、参数和场景信息，相当于照片的“数字身份证”。
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/jpeg_1.png?raw=true)             
+
+
+#### 典型JPEG文件结构    
+
+[SOI] -> [APP0] -> [APP1(EXIF)] -> [DQT] -> [SOF] -> [DHT] -> [SOS] -> [压缩数据] -> [EOI]
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/jpeg_2.png?raw=true)             
+
+##### 怎么判断是不是JPEG图片？ 
+
+jpeg是一种压缩标准，大幅度缩小数据流，jpeg以FF D8开头，FF D9结束。
+
+
+其实很简单，就是判断前面3个字节是什么，如果发现是FF D8 FF开始，那就认为它是JEPG图片。(注意android不是根据后缀名来判断是什么文件的，当然你必须是图片的后缀名文件管理器才可以打开
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/jpeg_3.png?raw=true)             
+
+
+
+
+### Exif是什么
+
+
+Exif(Exchangeable Image File可交换图像文件)就是用来记录拍摄图像时的各种信息: 
+- 图像信息(厂商、分辨率等)
+- 相机拍摄记录(ISO、白平衡、饱和度、锐度等)
+- 缩略图(缩略图宽度、高度等)
+- gps(拍摄时的经度、纬度、高度等)
+
+将这些信息按照JPEG文件标准放在图像文件头部。   
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/PNG.md" "b/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/PNG.md"
new file mode 100644
index 00000000..e85ed436
--- /dev/null
+++ "b/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/PNG.md"
@@ -0,0 +1,247 @@
+# PNG
+
+[PNG](https://www.w3.org/TR/png/#4Concepts.Format): 便携式网络图形（Portable Network Graphics）是一种无损压缩的位图图形格式,被设计为取代古老的 GIF 格式，其核心目标是无损压缩、支持真彩色和完全透明。      
+
+
+### 文件结构
+
+PNG图像格式文件（或者称为数据流）由一个8字节的PNG文件署名（PNG file signature）域和按照特定结构组织的3个以上的数据块（chunk）组成。   
+
+
+
+1. 文件署名域（Magic Number）​
+
+
+8字节的PNG文件署名域用来识别该文件是不是PNG文件。该域的值是：
+
+十进制数137 80 78 71 13 10 26 10
+十六进制数 89 50 4e 47 0d 0a 1a 0a
+
+
+
+​固定 8 字节：89 50 4E 47 0D 0A 1A 0A:       
+- 89：高位设置，防止被误判为文本文件。
+- 50 4E 47：ASCII "PNG"。
+- 0D 0A：DOS 风格的换行符，用于换行符转换检测。
+- 1A：DOS 的 EOF（文件结束）字符。
+- 0A：Unix 风格的换行符。
+
+​任何 PNG 解析器首先都必须检查这 8 个字节。​​
+
+
+PNG定义了两种类型的数据块，一种是称为关键数据块（critical chunk），这是必需的数据块，另一种叫做辅助数据块（ancillary chunks），这是可选的数据块。
+
+2. 数据块（Chunk）结构​
+
+每个数据块都有统一的格式，如下所示：
+
+```
+// 数据块结构
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+| Length (4 bytes)                              |  // 数据字段长度
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+| Chunk Type (4 bytes ASCII)                    |  // 块类型，如 IHDR
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+| Chunk Data (Length bytes)                     |  // 数据内容
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+| CRC32 (4 bytes)                               |  // 对整个块类型+数据的校验
++-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+```
+
+
+
+
+​- Length​：Data字段的字节数（32 位无符号整数，​大端序）。
+​- Chunk Type​：4 个 ASCII 字符，定义了块的用途。​大小写敏感​:      
+​    - 大写首字母​：关键块（解析器必须识别）
+    - 小写首字母​：辅助块（可忽略）
+    例如：IHDR是关键块，tEXt是辅助块。
+​- CRC​：循环冗余校验码，用于检测数据在传输过程中是否出错。
+
+
+3. 关键数据块（Critical Chunks）​​
+
+解析必须按顺序处理这些块：
+
+| 块类型 | 必须 | 说明 | 结构（Data 字段内容） |
+
+| ：--- | :--- | :--- | :--- |
+
+| ​IHDR​ | 是 | 文件头，包含图像基本信息 | Width(4B), Height(4B), BitDepth(1B), ColorType(1B), Compression(1B), Filter(1B), Interlace(1B) |
+
+| ​PLTE​ | 可选 | 调色板，定义索引颜色 | 一系列 RGB 三元组（R, G, B） |
+
+| ​IDAT​ | 是 | 图像数据，可存在多个 | 由 DEFLATE 压缩过的、经过过滤的像素数据流 |
+
+| ​IEND​ | 是 | 图像结束标记 | 无数据 |
+
+
+- IHDR：文件头数据块IHDR(header chunk)：它包含有PNG文件中存储的图像数据的基本信息，并要作为第一个数据块出现在PNG数据流中，而且一个PNG数据流中只能有一个文件头数据块。
+文件头数据块由13字节组成，包含图像宽度(4字节)、图像高度(4字节)、图像深度(1字节)、颜色类型(1字节)、压缩方法(1字节)、滤波器方法(1字节)、隔行扫描方法(1字节)
+
+- PLTE：调色板数据块PLTE(palette chunk)包含有与索引彩色图像(indexed-color image)相关的彩色变换数据，它仅与索引彩色图像有关，而且要放在图像数据块(image data chunk)之前。PLTE数据块是定义图像的调色板信息，PLTE可以包含1~256个调色板信息，每一个调色板信息由3个字节组成。
+- IDAT：图像数据块IDAT(image data chunk)：它存储实际的数据，在数据流中可包含多个连续顺序的图像数据块。IDAT存放着图像真正的数据信息，因此，如果能够了解IDAT的结构，我们就可以很方便的生成PNG图像。
+- IEND：图像结束数据IEND(image trailer chunk)：它用来标记PNG文件或者数据流已经结束，并且必须要放在文件的尾部。如果我们仔细观察PNG文件，我们会发现，文件的结尾12个字符看起来总应该是这样的：
+0000000049454E44AE426082，不难明白，由于数据块结构的定义，IEND数据块的长度总是0（00 00 00 00，除非人为加入信息），数据标识总是IEND（49 45 4E 44），因此，CRC码也总是AE 42 60 82。 
+
+除了表示数据块开始的IHDR必须放在最前面， 表示PNG文件结束的IEND数据块放在最后面之外，其他数据块的存放顺序没有限制。
+
+
+4. 辅助数据块（Ancillary Chunks）​​
+
+常见的有：
+
+| 块类型 | 说明 |
+
+| ：--- | :--- |
+
+| ​tEXt​| 文本信息数据块(textual data)，可存储任何文本信息（关键字+值），如软件、作者、版权。​你之前操作的 aigc:{}就可以写在这里。​​ |
+
+| ​zTXt​ | 压缩的文本数据块(comporessed textual data)。 |
+
+| ​iTXt​ | 国际化的 UTF-8 文本，可包含语言标签。例如中文、日文要写入该区域 |
+
+| ​tRNS​ | 透明度信息数据块(transparency)。对于索引色，它是调色板索引的 Alpha 数组；对于灰度/真彩色，它指定单一颜色为透明色。 |
+
+| ​gAMA​ | 图像y数据块(image gamma)指定图像伽马值，用于跨平台显示校正。 |
+
+| ​pHYs​ | 物理像素尺寸数据块(physical pixel dimensions)指定像素的物理尺寸（像素比/DPI）。 |
+
+| ​tIME​ | 图像最后修改时间数据块tIME(image last-modification time) |
+
+
+4.8.2 Chunk types
+Chunk types are four-byte sequences chosen so that they correspond to readable labels when interpreted in the ISO 646.IRV:1991 [ISO646] character set. The first four are termed critical chunks, which shall be understood and correctly interpreted according to the provisions of this specification. These are:
+
+- IHDR: image header, which is the first chunk in a PNG datastream.
+- PLTE: palette table associated with indexed PNG images.
+- IDAT: image data chunks.
+- IEND: image trailer, which is the last chunk in a PNG datastream.
+
+The remaining chunk types are termed ancillary chunk types, which encoders may generate and decoders may interpret.
+
+- Transparency information: tRNS (see 11.3.1 Transparency information).
+- Color space information: cHRM, gAMA, iCCP, sBIT, sRGB, cICP, mDCV (see 11.3.2 Color space information).
+- Textual information: iTXt, tEXt, zTXt (see 11.3.3 Textual information).
+- Miscellaneous information: bKGD, hIST, pHYs, sPLT, eXIf (see 11.3.4 Miscellaneous information).
+- Time information: tIME (see 11.3.5 Time stamp information).
+- Animation information: acTL, fcTL, fdAT (see 11.3.6 Animation information).
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/png_1.png?raw=true)             
+
+
+#### Textual information
+
+PNG provides the tEXt, iTXt, and zTXt chunks for storing text strings associated with the image, such as an image description or copyright notice. Keywords are used to indicate what each text string represents. Any number of such text chunks may appear, and more than one with the same keyword is permitted.
+
+11.3.3.1 Keywords and text strings
+The following keywords are predefined and should be used where appropriate.
+
+Table 21 Predefined keywords
+Keyword value	Description
+Title	Short (one line) title or caption for image
+Author	Name of image's creator
+Description	Description of image (possibly long)
+Copyright	Copyright notice
+Creation Time	Time of original image creation
+Software	Software used to create the image
+Disclaimer	Legal disclaimer
+Warning	Warning of nature of content
+Source	Device used to create the image
+Comment	Miscellaneous comment
+XML:com.adobe.xmp	Extensible Metadata Platform (XMP) information, formatted as required by the XMP specification [XMP]. The use of iTXt, with Compression Flag set to 0, and both Language Tag and Translated Keyword set to the null string, are recommended for XMP compliance.
+Collection	Name of a collection to which the image belongs. An image may belong to one or more collections, each named by a separate text chunk.
+Other keywords MAY be defined by any application for private or general interest.
+
+Keywords SHOULD be .
+
+- reasonably self-explanatory, since the aim is to let other human users understand what the chunk contains; and
+- chosen to minimize the chance that the same keyword is used for incompatible purposes by different applications.
+
+## 所有块
+The constraints on the positioning of the individual chunks are listed in Table 7 and illustrated diagrammatically for static images in Figure 11 and Figure 12, for animated images where the static image forms the first frame in Figure 13 and Figure 14, and for animated images where the static image is not part of the animation in Figure 15 and Figure 16. These lattice diagrams represent the constraints on positioning imposed by this specification. The lines in the diagrams define partial ordering relationships. Chunks higher up shall appear before chunks lower down. Chunks which are horizontally aligned and appear between two other chunk types (higher and lower than the horizontally aligned chunks) may appear in any order between the two higher and lower chunk types to which they are connected. The superscript associated with the chunk type is defined in Table 8. It indicates whether the chunk is mandatory, optional, or may appear more than once. A vertical bar between two chunk types indicates alternatives.
+
+Table 7 Chunk ordering rules
+Critical chunks
+(shall appear in this order, except PLTE is optional)
+Chunk name	Multiple allowed	Ordering constraints
+IHDR	No	Shall be first
+PLTE	No	Before first IDAT
+IDAT	Yes	Multiple IDAT chunks shall be consecutive
+IEND	No	Shall be last
+Ancillary chunks
+(need not appear in this order)
+Chunk name	Multiple allowed	Ordering constraints
+acTL	No	Before IDAT
+cHRM	No	Before PLTE and IDAT
+cICP	No	Before PLTE and IDAT
+gAMA	No	Before PLTE and IDAT
+iCCP	No	Before PLTE and IDAT. If the iCCP chunk is present, the sRGB chunk should not be present.
+mDCV	No	Before PLTE and IDAT.
+cLLI	No	Before PLTE and IDAT.
+sBIT	No	Before PLTE and IDAT
+sRGB	No	Before PLTE and IDAT. If the sRGB chunk is present, the iCCP chunk should not be present.
+bKGD	No	After PLTE; before IDAT
+hIST	No	After PLTE; before IDAT
+tRNS	No	After PLTE; before IDAT
+eXIf	No	Before IDAT
+fcTL	Yes	One may occur before IDAT; all others shall be after IDAT
+pHYs	No	Before IDAT
+sPLT	Yes	Before IDAT
+fdAT	Yes	After IDAT
+tIME	No	None
+iTXt	Yes	None
+tEXt	Yes	None
+zTXt	Yes	None
+
+
+我们发现上面也有eXif块:   
+#### eXif(Exchangeable Image File)  
+
+The data segment of the eXIf chunk contains an Exif profile in the format specified in "4.7.2 Interoperability Structure of APP1 in Compressed Data" of [CIPA-DC-008] except that the JPEG APP1 marker, length, and the "Exif ID code" described in 4.7.2(C), i.e., "Exif", NULL, and padding byte, are not included.
+
+The eXIf chunk size is constrained only by the maximum of 231-1 bytes imposed by the PNG specification. Only one eXIf chunk is allowed in a PNG datastream.
+
+The eXIf chunk contains metadata concerning the original image data. If the image has been edited subsequent to creation of the Exif profile, this data might no longer apply to the PNG image data. It is recommended that unless a decoder has independent knowledge of the validity of the Exif data, the data should be considered to be of historical value only. It is beyond the scope of this specification to resolve potential conflicts between data in the eXIf chunk and in other PNG chunks.
+
+
+
+PNG 格式中的 ​eXIf 块​ 和 ​zTXt 块​ 虽然都是用于存储元数据，但其设计目的、内部结构和适用场景有本质区别。
+
+
+
+好的，这是一个非常核心的问题。PNG 格式中的 ​eXIf 块​ 和 ​zTXt 块​ 虽然都是用于存储元数据，但其设计目的、内部结构和适用场景有本质区别。
+
+为了更直观地理解它们的区别，我们可以通过以下流程图来快速判断哪种块更适合你的需求：
+​eXIf 块 (Chunk Type: 65 58 49 66 -> ASCII "eXIf")​​
+
+​1. 作用​
+•
+​唯一目的​：用于在 PNG 图像中嵌入 ​Exif（Exchangeable Image File Format）数据。
+•
+​内容​：Exif 数据是一套高度标准化的元数据规范，主要用于记录数码照片的拍摄参数和设备信息。例如：
+•
+​相机参数​：光圈、快门速度、ISO、焦距、镜头型号
+•
+​设备信息​：相机制造商、型号
+•
+​时间信息​：照片原始拍摄时间（DateTimeOriginal）
+•
+​位置信息​：GPS 坐标（经度、纬度、高度）
+•
+​版权信息​：作者、版权说明
+•
+​缩略图​：嵌入式的小尺寸预览图
+
+
+
+你应该选择哪一个？​​
+•
+​要保存相机的拍摄信息（光圈、快门、GPS等）？​​
+•
+-> 使用 ​eXIf 块。（例如：用 exiftool -tagsFromFile source.jpg -all:all拷贝）
+•
+​要写入自己定义的文字、配置或标识（如 aigc:{"model":"GPT-4"}）？​​
+•
+-> 使用 ​zTXt 块。（例如：用 exiftool -zTXt:YourKey="Your Value"写入）
+​简单总结：eXIf 用于“相机说什么”，zTXt 用于“你想说什么”。​

From bc41ff07ee9ff28573c403d226c5ac6e5f98cbdd Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Mon, 22 Sep 2025 17:26:23 +0800
Subject: [PATCH 212/213] add pics

---
 .../GIF.md"                                   | 105 ++++++++++++++++
 .../HEIC.md"                                  |  42 +++++++
 .../JPEG.md"                                  |   4 +-
 .../PNG.md"                                   |  72 +++++------
 .../WebP.md"                                  |  87 +++++++++++++
 ...07\345\205\203\346\225\260\346\215\256.md" | 118 ++++++++++++++++++
 6 files changed, 389 insertions(+), 39 deletions(-)
 create mode 100644 "VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/GIF.md"
 create mode 100644 "VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/HEIC.md"
 create mode 100644 "VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/WebP.md"
 create mode 100644 "VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/\345\233\276\347\211\207\345\205\203\346\225\260\346\215\256.md"

diff --git "a/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/GIF.md" "b/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/GIF.md"
new file mode 100644
index 00000000..2631cf56
--- /dev/null
+++ "b/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/GIF.md"
@@ -0,0 +1,105 @@
+# GIF
+
+GIF(Graphics Interchange Format，图像文件存储格式)是CompuServe公司开发的。     
+
+它的核心特点是支持动画和透明度，但牺牲了色彩深度。
+
+1987年开发的GIF文件格式版本号是GIF87a，1989年进行了扩充，扩充后的版本号定义为GIF89a。    
+
+ 
+GIF图像文件以数据块(block)为单位来存储图像的相关信息。      
+
+
+一个GIF文件由表示图形/图像的数据块、数据子块以及显示图形/图像的控制信息块组成，称为GIF数据流(Data Stream)。      
+
+
+数据流中的所有控制信息块和数据块都必须在文件头(Header)和文件结束块(Trailer)之间 。
+ 
+GIF文件格式采用了LZW(Lempel-Ziv Walch)压缩算法来存储图像数据，定义了允许用户为图像设置背景的透明(transparency)属性。     
+
+此外，GIF文件格式可在一个文件中存放多幅彩色图形/图像。如果在GIF文件中存放有多幅图，它们可以像演幻灯片那样显示或者像动画那样演示。     
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/gif_1.png?raw=true)             
+ 
+
+## GIF文件结构
+
+GIF格式的文件结构整体上分为三部分：文件头、GIF数据流、文件结尾。其中，GIF数据流分为全局配置和图像块。
+
+
+GIF 文件由一系列数据块（Blocks）和扩展块（Extension Blocks）顺序组成。理解这个结构是解析元数据的关键。
+​- 文件头 (Header)​​：GIF87a或 GIF89a，标识文件版本： GIF署名（Signature）和版本号（Version）:GIF的前6个字节内容是GIF的署名和版本号。我们可以通过前3个字节判断文件是否为GIF格式，后3个字节判断GIF格式的版本。
+​- 逻辑屏幕描述符 (Logical Screen Descriptor)​​：定义画布大小和全局调色板信息。
+​- 全局调色板 (Global Color Table)​​：可选，定义所有帧共用的颜色表。
+​- 数据块​:      
+​    - 图像描述符 (Image Descriptor)​​：定义帧的图像区域和局部调色板信息。
+​    - 基于调色板的图像数据​：使用 LZW 压缩后的像素数据。
+​- 扩展块 (Extension Blocks)​​:       
+​    - 图形控制扩展 (Graphic Control Extension)​​：​最重要的扩展，包含帧的延迟时间（动画速度）、透明色索引和处置方法。
+​    - 注释扩展 (Comment Extension)​​：​这是存储纯文本元数据的主要位置！​​
+​    - 应用扩展 (Application Extension)​​：用于存储应用程序的特定信息（如 Netscape 的循环次数）。
+    - 明文扩展、等。
+​- 文件终结器 (Trailer)​​：一个分号 ;，标识文件结束。
+
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/gif_2.png?raw=true)             
+
+
+
+数据块可分成3类：控制块(Control Block)，图形描绘块(Graphic-RenderingBlock)和专用块(Special Purpose Block)。
+
+
+- 控制块: 控制块包含有用来控制数据流(Data Stream)或者设置硬件参数的信息，其成员包括:     
+    - GIF文件头(Header)
+    - 逻辑屏幕描述块(LogicalScreen Descriptor)
+    - 图形控制扩展块(GraphicControl Extension)
+    - 文件结束块(Trailer)
+
+- 图形描绘块：包含有用来描绘在显示设备上显示图形的信息和数据，其成员包括:      
+    - 图像描述块(ImageDescriptor)
+    - 无格式文本扩展块(PlainText Extension)
+    - 全局调色板、局部调色板、图像压缩数据和图像说明扩充块。
+
+ - 特殊用途数据块；包含有与图像处理无关的信息，其成员包括:    
+    - 注释扩展块(CommentExtension)
+    - 应用扩展块(ApplicationExtension)
+    - 除了在控制块中的逻辑屏幕描述块(Logical Screen Descriptor)和全局彩色表(GlobalColor Table)的作用范围是整个数据流(Data Stream)之外, 所有其他控制块仅跟在它们后面的图形描绘块。
+
+
+
+第二部分：元数据与 XMP 在 GIF 中的存储位置​
+这是一个非常关键的点，也是 GIF 与 JPEG、PNG 等格式最大的不同。
+​1. 元数据存储在哪里？​​
+GIF 格式没有为 EXIF、IPTC 或 XMP 这类现代、结构化的元数据设计标准的存储位置。它的元数据能力非常有限。
+​主要位置：注释扩展块 (Comment Extension)​​
+​块标识符​：0x21 0xFE
+​内容​：可以包含任意纯文本信息。这是存储版权信息、作者、描述等简单元数据的传统位置。
+​限制​：​只能是纯文本，没有键值对或结构化的标准。不同软件写入的格式完全不同。
+​次要位置：应用扩展块 (Application Extension)​​
+​块标识符​：0x21 0xFF
+​内容​：通常被特定应用程序用于存储私有数据。例如，NETSCAPE2.0应用扩展用于指定动画循环次数。
+​理论上，某个软件可以自定义一个应用扩展来存储 XMP 数据，但这绝非标准，其他软件很可能无法识别。
+
+
+​2. XMP 存储在哪里？​​
+​标准的、符合 Adobe XMP 规范的元数据通常不存在于 GIF 文件中。​​
+​原因​：GIF 格式诞生时，XMP 规范还不存在。GIF 的结构没有为容纳一大段 XML 数据而设计。
+​变通方案​：极少数专业软件（如 Adobe 的部分产品）​可能会将 XMP 数据作为一串很长的 XML 文本字符串写入到注释扩展 (Comment Extension)​​ 中。
+​现实情况​：​99.9% 的 GIF 文件不包含 XMP 数据。​​ 如果您的目标是读取 XMP，遇到 GIF 格式的概率极低。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/HEIC.md" "b/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/HEIC.md"
new file mode 100644
index 00000000..f2630848
--- /dev/null
+++ "b/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/HEIC.md"
@@ -0,0 +1,42 @@
+# HEIC
+
+
+HEIC（High Efficiency Image Container​ 高效图像容器）是苹果公司基于HEIF（高效图像文件格式）和HEVC（高效视频编码）技术开发的一种图像存储格式。自2017年iOS 11系统更新起，该格式被设定为iPhone 7及后续机型的默认照片存储格式，在相同画质下可将文件体积较JPEG减少约50%。
+
+
+High Efficiency Image File Format (HEIF, 发音为：heef)，由 Moving Picture Experts Group ( MPEG，即动态图像专家组) 于2013年开发，它基于ISOBMFF标准。HEIF是一个容器的图片格式，它可以包含图片和图片序列（一个文件可以包含不止一个图片）。当前的编码格式有：HEVC 和H.264/MPEG-4 AVC 两种，并且未来可能有新的编码格式加入。
+
+
+
+### HEIF和HEIC的关系
+
+- HEIF是规则、HEIC是实例。 
+- HEIF定义了如何存储图像、图像序列(动画、连拍)、音频和元数据。  
+- 而HEIC文件是遵循HEIF规则，并使用HEVC(H.265)编码来压缩图像数据的具体文件。   
+- .HEIC只是一个HEIF文件格式的一种扩展名，言外之意是：HEIF不仅有.HEIC这种扩展名，还有其它的，比如说: .HEIF和.avci，它们都是属于HEIF文件格式。当然，常见的只有.heif和.heic这两种，而.avci 很少见。
+
+
+
+HEIF 的强大源于其现代的设计理念，它本质上是一个基于 ISO 基础媒体文件格式（ISOBMFF）的容器，该格式也是 MP4 视频的基础。
+
+
+​1. 核心结构：'box' (盒子) 体系​
+
+HEIF/HEIC 文件由一系列嵌套的 ​​'box'​​（或称 'atom'） 组成。每个 'box' 都有一个头部（声明类型和大小）和负载（数据）。
+​- ftyp​：文件类型盒，标识这是一个 HEIC 文件。
+​- meta​：元数据盒，是最重要的盒子，包含了描述图像数据的各种信息。
+​- mdat​：媒体数据盒，存储实际的、经过压缩的图像比特流。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git "a/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/JPEG.md" "b/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/JPEG.md"
index bf05b544..ba93a123 100644
--- "a/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/JPEG.md"
+++ "b/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/JPEG.md"
@@ -5,7 +5,9 @@ JPEG（Joint Photographic Experts Group)，全称为联合图像专家小组，
 
 
 
-JPEG只描述一副图像如何转换成一组数据流，而不论这些字节存储在何种介质上。由独立JPEG组创立的另一个进阶标准，JFIF（JPEGFileInterchangeFormat，JPEG文件交换格式）则描述JPEG数据流如何生成适于电脑存储或传送的图像。在一般应用中，我们从数码相机等来源获得的“JPEG文件”，指的就是JFIF文件，有时是ExifJPEG文件。
+JPEG只描述一副图像如何转换成一组数据流，而不论这些字节存储在何种介质上。     
+
+由独立JPEG组创立的另一个进阶标准，JFIF（JPEG File Interchange Format，JPEG文件交换格式）则描述JPEG数据流如何生成适于电脑存储或传送的图像。在一般应用中，我们从数码相机等来源获得的“JPEG文件”，指的就是JFIF文件，有时是ExifJPEG文件。
 
 
 该格式采用有损压缩算法，通过牺牲部分画质换取较小文件体积，压缩过程包含色彩空间转换（RGB转YCbCr）、离散余弦变换（DCT）、量化和熵编码等步骤。
diff --git "a/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/PNG.md" "b/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/PNG.md"
index e85ed436..3732f554 100644
--- "a/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/PNG.md"
+++ "b/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/PNG.md"
@@ -12,24 +12,27 @@ PNG图像格式文件（或者称为数据流）由一个8字节的PNG文件署
 1. 文件署名域（Magic Number）​
 
 
-8字节的PNG文件署名域用来识别该文件是不是PNG文件。该域的值是：
+8字节的PNG文件署名域用来识别该文件是不是PNG文件。该域的值是:     
 
-十进制数137 80 78 71 13 10 26 10
-十六进制数 89 50 4e 47 0d 0a 1a 0a
+- 十进制数137 80 78 71 13 10 26 10
+- 十六进制数 89 50 4e 47 0d 0a 1a 0a
 
 
 
-​固定 8 字节：89 50 4E 47 0D 0A 1A 0A:       
+​固定8字节：89 50 4E 47 0D 0A 1A 0A:        
 - 89：高位设置，防止被误判为文本文件。
 - 50 4E 47：ASCII "PNG"。
 - 0D 0A：DOS 风格的换行符，用于换行符转换检测。
 - 1A：DOS 的 EOF（文件结束）字符。
 - 0A：Unix 风格的换行符。
 
-​任何 PNG 解析器首先都必须检查这 8 个字节。​​
+​任何PNG解析器首先都必须检查这8个字节。​​
 
 
-PNG定义了两种类型的数据块，一种是称为关键数据块（critical chunk），这是必需的数据块，另一种叫做辅助数据块（ancillary chunks），这是可选的数据块。
+PNG定义了两种类型的数据块:    
+
+- 一种是称为关键数据块（critical chunk），这是必需的数据块
+- 另一种叫做辅助数据块（ancillary chunks），这是可选的数据块。
 
 2. 数据块（Chunk）结构​
 
@@ -76,12 +79,14 @@ PNG定义了两种类型的数据块，一种是称为关键数据块（critical
 | ​IEND​ | 是 | 图像结束标记 | 无数据 |
 
 
-- IHDR：文件头数据块IHDR(header chunk)：它包含有PNG文件中存储的图像数据的基本信息，并要作为第一个数据块出现在PNG数据流中，而且一个PNG数据流中只能有一个文件头数据块。
+- IHDR：文件头数据块IHDR(header chunk):     
+
+它包含有PNG文件中存储的图像数据的基本信息，并要作为第一个数据块出现在PNG数据流中，而且一个PNG数据流中只能有一个文件头数据块。     
 文件头数据块由13字节组成，包含图像宽度(4字节)、图像高度(4字节)、图像深度(1字节)、颜色类型(1字节)、压缩方法(1字节)、滤波器方法(1字节)、隔行扫描方法(1字节)
 
-- PLTE：调色板数据块PLTE(palette chunk)包含有与索引彩色图像(indexed-color image)相关的彩色变换数据，它仅与索引彩色图像有关，而且要放在图像数据块(image data chunk)之前。PLTE数据块是定义图像的调色板信息，PLTE可以包含1~256个调色板信息，每一个调色板信息由3个字节组成。
-- IDAT：图像数据块IDAT(image data chunk)：它存储实际的数据，在数据流中可包含多个连续顺序的图像数据块。IDAT存放着图像真正的数据信息，因此，如果能够了解IDAT的结构，我们就可以很方便的生成PNG图像。
-- IEND：图像结束数据IEND(image trailer chunk)：它用来标记PNG文件或者数据流已经结束，并且必须要放在文件的尾部。如果我们仔细观察PNG文件，我们会发现，文件的结尾12个字符看起来总应该是这样的：
+- PLTE: 调色板数据块PLTE(palette chunk)包含有与索引彩色图像(indexed-color image)相关的彩色变换数据，它仅与索引彩色图像有关，而且要放在图像数据块(image data chunk)之前。PLTE数据块是定义图像的调色板信息，PLTE可以包含1~256个调色板信息，每一个调色板信息由3个字节组成。    
+- IDAT: 图像数据块IDAT(image data chunk)：它存储实际的数据，在数据流中可包含多个连续顺序的图像数据块。IDAT存放着图像真正的数据信息，因此，如果能够了解IDAT的结构，我们就可以很方便的生成PNG图像。
+- IEND: 图像结束数据IEND(image trailer chunk)：它用来标记PNG文件或者数据流已经结束，并且必须要放在文件的尾部。如果我们仔细观察PNG文件，我们会发现，文件的结尾12个字符看起来总应该是这样的：
 0000000049454E44AE426082，不难明白，由于数据块结构的定义，IEND数据块的长度总是0（00 00 00 00，除非人为加入信息），数据标识总是IEND（49 45 4E 44），因此，CRC码也总是AE 42 60 82。 
 
 除了表示数据块开始的IHDR必须放在最前面， 表示PNG文件结束的IEND数据块放在最后面之外，其他数据块的存放顺序没有限制。
@@ -89,7 +94,7 @@ PNG定义了两种类型的数据块，一种是称为关键数据块（critical
 
 4. 辅助数据块（Ancillary Chunks）​​
 
-常见的有：
+常见的有:      
 
 | 块类型 | 说明 |
 
@@ -159,6 +164,7 @@ Keywords SHOULD be .
 - chosen to minimize the chance that the same keyword is used for incompatible purposes by different applications.
 
 ## 所有块
+
 The constraints on the positioning of the individual chunks are listed in Table 7 and illustrated diagrammatically for static images in Figure 11 and Figure 12, for animated images where the static image forms the first frame in Figure 13 and Figure 14, and for animated images where the static image is not part of the animation in Figure 15 and Figure 16. These lattice diagrams represent the constraints on positioning imposed by this specification. The lines in the diagrams define partial ordering relationships. Chunks higher up shall appear before chunks lower down. Chunks which are horizontally aligned and appear between two other chunk types (higher and lower than the horizontally aligned chunks) may appear in any order between the two higher and lower chunk types to which they are connected. The superscript associated with the chunk type is defined in Table 8. It indicates whether the chunk is mandatory, optional, or may appear more than once. A vertical bar between two chunk types indicates alternatives.
 
 Table 7 Chunk ordering rules
@@ -206,42 +212,32 @@ The eXIf chunk contains metadata concerning the original image data. If the imag
 
 
 
-PNG 格式中的 ​eXIf 块​ 和 ​zTXt 块​ 虽然都是用于存储元数据，但其设计目的、内部结构和适用场景有本质区别。
+PNG格式中的eXIf块​和​zTXt块​虽然都是用于存储元数据，但其设计目的、内部结构和适用场景有本质区别。
 
 
-
-好的，这是一个非常核心的问题。PNG 格式中的 ​eXIf 块​ 和 ​zTXt 块​ 虽然都是用于存储元数据，但其设计目的、内部结构和适用场景有本质区别。
+PNG 格式中的eXIf块​和zTXt块​ 虽然都是用于存储元数据，但其设计目的、内部结构和适用场景有本质区别。
 
 为了更直观地理解它们的区别，我们可以通过以下流程图来快速判断哪种块更适合你的需求：
 ​eXIf 块 (Chunk Type: 65 58 49 66 -> ASCII "eXIf")​​
 
 ​1. 作用​
-•
-​唯一目的​：用于在 PNG 图像中嵌入 ​Exif（Exchangeable Image File Format）数据。
-•
-​内容​：Exif 数据是一套高度标准化的元数据规范，主要用于记录数码照片的拍摄参数和设备信息。例如：
-•
-​相机参数​：光圈、快门速度、ISO、焦距、镜头型号
-•
-​设备信息​：相机制造商、型号
-•
-​时间信息​：照片原始拍摄时间（DateTimeOriginal）
-•
-​位置信息​：GPS 坐标（经度、纬度、高度）
-•
-​版权信息​：作者、版权说明
-•
-​缩略图​：嵌入式的小尺寸预览图
-
-
-
-你应该选择哪一个？​​
-•
+唯一目的​：用于在 PNG 图像中嵌入 ​Exif（Exchangeable Image File Format）数据。
+​内容​：Exif 数据是一套高度标准化的元数据规范，主要用于记录数码照片的拍摄参数和设备信息。例如:     
+​- 相机参数​：光圈、快门速度、ISO、焦距、镜头型号
+​- 设备信息​：相机制造商、型号
+​- 时间信息​：照片原始拍摄时间（DateTimeOriginal）
+​- 位置信息​：GPS 坐标（经度、纬度、高度）
+​- 版权信息​：作者、版权说明
+​- 缩略图​：嵌入式的小尺寸预览图
+
+
+
+### 应该选择哪一个？​​
+
 ​要保存相机的拍摄信息（光圈、快门、GPS等）？​​
-•
 -> 使用 ​eXIf 块。（例如：用 exiftool -tagsFromFile source.jpg -all:all拷贝）
-•
+
 ​要写入自己定义的文字、配置或标识（如 aigc:{"model":"GPT-4"}）？​​
-•
 -> 使用 ​zTXt 块。（例如：用 exiftool -zTXt:YourKey="Your Value"写入）
+
 ​简单总结：eXIf 用于“相机说什么”，zTXt 用于“你想说什么”。​
diff --git "a/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/WebP.md" "b/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/WebP.md"
new file mode 100644
index 00000000..fa55a758
--- /dev/null
+++ "b/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/WebP.md"
@@ -0,0 +1,87 @@
+# WebP
+
+WebP是一种图片格式，它使用VP8关键帧编码，以有损方式压缩图像数据或WebP无损编码。    
+
+除了 WebP 的基本用例（即包含编码为 VP8 关键帧的单个图片的文件）之外，WebP 容器（即 WebP 的 RIFF 容器）还支持其他功能。WebP 容器提供 对以下各项的支持:    
+
+- 无损压缩：可以使用 WebP 无损格式对图片进行无损压缩。
+
+- 元数据：图片中可能有存储于可交换图片文件中的元数据 格式 (Exif) 或可扩展元数据平台 (XMP) 格式。
+
+- 透明度：图片可以具有透明度，即 alpha 通道。
+
+- 颜色配置文件：图片可能具有如国际色彩联盟所述的嵌入式 ICC 配置文件。
+
+- 动画：同一张图片可能包含多个帧，帧之间会暂停播放； 使其成为动画
+
+
+在图片（和多媒体）文件格式中，​RIFF​ 是一个容器格式，或者说是一种文件结构规范，而不是一种图片编码格式本身。
+
+您可以把它理解为一个盒子或文件夹，里面可以装各种不同的东西（图片数据、音频数据、元数据等）。
+
+### RIFF
+
+RIFF​ 的全称是 ​Resource Interchange File Format​（资源交换文件格式），由微软公司在1991年提出。    
+
+它的核心思想是：​所有数据都存储在称为“块（Chunks）”的结构中。
+
+#### RIFF 文件的结构
+
+一个典型的 RIFF 文件由以下几个部分组成:     
+
+​- RIFF 头（Header）​​:      
+    - RIFF（4字节）：固定标识，表明这是一个RIFF格式的文件。
+    - 文件大小（4字节）：从下一个字节开始到文件结尾的总大小。
+    - 格式类型（4字节）：用四个字符代码（FOURCC）定义文件的具体类型，例如 AVI或 WAVE。
+​- 块（Chunks）​​:     
+
+在文件头之后，就是一系列的数据块。
+每个块都有自己的头和信息:     
+- 块ID（4字节）：用四个字符代码标识这个块是什么（例如 fmt是格式块，data是数据块）。
+- 块大小（4字节）：该块数据部分的大小。
+- 块数据（可变长度）：实际的数据内容。
+
+​- 列表块（LIST Chunks）​​:     
+
+这是一种特殊的块，它本身内部又可以包含其他多个子块，用于更复杂的数据组织。
+
+​用个比喻来说:    
+
+一个 RIFF 文件就像一个行李箱（RIFF Container）​，上面贴着一个标签写着“摄影器材”（格式类型= PHOT）。箱子里面有几个收纳盒（Chunks）​，每个收纳盒上又贴着“镜头”、“机身”、“电池”等标签（块ID）。这样就可以井井有条地存放所有东西。
+
+
+#### 与图片格式的关系
+
+RIFF 作为一种容器，被用于多种图片格式。最著名的例子就是WebP:     
+
+一个典型的 WebP 文件结构如下:    
+```
+RIFF Header (标识这是一个RIFF文件，格式类型为 'WEBP')
+|
++-- VP8 (或 VP8L, VP8X) Chunk (存储实际的图片编码数据)
+|
++-- ANIM Chunk (可选，如果存在则表示是动画WebP)
+|
++-- ANMF Chunk (可选，动画帧数据)
+|
++-- EXIF Chunk (可选，存储EXIF元数据)
+|
++-- XMP  Chunk (可选，存储XMP元数据)
+|
++-- ... (其他可选块)
+```
+
+
+WebP的强大之处在于它利用了RIFF容器的可扩展性，可以轻松的在一个文件中包含静态图、动画、Alpha透明度、元数据等多种信息。   
+
+
+
+简单来说:   
+
+- RIFF: 是一种文件结构或容器规范，可以比喻成行李箱
+- JPEG、PNG: 是一种图片编码格式，可以比喻成一种折叠衣服的方法。注意PNG拥有自己独特的、与RIFF无关的容器结构。   
+- WebP: 使用RIFF容器来包装VP8编码数据的图片格式，可以比喻成用行李箱装了特定方法折叠好的衣服
+
+
+
+
diff --git "a/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/\345\233\276\347\211\207\345\205\203\346\225\260\346\215\256.md" "b/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/\345\233\276\347\211\207\345\205\203\346\225\260\346\215\256.md"
new file mode 100644
index 00000000..1748eb73
--- /dev/null
+++ "b/VideoDevelopment/\345\233\276\347\211\207\346\240\274\345\274\217/\345\233\276\347\211\207\345\205\203\346\225\260\346\215\256.md"
@@ -0,0 +1,118 @@
+# 图片元数据
+
+简单来说，元数据就是有关数据的数据。      
+
+
+实际上，元数据是关于文件的一组标准化信息，如作者姓名、分辨率、色彩空间、版权以及应用于文件的关键字。例如，多数摄像机会在视频文件中附加一些基本信息，如日期、持续时间和文件类型。
+
+
+
+
+## 元数据分类
+
+对于数码图像，目前常见的元数据有EXIF、IPTC、XMP三种:   
+
+- EXIF: 通常被数码相机在拍摄照片时自动添加，比如相机型号、镜头、曝光、图片尺寸等信息
+- IPTC: 比如图片标题、关键字、说明、作者、版权等信息。主要是由人工在后期通过软件写入的数据。
+- XMP: XMP实际上是一种元数据存储和管理的标准，可以将Exif，IPTC或其他的数据都按XMP统一的格式存放在图像文件中。
+- ICC: 色彩管理、色彩空间
+
+### 1.EXIF/标准元数据
+
+EXIF（Exchangeable Image File Format，可交换图像文件格式）
+
+这是最常见的元数据类型，主要记录拍摄参数、设备信息、时间、位置等数据。以下是常见 EXIF 信息分类：
+
+- 拍摄参数类:  
+    - 曝光时间
+    - 焦距
+    - ISO感光度等
+
+- 时间与位置
+    - 拍摄时间
+    - 文件创建时间
+    - GPS经纬度
+    - 海拔
+
+- 设备信息
+    - Make: 相机/手机制造商(例如Apple)
+    - Model: 设备型号(如iPhone14)
+    - LensModel: 镜头型号
+
+- 图片属性
+    - 图片宽高
+    - Orientation: 拍摄方向
+    - 压缩方式
+    - 缩略图数据(如有)    
+
+### 2. ICC/色彩管理的核心
+ICC（International Color Consortium，国际色彩联盟）元数据是嵌入在图像文件中的色彩管理数据，用于确保不同设备（相机、显示器、打印机）呈现的色彩一致性。
+
+### 3. XMP/图像的可扩展元数据
+
+[XMP](https://helpx.adobe.com/cn/after-effects/using/xmp-metadata.html)Extensible Metadata Platform，可扩展元数据平台）是 Adobe 开发的一种标准化元数据格式，用于嵌入到图片、视频、PDF 等文件中。它比 EXIF 更灵活，支持自定义字段和结构化数据，具有高度可扩展性。   
+
+核心特点​:   
+
+- 基于RDF/XML格式
+    - XML: 语法规则，提供了语法(如何写)
+    - RDF: 数据模型，提供了语义(什么意思)，确保不同系统、不同厂商、不同标准的元数据都能够共存且被正确理解
+    - 总结: RDF在XML提供的语法基础上，增加了语义层，使得数据不仅仅是结构化的，更是有意义且可互联的。    
+- 支持自定义命名空间和属性
+- 可以嵌入到多种文件格式中
+- 支持复杂数据结构（数组、嵌套对象）
+
+
+例如: 在元数据中增加一个信息，如果没有 RDF，只是自定义 XML：:  
+```
+<metadata>
+    <TC260:AIGC>{"Label":"value1"}</TC260:AIGC>
+</metadata>
+```
+问题​：其他系统看不懂 TC260:AIGC是什么意思，无法理解和重用这个数据。
+
+使用 RDF (XMP 的实际做法):
+
+```
+<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+         xmlns:tc260="http://www.tc260.org.cn/ns/AIGC/1.0/">
+    <rdf:Description rdf:about="">
+        <tc260:AIGC>{"Label":"value1"}</tc260:AIGC>
+    </rdf:Description>
+</rdf:RDF>
+```
+优势​:   
+​
+- 明确语义​：通过 xmlns:tc260="http://www.tc260.org.cn/ns/AIGC/1.0/"明确指出了 tc260:AIGC的含义是由该命名空间定义的。任何人都可以访问这个 URI 来了解 AIGC属性的正式定义。
+​- 可扩展性​：可以轻松混合来自不同来源的元数据。例如，可以同时包含 Dublin Core 的标题和您自定义的 TC260 标签，而不会产生冲突。
+​- 机器可读​：计算机程序可以自动解析和理解这些关系，实现数据的互联和智能处理。
+
+
+
+### 4. IPTC
+
+IPTC(International Press Telecommunications Council)，
+最初为新闻行业设计，主要用于描述图片内容和版权信息。   
+
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/metadata_1.png?raw=true)             
+
+
+EXIF里面保存的是二进制数据，而且基本都是固定的字段，主要应用于相机参数、时间等。    
+
+XMP中则是XML文本而且支持扩展性，可用于编辑元数据、版权等。   
+
+
+
+
+
+
+
+
+
+
+
+
+
+

From 01f25a054328f167105ca5f725efbb5ea7da1e39 Mon Sep 17 00:00:00 2001
From: CharonChui <charon.chui@gmail.com>
Date: Wed, 24 Dec 2025 16:08:48 +0800
Subject: [PATCH 213/213] update

---
 .../Componse\344\275\277\347\224\250.md"      | 130 +++++
 .../KMP\345\274\200\345\217\221.md"           |   4 -
 .../python3\345\205\245\351\227\250.md"       | 458 +++++++++++++++++-
 JavaKnowledge/shell.md                        |  10 +
 "Jetpack/ui/\345\257\271\346\257\224.md"      |  68 +++
 MobileAIModel/AIGC.md                         |  49 ++
 MobileAIModel/RAG.md                          |  75 +++
 MobileAIModel/TensorFlow Lite                 |   5 +
 .../\345\244\247\346\250\241\345\236\213.md"  | 394 +++++++++++++++
 .../\351\242\204\350\256\255\347\273\203.md"  |  11 +
 10 files changed, 1198 insertions(+), 6 deletions(-)
 create mode 100644 "AdavancedPart/Componse\344\275\277\347\224\250.md"
 create mode 100644 "Jetpack/ui/\345\257\271\346\257\224.md"
 create mode 100644 MobileAIModel/AIGC.md
 create mode 100644 MobileAIModel/RAG.md
 create mode 100644 "MobileAIModel/\345\244\247\346\250\241\345\236\213.md"
 create mode 100644 "MobileAIModel/\351\242\204\350\256\255\347\273\203.md"

diff --git "a/AdavancedPart/Componse\344\275\277\347\224\250.md" "b/AdavancedPart/Componse\344\275\277\347\224\250.md"
new file mode 100644
index 00000000..6a2f0449
--- /dev/null
+++ "b/AdavancedPart/Componse\344\275\277\347\224\250.md"
@@ -0,0 +1,130 @@
+Compose使用
+===
+
+传统 Android UI 开发采用命令式模型，即通过命令驱动视图变化：findViewById 查找控件、设置属性、处理交互逻辑。代码经常伴随着多个职责耦合在一起，结构混乱，易错难测。
+
+Compose 则采用声明式模型：界面即状态的函数表达。当状态改变时，对应的 Composable 自动重新组合（Recompose）并刷新界面。这种模式更贴近现代前端（如 React/Vue）的理念。
+
+无需关心视图更新逻辑，只要状态变化，界面自然重绘，大幅降低 UI 层复杂度。
+
+
+1.3 开发效率提升点
+
+代码量平均减少 40%-60%
+
+无需 ViewHolder、Adapter 逻辑
+
+状态与 UI 同步更新，避免 UI 状态丢失
+
+支持实时预览（@Preview）、热重载、即时调试
+
+
+我们在公司项目中构建了性能对比 Benchmark（测试设备为 Pixel 6、Android 13）：
+
+2.1 滚动列表对比：RecyclerView vs LazyColumn
+
+指标  RecyclerView    LazyColumn (Compose)    差异
+平均帧率
+48 fps
+58 fps
++20%
+内存占用
+28 MB
+22 MB
+-21%
+首次绘制耗时
+320 ms
+210 ms
+-34%
+
+
+2.2 原因解析：Compose 更快的秘密
+
+SlotTable：结构快照树
+Compose 编译器会将 Composable 函数转换为组装 SlotTable 的代码。SlotTable 是一种高效的数据结构，存储了 Composable 树的结构快照。当状态发生变化时，Compose 通过对比 SlotTable 的版本，精确地定位变化范围，从而进行最小代价的重组操作（recomposition）。这一过程通过 Composer 对 Slot 表的操作实现，避免了冗余 UI 节点更新。
+
+重组与 Group 管理机制
+Compose 使用 Group（startGroup/endGroup）对 Composable 调用进行打包与标识，每个重组区域会通过重新执行对应的 Group 来进行更新，确保仅变更部分被执行。此机制在 RecomposeScopeImpl 中有体现，它能追踪每个状态依赖的作用域，从而提升重组精度。
+
+无需 ViewHolder 回收
+传统 RecyclerView 需要手动管理视图缓存与回收，而 Compose 自动处理 Composition 节点生命周期。Compose Compiler 会生成高效的 Slot 操作指令，通过“skip、reuse”策略对 UI 层进行精准控制，避免重复创建与销毁。
+
+Skia 图形引擎与 RenderNode
+Compose 绘制层基于 Skia 引擎，使用 DrawModifier 直接对 Canvas 进行渲染。它不会像传统 View 那样层层嵌套测量布局与绘制流程，而是采用测量（MeasurePass）-> 布局（LayoutPass）-> 绘制（DrawPass）的管线逻辑，通过 LayoutNode 驱动 Compose UI 树的变化。同时 Compose Layout 使用 SubcomposeLayout 实现异步测量能力，提高复杂嵌套组件的性能表现。
+
+渲染流程对比
+阶段  View System Compose
+布局树管理
+View/ViewGroup 层级
+LayoutNode 节点
+渲染方式
+Choreographer + RenderThread
+FrameClock + Skia 渲染
+状态追踪
+手动触发 invalidate
+Snapshot 自动追踪 + Diff Patch
+更新路径
+requestLayout → measure/layout
+Recomposer + SlotTable 重组
+
+注意：Compose 并非所有场景都一定更快，特别是复杂嵌套、过度组合场景仍需谨慎使用。
+
+### 简介
+
+Jetpack Compose 是用于构建 Android 界面的新款工具包。
+
+
+Jetpack Compose 是用于构建原生 Android 界面的新工具包。它使用更少的代码、强大的工具和直观的 Kotlin API，可以帮助您简化并加快 Android 界面开发，打造生动而精彩的应用。它可让您更快速、更轻松地构建 Android 界面。
+
+
+编写更少的代码会影响到所有开发阶段：作为代码撰写者，需要测试和调试的代码会更少，出现 bug 的可能性也更小，您就可以专注于解决手头的问题；作为审核人员或维护人员，您需要阅读、理解、审核和维护的代码就更少。
+
+与使用 Android View 系统（按钮、列表或动画）相比，Compose 可让您使用更少的代码实现更多的功能。无论您需要构建什么内容，现在需要编写的代码都更少了。以下是我们的一些合作伙伴的感想：
+
+“对于相同的 Button 类，代码的体量要小 10 倍。”(Twitter)
+“使用 RecyclerView 构建的任何屏幕（我们的大部分屏幕都使用它构建）的大小也显著减小。”(Monzo)
+““只需要很少几行代码就可以在应用中创建列表或动画，这一点令我们非常满意。对于每项功能，我们编写的代码行更少了，这让我们能够将更多精力放在为客户提供价值上。”(Cuvva)
+编写代码只需要采用 Kotlin，而不必拆分成 Kotlin 和 XML 部分：“当所有代码都使用同一种语言编写并且通常位于同一文件中（而不是在 Kotlin 和 XML 语言之间来回切换）时，跟踪变得更容易”(Monzo)
+
+无论您要构建什么，使用 Compose 编写的代码都很简洁且易于维护。“Compose 的布局系统在概念上更简单，因此可以更轻松地推断。查看复杂组件的代码也更轻松。”(Square)
+
+
+
+Compose 使用声明性 API，这意味着您只需描述界面，Compose 会负责完成其余工作。这类 API 十分直观 - 易于探索和使用：“我们的主题层更加直观，也更加清晰。我们能够在单个 Kotlin 文件中完成之前需要在多个 XML 文件中完成的任务，这些 XML 文件负责通过多个分层主题叠加层定义和分配属性。”(Twitter)
+
+
+Compose 与您所有的现有代码兼容：您可以从 View 调用 Compose 代码，也可以从 Compose 调用 View。大多数常用库（如 Navigation、ViewModel 和 Kotlin 协程）都适用于 Compose，因此您可以随时随地开始采用。“我们集成 Compose 的初衷是实现互操作性，我们发现这件事情已经‘水到渠成’。我们不必考虑浅色模式和深色模式等问题，整个体验无比顺畅。”(Cuvva)
+
+
+为现有应用设置 Compose
+
+首先，使用 Compose Compiler Gradle 插件配置 Compose 编译器。
+
+然后，将以下定义添加到应用的 build.gradle 文件中：
+```
+android {
+    buildFeatures {
+        compose = true
+    }
+}
+```
+在 Android BuildFeatures 代码块内将 compose 标志设置为 true 会在 Android Studio 中启用 Compose 功能。
+
+
+Compose vs HarmonyOS ArkUI 对比分析
+
+
+Jetpack Compose 和 HarmonyOS ArkUI 均采用声明式 UI 编程范式，面向多设备场景的响应式 UI 构建，二者在理念相通的同时，在架构设计、状态模型、渲染机制等方面有显著区别。
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/compose_vs_arkui.png?raw=true)        
+
+
+Jetpack Compose 是围绕可组合函数构建的。这些函数可让您以程序化方式定义应用的界面，只需描述应用界面的外观并提供数据依赖项，而不必关注界面的构建过程（初始化元素、将其附加到父项等）。如需创建可组合函数，只需将 @Composable 注解添加到函数名称中即可。
+
+
+    	
+---
+
+- 邮箱 ：charon.chui@gmail.com  
+- Good Luck! 
\ No newline at end of file
diff --git "a/AdavancedPart/KMP\345\274\200\345\217\221.md" "b/AdavancedPart/KMP\345\274\200\345\217\221.md"
index b4d7e54c..d4faa6f6 100644
--- "a/AdavancedPart/KMP\345\274\200\345\217\221.md"
+++ "b/AdavancedPart/KMP\345\274\200\345\217\221.md"
@@ -22,10 +22,6 @@ Kotlin 语言的编译，与向不同的平台转化，明显是不同的职责
 Frontend 会将 AST 进一步转换为 Kotlin IR（Kotlin Intermediate Representation），是 Kotlin 源代码的中间表示形式，Kotlin IR 是编译器前端的输出，也是编译器后端的输入。
 Backend 则会吧 Kotlin IR 转换为不同平台的中间表示形式，最终生成目标代码。
 
-作者：A0微声z
-链接：https://juejin.cn/post/7507888457705275455
-来源：稀土掘金
-著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
 
     	
 ---
diff --git "a/JavaKnowledge/python3\345\205\245\351\227\250.md" "b/JavaKnowledge/python3\345\205\245\351\227\250.md"
index 1f65e19f..35233217 100644
--- "a/JavaKnowledge/python3\345\205\245\351\227\250.md"
+++ "b/JavaKnowledge/python3\345\205\245\351\227\250.md"
@@ -7,6 +7,37 @@ message = "Hello World"
 print(message)
 ```
 
+常量: python中一版约定名字全为大写的就是常量。   
+
+## bool
+
+
+bool类型只有True和False，用于真假判断。   
+
+python3中,bool是int的子类，True和False可以和数字相加。  
+
+True == 1、False == 0 会返回True
+
+is运算符用于比较两个对象的身份(即它们是否是同一个对象，是否在内存中占据相同的问题)，而不是比较它们的值。  
+
+```python3
+print(True == 1) # True
+print(False == 0) # True
+
+print(True is 1) # False
+print(False is 0) # False
+
+```
+
+
+在python中，能够解释为假的值不只有False，还有:   
+
+- None
+- 0
+- 0.0
+- False
+- 所有的空容器(空列表、空元组、空字典、空集合、空字符串)     
+
 ## 字符串
 
 字符串就是一系列字符。在Python中，用引号括起来的都是字符串，其中的引号可以是单引号，也可以是双引号。例如:     
@@ -102,6 +133,33 @@ message = "Happy" + str(age) + "Birthday"
 print(message)
 ```
 
+### 自动类型转换(隐式转换)
+
+对两种不同类型的数据进行运算，较小的数据类型(整数)就会转换为较大的数据类型(浮点数)以免数据丢失，计算结果为浮点型:  
+
+```python3
+num1 = 2
+num2 = 3.0
+
+print(num1 + num2) # 5.0
+
+
+
+num1 = 9
+num2 = 1
+print(num1 / num2) #9.0
+```
+注意: 特别的，两个整形进行除法运算时结果也是浮点型。  
+
+
+
+
+
+
+
+
+
+
 
 ## 注释
 
@@ -187,6 +245,15 @@ for bcy in bicycles:
 print('end')
 ```
 
+#### 使用enumerate()可以同时获取列表的下标和元素。
+
+```python
+lst = [1, 2, 3]
+
+for i, value in enumerate(lst):
+    print(i, value)
+```
+
 
 ### 切片
 
@@ -253,6 +320,20 @@ else:
     print("cost $10")
 ```
 
+### match case语句
+
+```python3
+match x:
+    case a:
+        xxxx
+    case b:
+        xxxx
+    case _:
+        xxx
+```
+在python3.10版本新增了match case的条件判断方式，match后的对象会依次与case后的内容匹配，匹配成功则执行相应的语句，否则跳过，其中_可以匹配一切。  
+
+
 ### 相等判断
 ```python
 car = 'Audi'
@@ -303,6 +384,14 @@ print(alien['xPos'])
 del alien['points']
 ```
 
+字典的其他写法:   
+
+```python3
+dict4 = dict(name="Bob", age=20, gender="female")
+dict5 = dict([("name", "Tom"), ("age", 22), ("gender", "male")])
+```
+
+
 ### 遍历字典
 
 - keys()方法返回所有的键列表。
@@ -395,6 +484,10 @@ while current_number <= 5:
 
 同样while中也可以结合使用break、continue等，和Java基本一样。  
 
+## 缩进
+
+在python3中，代码块的结束不像其他一些编程语言(如c、java等)使用大括号{}来明确界定，而是通过缩进来表示。PEP8建议每级缩进都使用四个空格。
+
 
 ## 函数
 
@@ -415,6 +508,18 @@ print(greet_user(username='lili'))
 
 上面三个引号的部分是文档字符串格式，用于简要的阐述其功能的注释。     
 
+### 函数的参数传递
+
+- 不可变类型     
+    类似c++的值传递，如整数、字符串、元祖。如fun(a)，传递的只是a的值，没有影响a对象本身，比如在fun(a)内部修改a的值，只是修改了另一个复制的对象，不会影响a本身。 
+- 可变类型    
+    类似c++的引用传递，如列表、字典。如fun(la)，则是将la真正的传过去，修改后fun外部的la也会受影响  
+
+
+python中一切都是对象，严格意义上我们不能说值传递还是引用传递，我们应该说传可变对象和不可变对象。   
+
+
+
 ### 函数列表参数副本
 
 将列表传递给函数后，函数就可对其进行修改。在函数中对这个列表所做的任何修改都是永久性的，这让你能够高效地处理大量的数据。
@@ -461,6 +566,23 @@ make_pizza('mushrooms','green peppers','extra cheese')
 看起来，Python的参数传递方式是整齐划一的，但具体情况还得具体分析。在Python中，对象大致分为两类，即可变对象和不可变对象。可变对象包括字典、列表及集合等。不可变对象包括数值、字符串、不变集合等。如果参数传递的是可变对象，传递的就是地址，形参的地址就是实参的地址，如同“两套班子，一套人马”一样，修改了函数中的形参，就等同于修改了实参。如果参数传递的是不可变对象，为了维护它的“不可变”属性，函数内部不得不“重构”一个实参的副本。此时，实参的副本（即形参）和主调用函数提供的实参在内存中分处于不同的位置，因此对函数形参的修改，并不会对实参造成任何影响，在结果上看起来和传值一样。
 
 
+### 解包传参
+
+若函数的形参是定长参数，可以通过`*`和`**`对列表、元组、字典等解包传参。  
+
+```python3
+def func(a, b, c):
+    return a + b + c
+
+tuple1 = (1, 2, 3)
+
+print(func(*tuple))
+dict1 = {"a":1, "b":2, "c":3}
+
+print(func(**dict1))
+``` 
+
+
 
 ### 将函数存储在模块中
 
@@ -532,6 +654,70 @@ p.make_pizza(16,'pepperoni')
 p.make_pizza(12,'mushrooms','green peppers','extra cheese')
 ```
 
+### __name__
+
+在python中，__name__是一个特殊的内置变量:    
+
+- 当一个python文件被直接运行时，该文件的__name__属性为"__main__"
+- 当一个python文件作为模块被导入时，__name__属性会被设置为该模块的名称(即文件名，不包括.py后缀)
+
+例如有时我们在模块中写一些测试代码，当模块被其他文件导入时这些测试代码会被执行。
+例如我们在main.py中导入my_add.py中，会发现my_add中的测试代码被执行了。这个时候使用__name__ == "__main__"判断就能避免测试代码被执行。  
+
+
+
+
+
+
+### 全局变量和局部变量
+
+
+定义在函数内部的变量拥有一个局部作用域，定义在函数外的变量拥有全局作用域，局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。   
+
+#### global关键字
+
+使用global关键字修改全局变量
+```python
+def function_a():
+    global var1
+    var1 = 200
+    print("var1:", var1)
+
+var1 = 100
+
+```
+当全局变量为可变类型时，函数内部使用global声明，也可以对其进行修改。  
+```python
+def function_a():
+    list1[0] = 1000
+
+list1 = [1, 2, 3]
+```
+在函数中不使用global声明全局变量时不能修改全局变量的本质是不能修改全局变量的指向，即不能将全局变量指向新的数据。    
+
+- 不可变类型的全局变量其指向的数据不能修改，所以部使用global无法修改全局变量。
+- 可变类型的全局变量其指向的数据可以修改，所以不使用global也可修改全局变量。 
+
+#### nonlocal关键字
+
+nonlocal也用作内部作用域修改外部作用域的变量的场景，不过此时外部作用域不是全局作用域，而是嵌套作用域
+
+```python
+def function_outer():
+    var = 1
+    print(var)
+
+    def function_inner():
+        nonlocal var
+        var = 200
+    function_inner()
+    print(var)
+
+
+function_outer()
+```
+
+
 
 ## 类 
 
@@ -541,8 +727,10 @@ p.make_pizza(12,'mushrooms','green peppers','extra cheese')
 dog.py
 ```python
 class Dog:
+    home = "xx"    # 类属性
+
     def __init__(self, name, age):
-        self.name = name
+        self.name = name  # 实例属性
         self.age = age
 
     def sit(self):
@@ -552,12 +740,14 @@ class Dog:
         print(self.name + " Rolling")
 ```
 
-__init__()是一个特殊的方法，每当你根据Dog类创建新实例时，Python都会自动运行它。在这个方法中形参self必不可少，还必须位于其他形参的前面。        
+__init__()是一个特殊的方法(构造方法)，每当你根据Dog类创建新实例时，Python都会自动运行它(__init__()方法的调用时机在实例(通过__new__()被创建之后，返回调用者之前调用，一般用于初始化一些数据))。在这个方法中形参self必不可少，还必须位于其他形参的前面。        
 
 为什么必须在方法定义中包含形参self呢？因为Python调用这个__init__()方法来创建Dog实例时，将自动传入实参self。    
 
 每个与类相关联的方法调用都自动传入实参self，它是一个指向实例本身的引用，让实例能够访问类中的属性和方法。         
 
+
+
 ```python
 import dog
 
@@ -568,6 +758,103 @@ print(dog.name)
 dog.sit()
 ```
 
+类属性可以直接通过类名.类属性调用也可以通过实例对象.类属性调用，如`Dog.home或dog.home`
+
+```python
+class Person:
+    home = "class home"
+
+    def __init__(self, name) -> None:
+        self.name = name
+
+
+person = Person("name")
+print(person.name)
+print(person.home)
+person.home = "object home"
+print(person.home)
+print(Person.home)
+Person.home = "new class home"
+print(Person.home)
+
+# 结果
+name
+class home
+object home
+class home
+new class home
+
+```
+可以看到所有类的实力都会共享同一个类属性，如果通过对象实例.类属性调用则会直接创建一个实例属性(并不是修改了类属性的值)
+
+#### 动态添加属性和方法
+
+```python
+class Person:
+    def __init__(self, name: str) -> None:
+        self.name = name
+
+p = Person("John")
+p.age = 20
+print(p.name)
+print(p.age)
+
+```
+
+
+
+### 方法
+
+Python的类中有三种方法: 实例方法、静态方法、类方法。   
+
+- 实例方法在类中定义，第一个参数是self,代表实例本身
+- 实例方法只能被实例对象调用
+- 可以访问实例属性、类属性、类方法
+
+#### 类方法
+
+- 类方法通过@classmethod标注，方法的第一个参数是cls
+- 类方法可以通过类来调用也可以通过实例来调用
+- 可以访问类属性
+- 类方法可以在不创建实例的情况下调用，通过类名直接调用，非常方便，适合一些和类整体相关的操作
+
+
+```python
+class Dog:
+
+    @classmethod
+    def wangwang(cls):
+        print"wangwang"
+
+
+```
+
+#### 静态方法
+
+- 静态方法通过@staticmethod定义
+- 不访问实例属性或类属性，只依赖传入的参数
+- 可以通过类名或实例调用，但它不会访问类或实例的内部信息，更像一个工具函数
+
+
+#### 特殊方法
+
+
+方法名中有两个前缀下划线和两个后缀下划线的方法为特殊方法，也叫魔法方法。   
+上面的__init__()就是一个特殊方法，这些方法会在进行特定的操作时自动被调用。   
+
+几个常见的特殊方法:    
+
+- __new__(): 对象实例化时第一个调用的方法
+- __init__(): 类的初始化方法
+- __del__(): 对象的销毁器，定义了当对象被垃圾回收时的行为，使用del xxx时不会主动调用__del__()，除非此时引用计数=0
+- __str__(): 定义了对类的实例调用str()时的行为
+- __repr__(): 定义了对类的实例调用repr()时的行为，str()和repr()最主要的差别在于目标用户。repr()的作用是产生机器可读的输出，而str()则产生人类可读的输出。 
+- __getattribute__():属性访问拦截器，定义了属性被访问前的操作。  
+
+
+
+
+
 
 ### 继承
 
@@ -612,6 +899,69 @@ tesla.get_battery()
 super()是一个特殊函数，帮助Python将父类和子类关联起来。这行代码让子类包含父类的所有属性。 
 
 
+多继承: 调用方法时先在子类中查找，若不存在则从左到右依次查找父类中是否包含方法。    
+
+#### 私有属性和方法
+
+有时为了限制属性和方法只能在类内访问，外部无法访问。或父类中某些属性和方法不希望被子类继承，可以将其私有化:    
+
+- 单下划线: 非公开API
+
+    大多数python代码都遵循这样一个约定，有一个前缀下划线的变量或方法应被视为非公开的API，例如_var1。但这种约定不具有强制力。    
+
+- 双下划线: 名称改写
+    有两个前缀下划线，并至多一个后缀下划线的标识符，例如__x，会被改写为_类名__x，只有在类内部可以通过__x访问，其他地方无法访问或只能通过_类名__x访问。    
+
+
+#### property装饰器
+
+可通过@property装饰器将一个方法转换为属性来调用。转换后可直接使用.方法名来使用，而无需使用.方法名()。  
+
+注意: @property修饰的方法不要和变量重名，否则可能导致无限递归
+#### 只读属性
+
+```python
+class Person:
+    def __init__(self, name: str) -> None:
+        self.__name = name
+
+    @property
+    def name(self):
+        return self.__name
+
+p = Person("zhangsan")
+print(p.name)
+
+.name = "lisi" # 报错
+```
+
+#### 读写属性
+
+使用属性名.setter装饰
+
+```python
+class Person:
+    def __init__(self, name: str) -> None:
+        self.__name = name
+
+    @property
+    def name(self):
+        return self.__name
+
+    @name.setter
+    def name(self, name: str) -> None:
+        self.__name = name
+        
+p = Person("zhangsan")
+print(p.name)
+
+p.name = "lisi"
+print(p.name)
+```
+
+
+
+
 ## 标准库
 
 Python标准库是一组模块，安装的Python都包含它。
@@ -664,6 +1014,54 @@ with open(filename, 'w') as fo:
 
 异常是使用try-except代码块处理的。try-except代码块让Python执行指定的操作，同时告诉Python发生异常时怎么办。使用了try-except代码块时，即便出现异常，程序也将继续运行：显示你编写的友好的错误消息，而不是令用户迷惑的traceback。
 
+```python
+try:
+    可能发生异常的代码
+except 异常类型1 as 变量名1:
+    异常1处理代码
+except 异常类型2 as 变量名2: 
+    异常2处理代码
+else: 
+    没有异常时执行的代码
+finally:
+    无论是否发生异常都会执行的代码 
+```
+
+#### 抛出异常
+
+当想在代码中明确表示发生了错误或异常时，可以使用raise来抛出异常。
+```python
+def int_add(a, b):
+    if isinstance(a, int) and isinstance(b, int):
+        return a + b
+    else:
+        raise TypeError("参数类型错误")
+```
+
+### with关键字
+
+
+python中的with语句用于异常处理，封装了try except finally编码范式，提供了一种简洁的方式来确保资源的正确获取和释放，同时处理可能发生的异常，提高了易用性，使代码更清晰、更具可读性，简化了文件流等公共资源的管理   
+
+```python
+with expression as variable:     
+    # 代码块
+```
+
+- expression: 通常是一个对象或函数调用，该对象需要一个上下文管理器，即实现了__enter__和__exit__方法
+
+- variable: 是可选的，用于存储expression的__enter__方法的返回值。     
+
+工作原理:   
+
+- 使用with关键字系统会自动调用f.close()方法，with的作用等效于try finally语句。 - 当执行with语句时，会调用expression对象的__enter__方法
+- __enter__方法的返回值可以被存储在variable中(如果有)，以供with代码块中使用  
+- 然后执行with语句内部的代码块
+- 无论在代码块中是否发生异常，都会调用expression对象的__exit__方法，以确保资源的释放或清理工作，这类似于try - except -finally中的finally语句。   
+
+
+
+
 
 ### 分割字符串
 
@@ -790,3 +1188,59 @@ some_kwargs(**kdic)
 
 
 在Python中，可以通过@property（装饰器）将一个方法转换为属性，从而实现用于计算的属性。将方法转换为属性后，可以直接通过方法名来访问方法，而不需要再添加一对小括号“()”，这样可以让代码更加简洁。
+
+
+#### lambda
+
+Python使用lambda来定义匿名函数，所谓匿名，指其不用def的标准形式定义函数。 
+
+
+Lambda 表达式的基本语法是：`lambda 参数列表: 表达式`。
+关键字与参数：以 lambda关键字开头，后跟参数列表（如 x或 x, y），参数之间用逗号分隔。这些参数是函数的输入。
+表达式与返回值：冒号后面是一个单一的表达式。这个表达式会被求值，其结果就是 lambda 函数的返回值。注意，lambda 函数体内只能有一个表达式，不能包含复杂的语句或多行代码块。
+Lambda 函数是匿名的，也就是说，它们没有像用 def定义的函数那样的名称。它们的优势在于简洁，特别适合定义那些逻辑简单、可能只使用一次的短小函数。
+
+
+### var1 *= 2与var1 = var1 * 2的区别
+
+
+- var1 *= 2使用原地址
+- var1 = var1 * 2开辟了新的空间
+- 同样的对于类似，var1 += 2和var1 = var1 + 2也是同理
+
+```python
+def test(var1): 
+    print("函数内var1 id:", id(var1))
+    var1 *= 2
+    print("var1 *= 2后函数内var1 id:", id(var1))
+    var1 = var1 * 2
+    print("var1 = var1 *  2后函数内var1 id:", id(var1))
+    
+函数内var1 id: 2302584035712
+var1 *= 2后，函数内var1 id: 2302584035712
+var1 = var1 * 2后，函数内var1 id: 2302584033664    
+```    
+    
+    
+    
+    
+
+----
+
+
+
+
+
+
+计算机高级运行方式:   
+
+- 编译型: c、c++
+- 解释型： python、JavaScript
+- 先编译再解释： java
+
+
+其实python也是先编译再解释，但是python的编译时机和java的不一样。 
+- java是在代码解释执行前，先进行预编译，编译后生成字节码文件存在硬盘中。
+- python是在对代码进行逐行解释执行的时候进行的编译操作，默认生成的字节码文件存在内存中。  
+
+
diff --git a/JavaKnowledge/shell.md b/JavaKnowledge/shell.md
index c6bf4a42..1c2fb339 100644
--- a/JavaKnowledge/shell.md
+++ b/JavaKnowledge/shell.md
@@ -89,3 +89,13 @@ ar命令最开始是用于将文件写入磁带设备以作归档，但它也可
 // 该命令创建了一个名为test.tar的归档文件，包含目录test和test2的内容。
 tar -cvf test.tar test/ test2/
 
+
+### 切换到root用户
+
+
+`sudo su -`
+
+ - sudo : super user doing
+ - su : switch user
+ - `-` : root用户
+
diff --git "a/Jetpack/ui/\345\257\271\346\257\224.md" "b/Jetpack/ui/\345\257\271\346\257\224.md"
new file mode 100644
index 00000000..644118ec
--- /dev/null
+++ "b/Jetpack/ui/\345\257\271\346\257\224.md"
@@ -0,0 +1,68 @@
+# 对比
+
+
+当前，Android开发正经历着从\"代码工人\"到\"智能场景架构师\"的转型。传统的XML布局开发模式正被声明式UI取代，云端AI计算快速向设备端迁移，跨平台技术也从\"能用\"向\"好用\"演进。
+
+
+1. 界面开发革命：Compose主导的声明式转型
+Jetpack Compose已不再是\"未来技术\"，而是现在的必备技能。数据显示，使用Compose后，页面开发周期可缩短70% 。更有性能测试表明，在折叠屏设备上，传统的RecyclerView滑动帧率下降至45fps，而Compose的LazyColumn能稳定在60fps 。
+
+
+
+2. 设备端AI：从云端到终端的算力迁移
+设备端AI正成为移动开发的新战场。2025年三大杀手级应用已落地：实时视频抠图、离线语音合成、智能代码补全。
+成本对比数据令人震惊：对于月活100万的应用，使用设备端AI进行图片风格迁移的成本几乎为零，而云端方案成本约为2000美元/月 。这种成本优势，加上设备端AI在延迟和隐私保护上的优势，使得端侧智能成为必然趋势。
+
+
+
+传统的 Android UI 开发采用的是 View 视图体系，它是一种命令式的编程模型。开发者需要通过编写大量的代码来描述 View 的外观和行为，包括布局、样式、交互等。这种方式需要开发者花费大量的时间和精力，而且代码量也非常庞大，维护和扩展也比较困难。
+
+与之相比，Jetpack Compose 是一种声明式的编程模型，采用的是函数式编程的思想。开发者只需要描述 UI 的样式和行为，然后 Jetpack Compose 会自动处理 View 的布局和绘制。这种方式不仅减少了代码量，还可以提高开发效率，同时也使得代码更加易于维护和扩展。
+
+那 Data Binding 呢？用过的人自然能明白其中的痛苦，在 xml 文件中编写代码。并且还需要先解析 xml 文件，效率自然会有影响。而 Jetpack Compose 代码完全基于 Kotlin DSL 实现，相较于 Data Binding 需要有 xml 的依赖，Compose 只依赖单一语言，避免了因为语言间交互而带来的性能开销及安全问题。
+
+
+传统的 View 视图是基于继承的结构体系，也已经随着 Android 发展了十多年。View.java 本身也变得十分臃肿，目前已经超过三万行。臃肿的父类控件，也会造成子类视图的功能不合理。以 Button 为例，为了能让 Button 具备显示文字的功能，Button 被设计成了继承自 TextView 的子类。这样有很多不适用于按钮的功能也被继承下来了，TextView 的剪贴板功能，对 Button 来说显得不合理。而且随着 TextView 自身功能的迭代，Button 可能引入更多不必要的功能。
+另一方面，想 Button 这类基础控件，只能跟随系统升级而更新，及使发现了问题，也得不到及时的修复。这也是为什么如今很多新的视图都以 Jetpack 扩展库的形式单独发布的原因。
+而 Jetpack Compose 则是作为函数，相互之间没有继承关系。让开发这更多的是以组合的思想去思考问题。
+
+
+
+3.1 声明式 UI 的编程范式发展的趋势
+从编程范式的维度来说，声明式 UI 相对传统的命令式 UI，更加先进， React， iOS 的 SwiftUI， flutter， Jetpack Compose， 声明式 UI 开发思想已经席卷了整个前端开发领域。如果你还在使用传统 View 视图体系开发 Android 原生界面，那你应该尝试声明式 UI。
+
+
+如同 Kotlin 取代 Java 成为 Google 推荐的 Android 官方推荐的编程语言一样，Jetpack Compose 也是 Google 推荐的 Android 官方 UI 框架。并且，新版的 Android Studio 中集成了大量的特性来支持 Jetpack Compose 更高效的开发。这表明 Jetpack Compose 在未来的 Android 开发中将扮演重要的角色。目前来看，Jetpack Compose 并不会完全取代传统的 View 视图体系，而是会和传统 View 视图体系共存， 但是 Jetpack Compose 在未来会能成为 Android 开发的主流。从 Android 14 Framework 中我们能看到 Compose 的影子了。在 2018 年，SystemUI 模块中，我们能看到 Kotlin 改写的部分模块，在 Android 14 中，我们再 Settings 中再次看到了 Kotlin 的代码了。并且 Google 新建了一个 spa 包，这个包里面尝试把 “应用管理”、“应用管理通知”、“使用情况” 页面用 Jetpack Compose 重写了。
+
+
+
+四、Jetpack Compose 与 View 视图体系对比
+Compose 重新定义了 Android UI 开发方式，大幅提升了开发效率，主要体现在：
+
+声明式 UI， 不需要手动刷新数据
+取消 XML, 完全解除了混合写法的(XML + java、Kotlin) 的局限性，以及性能开销
+超强兼容性，大多数 jetpack 库(如 Navigation、ViewModel) 以及 Kotlin 协程都适用于 Compose, Compose 能够与现有 View 体系并存，你可以为一个既有项目引入 Compose。
+加速开发，更简单的动画和触摸事件Api, Compose 为我们提供了很多开箱即用的 Material 组件，如果的APP是使用的material设计的话，那么使用Jetpack Compose 能让你节省不少精力。
+精简代码数量，减少 bug 的出现
+强大的预览功能， Compose 预览机制可以实时预览动画，交互式预览，真正所见即所得。
+
+
+
+4.1.1 APK 尺寸缩减
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/tvi_compose_apk_size.png?raw=true)
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/tvi_compose_method_count.png?raw=true)
+
+在将迁移后的应用与接入 Compose 前的应用做比较后，我们发现 APK 大小缩减了 41%，方法数减少了 17%。
+
+
+4.1.3 构建速度
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/tvi_compose_build_time.png?raw=true)
+
+
+        
+
+
diff --git a/MobileAIModel/AIGC.md b/MobileAIModel/AIGC.md
new file mode 100644
index 00000000..e37d7149
--- /dev/null
+++ b/MobileAIModel/AIGC.md
@@ -0,0 +1,49 @@
+AIGC
+---
+
+
+### AIGC概念
+
+AIGC全称为AI-Generated Content，人工智能内容生成。   
+
+
+### 技术划分
+
+AIGC从技术上的应用可以划分为:     
+
+- 内容孪生: 是数字内容映射到另一个模态的技术，包括智能增强与智能转译，应用场景包括图像超分、语音转字幕、文字转语音等。   
+- 内容编辑: 通过理解内容及属性控制实现修改，应用场景: 场景剪辑、虚拟试衣、人声分离等。    
+- 内容生成: 通过学习海量数据中的抽象概念，并生成全新的内容，应用广泛，包括图像生成(AI绘画)、文本生成(AI写作)，视频生成、多模态生成等。 
+
+
+### 从生成内容划分    
+
+- 文本生成
+- 图像生成
+- 音频生成
+- 视频生成
+- 多模态生成
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/MobileAIModel/RAG.md b/MobileAIModel/RAG.md
new file mode 100644
index 00000000..c50f2dfc
--- /dev/null
+++ b/MobileAIModel/RAG.md
@@ -0,0 +1,75 @@
+RAG
+---
+
+
+### RAG概念
+
+
+RAG(Retrieval Augmented Generation)：检索增强生成。     
+
+顾名思义，就是通过检索外部数据，增强大模型的生成效果。   
+
+RAG为LLM提供了从某些数据源检索到的信息，并基于此修正生成的答案。      
+
+RAG基本上是Search + LLM提示，可以通过大模型回答查询，并将搜索算法所找到的信息作为大模型的上下文。查询和检索到的上下文都会被注入发送到LLM的提示语中。    
+
+
+
+
+将大模型应用于实际业务场景时会发现，通用的基础大模型基本无法满足我们的实际业务需求，主要有以下几个方面的原因:      
+
+- LLM的知识不是实时的，不具备知识更新
+- LLM可能不知道你私有的领域/业务知识
+- LLM有时会在回答中生成看似合理但实际上是错误的信息  
+
+
+为什么会用RAG
+
+- 提高准确性: 通过检索相关的信息，RAG可以提高生成文本的准确性
+- 减少训练成本: 与需要大量数据来训练的大型生成模型相比，RAG可以通过检索机制来减少所需的训练数据量，从而降低训练成本。
+- 适应性强: RAG模型可以适应新的或不断变化的数据，由于它们能够检索最新的消息，因此在新数据和事件出现时，它们能够快速适应并生成相关的文本。   
+
+
+RAG系统兼具检索与生成的双重能力，可视为传统生成系统的升级版：既有效减少了幻觉现象，又显著提升了回答的事实准确性。该技术还支持“与数据对话”(chat with my data)的应用场景，使企业和个人能够将LLM与内部数据或特定数据源（如书籍内容）对接。
+
+RAG技术是一种结合信息检索与生成模型的新型架构，其核心思想是利用外部知识库或文档集合为大模型提供实时、准确的背景信息，从而弥补大模型的局限性。   
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/rag.png?raw=true)        
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/MobileAIModel/TensorFlow Lite b/MobileAIModel/TensorFlow Lite
index 3e3be658..0f9a7adf 100644
--- a/MobileAIModel/TensorFlow Lite	
+++ b/MobileAIModel/TensorFlow Lite	
@@ -1,12 +1,17 @@
 TensorFlow Lite
 ---
 
+
+
 [TensorFlow Lite](https://tensorflow.google.cn/lite?hl=zh-cn) 是一个移动端库，可用于在移动设备、微控制器和其他边缘设备上部署模型。
 
 
 [TensorFlow Lite](https://tensorflow.google.cn/lite?hl=zh-cn) 是一组工具，可帮助开发者在移动设备、嵌入式设备和 loT 设备上运行模型，以便实现设备端机器学习。
 
 
+TensorFlow模型通常不是为移动场景而设计的，在这些场景中，必须考虑大小、电池消耗以及可能影响移动用户体验的所有其他因素。为此，TensorFlow Lite的创建有两个主要目标。第一，它可用于将现有的TensorFlow模型转换为更小、更紧凑的格式，着眼于针对移动设备进行优化。第二则是为可用于模型推理的各种移动平台提供高效的运行环境。
+
+
 TensorFlow Lite是TensorFlow在手机和嵌入设备上的一个轻量级框架。      
 
 主要特性:  
diff --git "a/MobileAIModel/\345\244\247\346\250\241\345\236\213.md" "b/MobileAIModel/\345\244\247\346\250\241\345\236\213.md"
new file mode 100644
index 00000000..7a19ef92
--- /dev/null
+++ "b/MobileAIModel/\345\244\247\346\250\241\345\236\213.md"
@@ -0,0 +1,394 @@
+大模型简介
+---
+
+### 人工智能
+
+人工智能(AI, Artificial Inteligence)通常用于描述致力于执行接近人类智能任务(如语音识别、语音翻译和视觉感知)的计算机系统。它是指软件产生的智能，而不是人类的智能。   
+
+目标是研究、设计和构建具备智能、学习、推理和行动能力的计算机和机器。    
+
+例如: 2016年Alphago击败李世石围棋。     
+
+### 生成式人工智能
+
+GAI (Generative Aritificial Interligence)
+
+目标是让机器能够产生复杂有结构的物件。 例如chatGPT、deepseek。
+
+### 机器学习
+
+ML(Machine Learning)
+
+提到机器学习，追根溯源，我们需要先知道什么是“学习”。著名学者、1975年图灵奖获得者、1978年诺贝尔经济学奖获得者，赫伯特·西蒙（Herbert Simon）教授曾对“学习”下过一个定义：如果一个系统，能够通过执行某个过程，就此改进它的性能，那么这个过程就是学习。
+在西蒙看来，学习的核心目的就是改善性能。其实对于人而言，这个定义也是适用的。如果我们仅仅进行低层次的重复性学习，而没有达到认知升级的目的，那么即使表面看起来非常勤奋，其实也仅仅是一个“伪学习者”，因为我们的性能并没有得到改善。
+西蒙认为，对于计算机系统而言，通过运用数据及某种特定的方法（比如统计方法或推理方法）来提升机器系统的性能，就是机器学习（Machine Learning，简称ML）。
+
+所谓机器学习，在形式上可近似等同于，在数据对象中通过统计或推理的方法，寻找一个有关特定输入和预期输出的功能函数f
+
+
+所有的监督学习（Supervised Learning），基本上都是分类（Classification）的代名词。它从有标签的训练数据中学习模型，然后对某个给定的新数据利用模型预测它的标签。
+比如，小时候父母告诉我们某个动物是猫、狗或猪，然后在我们的大脑里就会形成或猫或狗或猪的印象（相当于模型构建），当面前来了一只“新”小狗时，如果你能叫出“这是一只小狗”，那么恭喜你，标签分类成功！
+但如果你回答说“这是一头小猪”，这时你的父母就会纠正你的偏差：“乖，不对，这是一只小狗。”这样一来二去地进行训练，不断更新你大脑的认知体系，当下次再遇到这类新的猫、狗、猪时，你就会在很大概率上做出正确的“预测”分类。
+监督学习，就是先利用有标签的训练数据学习得到一个模型，然后使用这个模型对新样本进行预测。在本质上，监督学习的目标在于，构建一个由输入到输出的映射，该映射用模型来表示。
+### 深度学习
+
+DL(Deep Learning): 深度学习算法试图模拟人类大脑的工作方式，其灵感来源于神经生物学，它通过对大量数据的学习，自动提取出数据的高层次特征和模式，从而实现图像识别、语音识别、自然
+语言处理等任务。 
+
+按照架构的不同，神经网络可以分为:   
+
+- 卷积神经网络(CNNS)
+- 循环神经网络(RNNS)
+- Transformer网络等
+
+同样是区分不同水果，这次你带孩子去了超市，那里有各种不同的水果，你没有解释每种水果的特点，只是给孩子指出了哪些是苹果、哪些是香蕉，他通过观察和比较，慢慢学会了辨认各种水果。 
+
+在这个过程中，孩子的大脑(在这里比喻为深度学习模型)自动从复杂的视觉、嗅觉等信号中提取层次化的特征。比如圆形、条纹、颜色深浅、气味等，从而达到识别水果的目的。  
+
+
+### LoRA
+
+低秩自适应(Low-Rank Adaptation，LoRA)是一种针对大型预训练语言模型（如GPT-3）的微调技术。LoRA的核心思想是通过对模型权重进行低秩更新，以实现有效的参数适应，而无须重新训练模型的全部参数。这种技术在保留预训练模型的泛化能力的同时，允许模型快速适应特定任务。
+
+
+### 大语言模型
+
+LLM(Large Language Model)
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/ai_relation..png?raw=true)        
+
+
+
+### 多模态
+
+提及LLM时，我们通常不会第一时间联想到多模态。毕竟，LLM本质上是语言模型。但我们很快会发现，若能处理文本之外的数据类型，其应用价值将大幅提升。例如，当语言模型可“看到”图像并回答相关问题时，其效用将显著增强。这种能够处理文本与图像（每种数据类型称为一种模态）的模型，即被称为多模态(multimodal)模型
+
+能处理多种数据模态（如图像、音频、视频或传感器数据）的模型称为多模态模型。模型接收某种模态作为输入，但不一定能生成对应模态的输出
+
+### 什么是大模型
+
+大语言模型(large language model，LLM)[插图]已经对世界产生了深远的影响。通过使机器更好地理解和生成人类语言，LLM在人工智能(artificial inteligence，AI)领域开创了新的可能性，并影响了众多行业。
+
+
+大模型，一般也称为"大预言模型"， 是一种基于深度学习技术训练出来的人工智能系统，主要用于处理和生成人类语言。     
+
+模型规模: 通常包含数十亿到数千亿个参数，这些参数就像是模型的"大脑神经元"。     
+训练数据: 使用海量文本数据进行训练，包括书籍、文章、网页等各种形式的文字内容。
+
+在深度学习和像GPT这样的大语言模型中，“参数”指的是模型的可训练权重。这些权重本质上是模型的内部变量，在训练过程中通过调整和优化来最小化特定的损失函数。
+
+
+### 模型蒸馏
+
+大模型的运行需要极高的硬件资源，通常都是服务器集群并挂载数量众多的GPU(显卡)。
+为了满足低性能设备的运行，可以对大模型进行蒸馏。   例如deepseek r1的 7b模型、70b模型。 
+
+模型蒸馏: 对模型进行简化，在尽量保证模型性能的前提下，尽可能减少对硬件资源的需求。  
+
+简单理解就是假设你有一个超强的老师(大模型)，他能讲解很复杂的知识。
+你想把这些知识传授给一群学生(小模型)。为了让学生能在不需要过多时间和资源的情况下，快速掌握老师的知识。你可以通过“蒸馏的方式”，让学生只学习精华、最重要的部分。
+这样，学生虽然没有老师那么强大，单依然能做出优秀表现。   
+
+
+
+
+### 大模型训练
+
+大模型整体的训练主要分为三个阶段:    
+
+- 预训练: 注入领域知识     
+- SFT(监督微调):      
+- RLHF(基于人类反馈的强化学习)     
+
+
+
+### 模型部署
+
+
+#### ollama
+
+[ollama](https://ollama.com/)是一款旨在简化大型语言模型本地部署和运行过程的开源软件。   
+
+
+- 本地部署(ollama)
+    - 后端和模型部署(例如ollama本地部署千问模型)
+    - 前端部署(交互界面，例如chatbox ai、Stremlit)
+    - 用户使用
+
+#### LangChain
+
+
+[LangChain](https://www.langchain.com/)是一个用于构建和管理基于语言模型(Language Models，LM)的应用程序框架。      
+
+它提供了一系列工具和组件，帮助开发者更高效的构建、训练、部署和管理语言模型应用。      
+
+LangChain的设计目标是简化语言模型的使用过程，使其更加容易被集成到各种应用场景中。      
+它本质上是一个Python框架
+
+LangChain的名称源自其核心方法之一——链(chain)。虽然我们可以独立运行LLM，但链的真正威力在与其他组件协同工作，甚至在多条链相互配合时才能充分展现。这种架构不仅能拓展LLM的能力，还能实现链与链之间的无缝衔接。
+
+
+
+LangChain主要组件:   
+
+- Prompts: 提示，包括提示管理、提示优化和提示序列化
+- Models: 模型，各种类型的模型和模型集成，比如gpt-4、deepseek
+- Memory: 记忆，用来保存和模型交互时的上下文状态
+- Indexes: 索引，用来结构化文档，以便和模型交互
+- Chains: 链，一系列对各种组件的调用
+- Agents: 代理，决定模型采取哪些行动，执行并且观察流程，直到完成为止
+
+
+
+- 云端部署(LangChain)
+    - 后端部署(例如阿里云百炼平台部署千问模型)
+    - 前端部署(例如Stremlit)
+    - 用户使用
+
+
+
+模型部署总结:   
+
+Ollama是本地模型运行的入门工具。     
+LangChain是覆盖入门 + 进阶的全功能框架。    
+
+除了Ollama的功能外，LangChain额外多出了:   
+
+- 记忆能力: 基于ConversationBufferMemory等组件完成多轮对话历史记录    
+- 文档对接能力: 可实现PDF/Word等本地文档对打，构建私有知识库
+- 工具调用与智能体能力: 通过Tool、Agent组件让模型自动调用工具
+- 流程编排能力: SequentialChain、LCEL等实现任务自动化与并行模型
+
+以及，针对云平台的API调用支持(如阿里云的通义千问百炼平台、腾讯云的混元等)    
+
+
+
+## 端模型
+
+不是所有模型都奔着“更大更强”去才有价值。    
+
+相反，像Qwen3-0.6b这种小模型才是真正能在实际场景中跑起来、用得起的模型。   
+
+Qwen3-0.6b的表现:   
+
+- 推理速度快、延迟低：典型场景延迟在几十毫秒，适合边缘设备部署。  
+- 资源占用小: 内存带宽压力低，功耗控制出色，支持长时间稳定运行。 
+- 兼容性强: 广泛适用于query改写、文本匹配、语义检索等任务。   
+
+ 
+很多人认为Qwen3-0.6b不如7b、13b强大，因此没用。但现实是，在高并发、低延迟、受限资源的实际业务场景中，大模型往往根本上不了场。   
+
+总结: 轻、小、稳，才是能落地的关键。   
+
+举个例子:   
+
+普通小货车的运载能力相比较那些拉上十几吨、几十吨的大货车相差太多，难道它就没用用处吗？      
+
+当然不是，因为它的定位就是面对相对狭小的场景、相对少的货物做出更敏捷的选择。    
+
+Qwen3-0.6b的定位，从来也不是生成长文本或复杂推理，而是在多模态系统中提供“一点点启发性的信号”，用于放大系统整体效能。      
+
+这“一点点信号”在推荐、搜索、识别系统重，往往正是决定点击、转化、留存的关键。   
+
+
+我们选择部署Qwen3-0.6b，不是"凑合"，而是精准选择--它足够快、足够轻、足够稳，也足够使用。     
+
+在生产环境中，能跑、能稳、能提效的模型，才是真正有价值的模型。   
+
+
+
+### 大模型的工作流程
+
+
+大多数人与语言模型交互的方式是通过网页平台，它提供用户与语言模型之间的聊天界面。你可能会注意到，模型并不是一次性生成所有输出，而是一次生成一个词元。
+词元不仅是模型的输出单位，也是模型查看输入的方式。发送给模型的提示词首先被分解成词元。
+
+
+
+对计算机来说，语言是一个复杂的概念。   
+
+
+文本本质上是非结构化的，当用0和1(单个字符)表示时就会失去其含义。因此，在语言人工智能的发展历史中，人们一直非常关注如何以结构化的方式标识语言，使计算机能够更容易的使用。    
+
+语言人工智能历史始于一种名为词袋(bag of words)的技术，这是一种表示非结构化文本的方法。  
+
+词袋模式的工作原理如下: 假设我们有两个句子需要创建数值表示。
+
+词袋模型的第一步是分词(tokenization)，即将句子拆分为单个词或子词(词元(token))。   
+
+最常见的分词方法是通过空格分割来把句子分割成词。      
+
+然而，这种方法也有其缺点，因为某些语言(如汉语)的词之间没有空格。
+在分词之后，我们将每个句子中所有不同的词组合起来，创建一个可用于表示句子的词表(vocabulary)。
+使用词表，我们只需计算每个句子中词出现的次数，就创建了一个词袋。       
+因此，词袋模型旨在以数字形式创建文本的表示(representation)，也称为向量或向量的标识。我们将这类模型称为表示模型(representation model)    
+
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/respresentation_1.png?raw=true)        
+
+通过计算单个词出现的次数创建词袋，这些值被称为向量表示。
+
+
+词袋虽然是一种优雅的方法，但存在一个明显的缺陷。它仅仅把语言视为一个几乎字面意义上的"词袋"，而忽略了文本的语音特性和含义。
+这是因为词袋模型就像把一段话拆成一堆词，装进袋子里，只数数量，不看顺序，不懂意思，不管谁和谁有关系。这让它在理解句子真正含义时，显的很呆。     
+比如狗追猫和猫追狗。 词袋模型看不出来到底谁追谁。    
+
+
+word2vec(词向量)于2013年发布，是首批成功利用嵌入(embeding)这个概念来捕捉文本含义的技术之一。     
+
+嵌入是数据的向量表示，试图捕捉数据的含义。为此word2vec通过在大量文本数据(如整个维基百科)上训练来学习词的语义表示。   
+
+为了生成这些语义表示，word2vec利用了神经网络(neural network)技术。    
+
+神经网络由处理信息的多层互连节点组成。神经网络可以有多个分层，每个连接有一定的权重，这些权重通常被称为模型的参数。    
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/neural_network_1.png?raw=true)        
+
+在训练过程中，word2vec会学习词与词之间的关系，并将这些信息提炼到词嵌入中。如果两个词各自的相邻词集合有更大的交集，它们的词嵌入向量就会更接近，反之亦然。    
+
+词嵌入可以用多种属性来表示一个词的含义。由于嵌入向量的大小是固定的，这些属性需要经过精心选择，以构建用来代表词的“心智表征”的抽象标识。 
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/word2vec_2.png?raw=true)        
+
+在实践中，这些属性通常相当抽象，很少与单一实体或人类可识别的概念相关。然而，这些属性组合在一起对计算机来说是有意义的，是将人类语言转换为计算机语言行之有效的方式。     
+
+词嵌入非常有用，因为它使我们能够衡量两个词的语义相似度。   
+
+上面word2vec的训练过程会创建静态的、可下载的词标识。例如，bank这个词无论在什么上下文中使用，都会有相同的词嵌入。   
+
+然而，bank既可以指银行，也可以指河岸。它的含义应该根据上下文而变化，因此它的嵌入也应该根据上下文而变化。   
+使用RNN(Recurrent Neural Network，循环神经网络)，可以实现文本编码的一个步骤。这些神经网络的变体可以将序列作为补充输入进行建模。    
+为此，这些RNN被用于两个任务:    
+- 编码: 也就是表示输入句子
+- 解码: 也就是输出句子
+
+该架构中的每个步骤都是自回归(auto - regressvie)的，在生成下一个词时，该架构需要使用所有先前生成的词作为输入。    
+然而，这种上下文嵌入方式存在局限性，因为它仅用一个嵌入向量来表示整个输入，使得处理较长的句子变得困难。    
+
+在2014年，研究人员提出了注意力(attention)解决方案，大大改善了原始架构。    
+注意力云讯模型关注输入序列中彼此相关(相互注意)的部分，并放大它们的信号，注意力机制通过选择性地聚焦于句子中最关键的词，来突出其重要性。   
+
+### Transformer
+
+在2017年著名论文"Attention is All You Need"首次探讨了注意力机制的真正威力，并提出了一种被称为Transformer的网络架构。    
+
+Transformer完全基于注意力机制，摒弃了此前提到的RNN。与RNN相比，Transformer支持并行训练，这大大加快了训练速度。    
+在Transformer中，编码和解码组件相互堆叠。这种架构仍然是自回归的，每个新生成的词都被模型用于生成下一个词。   
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/transformer_1.png?raw=true)        
+
+Transformer由堆叠的编码器和解码器块组合而成，输入依次轮流经每个编码器和解码器. 
+
+要理解Transformer LLM的行为，最常见的方式是将其视为一个接收文本输入并生成响应文本的软件系统。 
+
+通过分词后大模型会生成一个个的新词元的概率列表，然后从生成的词元列表中选择某一个词元的过程就叫做解码策略。 
+
+每次都选择概率分数最高的词元的策略被称为贪心解码。这就是在LLM中将温度(temperature)参数设为零时会发生的情况。
+
+
+
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/transformer_2.png?raw=true)        
+
+· Transformer LLM 每次生成一个词元。     
+· 生成的词元会被追加到提示词中，然后，这个更新后的提示词会再次被输入模型进行下一次前向传播，以生成下一个词元。    
+· Transformer LLM的三个主要组件是分词器、一系列Transformer块和语言建模头。    
+· 分词器包含模型的词元词表。模型中包含与这些词元相关联的词元嵌入。将文本分解成词元，然后使用这些词元的嵌入向量，是词元生成过程的第一步。    
+· 前向传播会依次经过所有阶段。    
+· 在处理接近尾声时，语言建模头会对下一个可能的词元进行概率评分。解码策略决定了在这一生成步骤中选择哪个实际词元作为输出（有时是概率最高的下一个词元，但并非总是如此）。    
+· Transformer表现出色的原因之一是它能够并行处理词元。每个输入词元都流入其独立的计算流（也称为处理路径）。这些流的数量就是模型的“上下文长度”，代表模型可以处理的最大词元数量。    
+· 由于Transformer LLM通过循环来一次生成一个词元的文本，因此缓存每个步骤的处理结果是一种很好的策略，这样可以避免重复处理工作（这些结果以各种矩阵的形式存储在层中）。    
+· 大部分处理发生在Transformer块中。这些块由两个组件组成，其中一个是前馈神经网络，它能够存储信息，并根据训练数据进行预测和插值。    
+· Transformer块的另一个主要组件是自注意力。自注意力整合了上下文信息，使模型能够更好地捕捉语言的细微差别。    
+· 注意力过程分为两个主要步骤：相关性评分；信息组合。    
+· Transformer的自注意力层并行执行多个注意力操作，每个操作都发生在注意力头内，它们的输出被聚合成自注意力层的输出。    
+· 通过在所有注意力头或一组注意力头（分组查询注意力）之间共享键矩阵和值矩阵，可以加速注意力计算。    
+· Flash Attention等方法通过优化在GPU不同显存系统上的操作方式来加速注意力计算。    
+
+
+
+
+
+
+
+##### 1. 分词化与词表映射
+
+分词化(Tokenization)是自然语言处理(NLP)中的重要概念，它是将段落和句子分割成更小的分词(Token)的过程。    
+
+举一个实际的例子，以下是一个英文句子:    
+
+I want to study LLM.   
+
+为了让机器理解这个句子，对字符串执行分词化，将其分解为独立的单元。使用分词化，我们会得到这样的结果:     
+
+`["I", "want", "to", "study", "LLM", "."]`
+
+将一个句子分解成更小的、独立的部分可以帮助计算机理解句子的各个部分，以及它们在上下文中的作用，这对于进行大量上下文的分析尤其重要。   
+
+每一个分词(token)都会通过预先设置好的词表，映射为一个tokenid，这是token的身份证，这样一句话最终会被表示为一个元素为tokenid的列表，供给计算机进行下一步处理。
+
+
+
+##### 2. 文本生成过程
+
+
+大模型的工作概括来说是根据给定的文本预测下一个token。 
+
+对于我们来说，看似像在对大模型提问，但实际上是给了大模型一串提示文本，让它可以对后续的文本进行推理。   
+
+大模型的推理过程不是一步到位的，当大模型进行推理时，它会基于现有的token，根据概率最大原则预测出下一个最有可能的token，然后将该预测的token加入到输入序列中，并将更新
+后的输入序列继续输入大模型预测下一个token。
+这个概率则是我们用很多的文本，分词为token以后训练大模型得来的。   
+
+
+
+### LLM
+
+
+LLM大模型训练流程:    
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/llm_training_process.png?raw=true)        
+
+
+
+
+
+### 提示工程
+
+提示工程(Prompt Engineering)是一项通过优化提示词(Prompt)和生成策略，从而获得更好的模型返回结果的工程技术。    
+
+提示词(Prompt)  --> 大语言模型(LLM) -->  返回结果(Completion)
+
+- 好的Prompt需要不断优化
+- 说清楚自己到底想要什么，要具体
+- 不要让机器去猜测太多，为了不让机器去猜测，我们就需要告诉细节
+- 提示工程有一些技巧，灵活掌握，事半功倍。   
+
+
+一个包含多个组件的复杂提示词示例:     
+![Image](https://raw.githubusercontent.com/CharonChui/Pictures/master/prompt_engie_1.png?raw=true)        
+
+
+
+### GPU
+
+计算资源通常是指系统中可用的GPU（graphics processing unit，图形处理单元，通常称显卡）资源。      
+
+强大的GPU可以加速LLM的训练和使用。在选择GPU时，一个重要的因素是可用的VRAM（video random access memory，视频随机存储器，通常称显存）容量，即GPU上可用的内存量。实践中，显存越大越好。原因是如果没有足够的显存，某些模型根本无法使用。
+
+
+
+### Agent
+
+
+Agent  = LLM + memory + planning skills + tool use 
+
+目前我们构建的系统均按照预设流程执行操作。LLM最具突破性的发展方向在于其自主决策能力。这类能够自主规划行动及其序列的系统被称为智能体(agent)，其核心在于利用语言模型自主制定行动决策。
+
+
+使用语言模型的一个重要步骤是选择模型。查找和下载LLM的一个重要网站是Hugging Face。Hugging Face是著名的Transformers软件包背后的组织，多年来一直推动着语言模型的整体发展。正如其名称所示，该软件包是建立在我们在此前提到过的transformers框架之上的。
+
+
+
+
diff --git "a/MobileAIModel/\351\242\204\350\256\255\347\273\203.md" "b/MobileAIModel/\351\242\204\350\256\255\347\273\203.md"
new file mode 100644
index 00000000..87bf60d2
--- /dev/null
+++ "b/MobileAIModel/\351\242\204\350\256\255\347\273\203.md"
@@ -0,0 +1,11 @@
+预训练
+---
+
+
+
+### 文本分类
+
+
+文本分类是NLP中的一项常见任务。    
+
+该任务的目标是训练一个模型，为输入的文本分配标签或类别。从情感分析和意图识别，到实体提取和语言检测，文本分类在全球范围内被广泛应用